Jak zaokrąglić do najbliższej liczby całkowitej w języku C #

Jak zaokrąglić wartości do najbliższej liczby całkowitej?

Na przykład:

1.1 => 1
1.5 => 2
1.9 => 2

„Math.Ceiling ()” mi nie pomaga. Jakieś pomysły?

Więcej informacji znajdziesz w oficjalnej dokumentacji . Na przykład:

Zasadniczo podajesz Math.Roundmetodzie trzy parametry.

1. Wartość, którą chcesz zaokrąglić.
2. Liczba miejsc po przecinku, które chcesz zachować po wartości.
3. Opcjonalny parametr, który można wywołać, aby użyć zaokrąglania AwayFromZero. ( ignorowane, chyba że zaokrąglenie jest niejednoznaczne, np. 1,5 )

Przykładowy kod:

var roundedA = Math.Round(1.1, 0); // Output: 1
var roundedB = Math.Round(1.5, 0, MidpointRounding.AwayFromZero); // Output: 2
var roundedC = Math.Round(1.9, 0); // Output: 2
var roundedD = Math.Round(2.5, 0); // Output: 2
var roundedE = Math.Round(2.5, 0, MidpointRounding.AwayFromZero); // Output: 3
var roundedF = Math.Round(3.49, 0, MidpointRounding.AwayFromZero); // Output: 3

Live Demo

Potrzebujesz, MidpointRounding.AwayFromZerojeśli chcesz, aby wartość 0,5 została zaokrąglona w górę. Niestety nie jest to domyślne zachowanie Math.Round(). Jeśli używasz MidpointRounding.ToEven(domyślnie), wartość jest zaokrąglana do najbliższej liczby parzystej ( 1.5jest zaokrąglana do 2, ale 2.5jest również zaokrąglana do 2).

Math.Ceiling

zawsze zaokrągla w górę (w kierunku sufitu)

Math.Floor

zawsze zaokrągla w dół (w kierunku podłogi)

to, czego szukasz, jest po prostu

Math.Round

który zaokrągla zgodnie z tym postem

Trzeba Math.Round, nie Math.Ceiling. Ceilingzawsze „zaokrągla” w górę, podczas gdy Roundzaokrągla w górę lub w dół w zależności od wartości po przecinku.

jest ten podręcznik i całkiem ładny sposób:

double d1 = 1.1;
double d2 = 1.5;
double d3 = 1.9;

int i1 = (int)(d1 + 0.5);
int i2 = (int)(d2 + 0.5);
int i3 = (int)(d3 + 0.5);

po prostu dodaj 0,5 do dowolnej liczby i rzuć ją na int (lub podłogę), a zostanie matematycznie poprawnie zaokrąglona: D

Możesz użyć Math.Round tak, jak sugerowali inni (zalecane), lub możesz dodać 0,5 i rzutować na int (co spowoduje usunięcie części dziesiętnej).

double value = 1.1;
int roundedValue = (int)(value + 0.5); // equals 1

double value2 = 1.5;
int roundedValue2 = (int)(value2 + 0.5); // equals 2

Tylko przypomnienie. Uważaj na podwójne.

Math.Round(0.3 / 0.2 ) result in 1, because in double 0.3 / 0.2 = 1.49999999
Math.Round( 1.5 ) = 2

Masz funkcję Math.Round, która robi dokładnie to, co chcesz.

Math.Round(1.1) results with 1
Math.Round(1.8) will result with 2.... and so one.

Zaokrągli to w górę do najbliższej 5 lub nie zmieni się, jeśli jest już podzielne przez 5

public static double R(double x)
{
    // markup to nearest 5
    return (((int)(x / 5)) * 5) + ((x % 5) > 0 ? 5 : 0);
}

Szukałem tego, ale moim przykładem było wzięcie liczby, takiej jak 4,2769 i upuszczenie jej w przedziale zaledwie 4,3. Niezupełnie to samo, ale jeśli to pomoże:

Model.Statistics.AverageReview   <= it's just a double from the model

Następnie:

@Model.Statistics.AverageReview.ToString("n1")   <=gives me 4.3
@Model.Statistics.AverageReview.ToString("n2")   <=gives me 4.28

itp...

Zastosowanie Math.Round:

double roundedValue = Math.Round(value, 0)

var roundedVal = Math.Round(2.5, 0);

Da wynik:

var roundedVal = 3

Jeśli pracujesz z liczbami całkowitymi zamiast liczb zmiennoprzecinkowych, oto sposób.

#define ROUNDED_FRACTION(numr,denr) ((numr/denr)+(((numr%denr)<(denr/2))?0:1))

Tutaj zarówno „numr”, jak i „denr” są liczbami całkowitymi bez znaku.

Korzystanie z Math.Round(number)rund do najbliższej liczby całkowitej.

Napisz własną metodę rundy. Coś jak,

function round(x) rx = Math.ceil(x) if (rx - x <= .000001) return int(rx) else return int(x) end

decimal RoundTotal = Total - (int)Total;
if ((double)RoundTotal <= .50)
   Total = (int)Total;
else
   Total = (int)Total + 1;
lblTotal.Text = Total.ToString();