Cómo redondear al número entero más cercano en C #

¿Cómo puedo redondear los valores al número entero más cercano?

Por ejemplo:

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

"Math.Ceiling ()" no me ayuda. ¿Algunas ideas?

Consulte la documentación oficial para obtener más información. Por ejemplo:

Básicamente le das al Math.Roundmétodo tres parámetros.

1. El valor que desea redondear.
2. El número de decimales que desea mantener después del valor.
3. Un parámetro opcional que puede invocar para utilizar el redondeo AwayFromZero. ( ignorado a menos que el redondeo sea ambiguo, por ejemplo, 1,5 )

Código de muestra:

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

Demo en vivo

Necesita MidpointRounding.AwayFromZerosi desea redondear un valor de .5. Desafortunadamente, este no es el comportamiento predeterminado de Math.Round(). Si utiliza MidpointRounding.ToEven(el valor predeterminado), el valor se redondea al número par más cercano ( 1.5se redondea a 2, pero 2.5también se redondea a 2).

Math.Ceiling

siempre redondea (hacia el techo)

Math.Floor

siempre redondea hacia abajo (hacia el suelo)

lo que buscas es simplemente

Math.Round

que rondas según esta publicación

Necesitas Math.Round, no Math.Ceiling. Ceilingsiempre "redondea" hacia arriba, mientras que Roundredondea hacia arriba o hacia abajo según el valor después del punto decimal.

hay este manual, y también una forma un poco linda:

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

simplemente agregue 0.5 a cualquier número, y échelo a int (o al piso) y se redondeará matemáticamente correctamente: D

Puede usar Math.Round como otros han sugerido (recomendado), o puede agregar 0.5 y convertir a un int (que eliminará la parte decimal).

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

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

Simplemente un recordatorio. Cuidado con el doble.

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

Tienes la función Math.Round que hace exactamente lo que quieres.

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

esto se redondeará al 5 más cercano o no cambiará si ya es divisible por 5

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

Estaba buscando esto, pero mi ejemplo fue tomar un número, como 4.2769 y colocarlo en un intervalo como solo 4.3. No es exactamente lo mismo, pero si esto ayuda:

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

Luego:

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

etc ...

Utilizar Math.Round:

double roundedValue = Math.Round(value, 0)

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

Dará resultado:

var roundedVal = 3

Si trabaja con números enteros en lugar de números de punto flotante, este es el camino.

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

Aquí tanto "numr" como "denr" son enteros sin signo.

Usar Math.Round(number)redondea al número entero más cercano.

Escribe tu propio método circular. Algo como,

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