c# - truncar - Construido en.Net algoritmo para redondear el valor al intervalo más cercano 10

truncar decimales c#

Question

¿Cómo, en C # alrededor de cualquier intervalo de valor a 10? 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 quiero hacerlo a mano es que no quiero escribir un código similar o similar en todos mis proyectos, incluso para algo tan simple como el anterior.

Answer 1

Esto podría ser un poco tarde pero supongo que esto podría ser de ayuda algún día ...

He intentado esto:

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

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 2

No hay una función incorporada 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 envolver su resumen en un método de extensión, si está trabajando con .NET 3.5, lo que le permitirá utilizar la función de forma 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 contra una versión anterior de .NET Framework, simplemente elimine el "this" de la función RoundOff y llame a la función de esta manera:

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

Answer 3

Prefiero no traer la biblioteca de Math ni ir al punto flotante, así que mi sugerencia es simplemente hacer cálculos aritméticos enteros, como a continuación, donde redondeo a la siguiente 1K. Envuélvalo en un método o fragmento lambda o algo así si no quiere repetir.

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

No he realizado pruebas de rendimiento en este y en otros aspectos, pero apostaría a que es la forma más rápida de hacerlo, salvo una versión de cambio y rotación de bits.

Answer 4

Redondear un flotador a un entero es similar a (int) (x + 0.5), en oposición a simplemente lanzar x - si quieres un múltiplo de 10, puedes adaptarlo fácilmente.

Si solo quiere hacer cálculos enteros y los redondea a diez, intente con (x + 10/2) / 10 * 10.

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

Answer 5

Una vieja pregunta, pero aquí hay una manera de hacer lo que se ha pedido, además lo extendí para poder redondear cualquier número al número de sig 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

Use Math.Ceiling para redondear siempre.

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

Módulo (%) obtiene el resto, por lo que obtienes:

// number = 236 + 10 - 6

Ponlo 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 arriba: debería haber ido con mi primer instinto para usar Math.Ceiling

Bloggeé sobre esto cuando calculo los dígitos de verificación UPC .