Algoritmo .Net incorporato per arrotondare il valore all'intervallo 10 più vicino

Question

Come, in C #, arrotondare qualsiasi valore a un intervallo di 10? Ad esempio, se ho 11, voglio che restituisca 10, se ne ho 136, quindi voglio che restituisca 140.

Posso facilmente farlo a mano

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

Ma sto cercando un algoritmo incorporato per fare questo lavoro, qualcosa come Math.Round (). Il motivo per cui non voglio fare a mano è che non voglio scrivere codice uguale o simile in tutti i miei progetti, anche per qualcosa di semplice come sopra.

Answer 1

Non esiste una funzione integrata nella libreria di classi che lo farà. Il più vicino è System.Math.Round () quale serve solo per arrotondare i numeri di tipo Decimale e Doppio al valore intero più vicino. Tuttavia, puoi concludere la tua dichiarazione in un metodo di estensione, se lavori con .NET 3.5, che ti permetterà di usare la funzione in modo molto più pulito.

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

Se stai programmando con una versione precedente di .NET framework, rimuovi semplicemente " questo " dalla funzione RoundOff e chiama la funzione in questo modo:

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

Answer 2

Usa Math.Ceiling per arrotondare sempre.

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

Il modulo (%) ottiene il resto, quindi ottieni:

// number = 236 + 10 - 6

Inseriscilo in un metodo di estensione

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();

sopra modificato: avrei dovuto seguire il mio primo istinto per usare Math.Ceiling

I ho scritto un blog al riguardo durante il calcolo delle cifre di controllo UPC .

Answer 3

Potrebbe essere un po 'troppo tardi, ma credo che un giorno potrebbe essere di grande aiuto ...

Ho provato questo:

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

Per usare:

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

In questo modo, hai la possibilità se la metà dell'intervallo verrà arrotondata per eccesso o per difetto. =)

Answer 4

Arrotondare un float a un numero intero è simile a (int) (x + 0,5), al contrario del semplice lancio di x - se vuoi un multiplo di 10, puoi facilmente adattarlo.

Se vuoi solo fare i numeri interi e arrotondarli a dieci, prova (x + 10/2) / 10 * 10.

Modifica: ho notato che questa risposta non soddisfa la richiesta dell'autore originale, ed è anche una forma distorta di arrotondamento che preferisco non fare. Tuttavia, un'altra risposta accettata ha già dichiarato Math.round (), una soluzione molto migliore.

Answer 5

Vecchia domanda, ma qui è un modo per fare ciò che è stato chiesto e l'ho esteso per poter arrotondare qualsiasi numero al numero di siggoli che desideri.

    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

Preferisco non portare la libreria Math né andare in virgola mobile, quindi il mio suggerimento è di fare l'aritmetica intera come sotto, dove arrotolo per il prossimo 1K. Avvolgilo con un metodo o uno snippet lambda o qualcosa del genere se non vuoi ripetere.

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

Non ho eseguito test delle prestazioni su questo contro altri modi, ma scommetto che è il modo più veloce per farlo, forse una versione di spostamento e rotazione dei bit di questo.