Algoritmo .Net incorporado para redondear el valor al intervalo 10 más cercano

Question

¿Cómo, en C # redondear cualquier valor a 10 intervalos? Por ejemplo, si tengo 11, quiero que devuelva 10, si tengo 136, entonces quiero que devuelva 140.

Puedo hacerlo fácilmente a mano

return ((int)(number / 10)) * 10;

Pero estoy buscando un algoritmo incorporado para hacer este trabajo, algo así como Math.Round (). La razón por la que no querré hacerlo a mano es que no quiero escribir el mismo código o un código similar en todos mis proyectos, incluso para algo tan simple como lo anterior.

Answer 1

No hay una función integrada en la biblioteca de clases que haga esto. El más cercano es System.Math.Round () que es solo para redondear números de tipos Decimal y Double al valor entero más cercano. Sin embargo, puede resumir su declaración en un método de extensión, si está trabajando con .NET 3.5, lo que le permitirá utilizar la función de manera mucho más limpia.

public static class ExtensionMethods
{
    public static int RoundOff (this int i)
    {
        return ((int)Math.Round(i / 10.0)) * 10;
    }
}

int roundedNumber = 236.RoundOff(); // returns 240
int roundedNumber2 = 11.RoundOff(); // returns 10

Si está programando en una versión anterior de .NET framework, simplemente elimine " this " desde la función RoundOff, y llame a la función así:

int roundedNumber = ExtensionMethods.RoundOff(236); // returns 240
int roundedNumber2 = ExtensionMethods.RoundOff(11); // returns 10

Answer 2

Use Math.Ceiling para redondear siempre.

int number = 236;
number = (int)(Math.Ceiling(number / 10.0d) * 10);

El módulo (%) obtiene el resto, por lo que obtiene:

// number = 236 + 10 - 6

Poner eso en un método de extensión

public static int roundupbyten(this int i){
    // return i + (10 - i % 10); <-- logic error. Oops!
    return (int)(Math.Ceiling(i / 10.0d)*10); // fixed
}

// call like so:
int number = 236.roundupbyten();

editado anteriormente: debería haber ido con mi primer instinto de usar Math.Ceiling

I blogueó sobre esto al calcular los dígitos de verificación UPC .

Answer 3

Esto podría ser demasiado tarde, pero supongo que algún día podría ser de gran ayuda ...

He intentado esto:

public int RoundOff(int number, int interval){
    int remainder = number % interval;
    number += (remainder < interval / 2) ? -remainder : (interval - remainder);
    return number;
}

Para usar:

int number = 11;
int roundednumber = RoundOff(number, 10);

De esta manera, tiene la opción de si la mitad del intervalo se redondeará hacia arriba o hacia abajo. =)

Answer 4

Redondear un flotante a un entero es similar a (int) (x + 0.5), en lugar de simplemente emitir x: si desea un múltiplo de 10, puede adaptarlo fácilmente.

Si solo quieres hacer matemática entera y la estás redondeando a diez, prueba (x + 10/2) / 10 * 10.

Editar: me di cuenta de que esta respuesta no cumple con la solicitud del autor original, y también es una forma sesgada de redondeo que prefiero no hacer. Sin embargo, otra respuesta aceptada ya decía Math.round (), una solución mucho mejor.

Answer 5

Antigua pregunta, pero aquí hay una manera de hacer lo que se le ha pedido, además la extendí para poder redondear cualquier número a la cantidad de higos que desee.

    private double Rounding(double d, int digits)
    {
        int neg = 1;
        if (d < 0)
        {
            d = d * (-1);
            neg = -1;
        }

        int n = 0;
        if (d > 1)
        {
            while (d > 1)
            {
                d = d / 10;
                n++;
            }
            d = Math.Round(d * Math.Pow(10, digits));
            d = d * Math.Pow(10, n - digits);
        }
        else
        {
            while (d < 0.1)
            {
                d = d * 10;
                n++;
            }
            d = Math.Round(d * Math.Pow(10, digits));
            d = d / Math.Pow(10, n + digits);
        }

        return d*neg;
    }


   private void testing()
   {
       double a = Rounding(1230435.34553,3);
       double b = Rounding(0.004567023523,4);
       double c = Rounding(-89032.5325,2);
       double d = Rounding(-0.123409,4);
       double e = Rounding(0.503522,1);
       Console.Write(a.ToString() + "\n" + b.ToString() + "\n" + 
           c.ToString() + "\n" + d.ToString() + "\n" + e.ToString() + "\n");
   }

Answer 6

Prefiero no traer la biblioteca Math ni ir a coma flotante, por lo que mi sugerencia es simplemente hacer aritmética de enteros como a continuación, donde redondeo al siguiente 1K. Envuélvelo en un método o fragmento de lambda o algo así si no quieres repetir.

int MyRoundedUp1024Int = ((lSomeInteger + 1023) / 1024) * 1024;

No he realizado pruebas de rendimiento en este frente a otras formas, pero apuesto a que es la forma más rápida de hacer esto, salvo tal vez una versión cambiante y giratoria de bits.