c# - que - punto flotante plc

Pruebe si un número de coma flotante es un número entero

Question

Este código funciona (C # 3)

double d;
if(d == (double)(int)d) ...;

1. ¿Hay una mejor manera de hacer esto?
2. Por razones extrañas, quiero evitar el doble elenco; ¿Qué formas agradables existen aparte de esto? (incluso si no son tan buenos)

Nota: Varias personas señalaron el punto (importante) de que == a menudo es problemático al recalcular el punto flotante. En este caso, espero valores en el rango de 0 a unos pocos cientos y se supone que son enteros (los no enteros son errores), por lo tanto, si esos puntos "no deberían" ser un problema para mí.

Answer 1

Algo como esto

double d = 4.0;
int i = 4;

bool equal = d.CompareTo(i) == 0; // true

Answer 2

Creo que esto funcionaría:

if (d % 1 == 0) {
  //...
}

Answer 3

Esto le permitirá elegir qué precisión está buscando, más o menos medio tic, para tener en cuenta la deriva de coma flotante. La comparación también es integral, lo cual es bueno.

static void Main(string[] args)
{
    const int precision = 10000;

    foreach (var d in new[] { 2, 2.9, 2.001, 1.999, 1.99999999, 2.00000001 })
    {
        if ((int) (d*precision + .5)%precision == 0)
        {
            Console.WriteLine("{0} is an int", d);
        }
    }
}

y el resultado es

2 is an int
1.99999999 is an int
2.00000001 is an int

Answer 4

No necesita el extra (doble) allí. Esto funciona:

if (d == (int)d) {
 //...
}

Answer 5

Si solo vas a convertirlo, la respuesta de Mike F / Khoth es buena, pero no responde completamente tu pregunta. Si realmente vas a probar, y es realmente importante, te recomiendo implementar algo que incluya un margen de error.

Por ejemplo, si está pensando en dinero y desea probar incluso montos en dólares, podría decir (siguiendo el patrón de Khoth):

if (Math.abs (d - Math.Floor (d + 0.001)) <0.001)

En otras palabras, tome el valor absoluto de la diferencia del valor y su representación entera y asegúrese de que sea pequeña.

Answer 6

Si su doble es el resultado de otro cálculo, probablemente desee algo como:

d == Math.Floor(d + 0.00001);

De esa forma, si ha habido un ligero error de redondeo, igual coincidirá.

Answer 7

Use Math.Truncate ()

Answer 8

d == Math.Floor(d)

hace lo mismo en otras palabras

NB: afortunadamente eres consciente de que debes ser muy cuidadoso al hacer este tipo de cosas; los flotadores / dobles acumularán fácilmente errores minúsculos que hacen que las comparaciones exactas (como esta) fallen sin ninguna razón obvia.

Answer 9

Podrías usar esto

    bool IsInt(double x)
    {
        try
        {
            int y = Int16.Parse(x.ToString());
            return true;
        }
        catch 
        {
            return false;
        }
    }

Answer 10

No puedo responder a la parte específica de C # de la pregunta, pero debo señalar que es probable que te falte un problema genérico con los números de coma flotante.

Generalmente, el entero no está bien definido en las carrozas. Por la misma razón que la igualdad no está bien definida en las carrozas. Los cálculos de punto flotante normalmente incluyen tanto errores de redondeo como de representación.

Por ejemplo, 1.1 + 0.6 != 1.7 .

Sí, así es como funcionan los números flotantes.

Aquí, 1.1 + 0.6 - 1.7 == 2.2204460492503131e-16 .

Estrictamente hablando, lo más parecido a la comparación de igualdad que puede hacer con flotadores es compararlos hasta una precisión elegida .

Si esto no es suficiente, debe trabajar con una representación de número decimal, con una representación numérica de punto flotante con rango de error incorporado, o con cálculos simbólicos.

Answer 11

Para manejar la precisión del doble ...

Math.Abs(d - Math.Floor(d)) <= double.Epsilon

Considere el siguiente caso donde un valor menor que el doble. Epsilon no puede comparar como cero.

// number of possible rounds
const int rounds = 1;

// precision causes rounding up to double.Epsilon
double d = double.Epsilon*.75;

// due to the rounding this comparison fails
Console.WriteLine(d == Math.Floor(d));

// this comparison succeeds by accounting for the rounding
Console.WriteLine(Math.Abs(d - Math.Floor(d)) <= rounds*double.Epsilon);

// The difference is double.Epsilon, 4.940656458412465E-324
Console.WriteLine(Math.Abs(d - Math.Floor(d)).ToString("E15"));

Answer 12

Una prueba simple como ''x == piso (x)'' está matemáticamente asegurada para funcionar correctamente, para cualquier número FP de precisión fija.

Todas las codificaciones FP de precisión fija representan números reales distintos, y así para cada entero x, hay a lo sumo una codificación FP de precisión fija que coincida exactamente.

Por lo tanto, para cada entero x que PUEDA representarse de esa manera, tenemos x == piso (x) necesariamente, ya que el piso (x) por definición devuelve el mayor número de FP y tal que y <= xyy representa un número entero; entonces el piso (x) debe devolver x.