español - Java For-loop cambia el resultado numérico al cambiar el tipo de variable de ciclo

for loop java español

Question

Escribí un programa para calcular el número de PI con la fórmula de Leibniz:

[

Escribí un for-loop con el tipo de inicialización es "int", el ciclo funciona bien, pero cuando cambié el tipo de inicialización a "largo", el resultado cambia. Esto solo ocurre cuando el ciclo supera los mil millones. Esto hace que "int - loop" calcule PI más preciso que "bucle largo". No sé por qué sucede esto. Por favor, ayúdame a entender este problema. ¡Gracias! y aquí está mi código.

public static void main(String[] args) {
    double result1 = 0;
    double result2 = 0;
    double sign = 1;

    for (int i = 0; i <= 1607702095; i++) {
        result1 += sign/(2 * i + 1);
        sign *= -1;
    }
    sign = 1;

    for (long j = 0; j <= 1607702095; j++) {
        result2 += sign/(2 * j + 1);
        sign *= -1;
    }

    System.out.println("result1  " + result1 * 4);
    System.out.println("result2  " + result2 * 4);
    System.out.println("pi       " + Math.PI);
}

Y el resultado es:

result1  3.141592653576877
result2  3.1415926529660116
pi       3.141592653589793

Answer 1

Advirtió que todo el mundo apunta al desbordamiento de enteros, pero es posible que desee una solución. (Si ya tiene una, ignore lo siguiente :))

Teniendo el desbordamiento en la parte (2 * i + 1) del código, debe maximizar el i en el ciclo for para (Integer.MAX_VALUE / 2 - 1) , lo que da como resultado:

for (int i = 0; i <= (Integer.MAX_VALUE / 2 - 1); i++) {
    result1 += sign/(2 * i + 1);
    sign *= -1;
}

También puede hacer eso en la parte larga con (Long.MAX_VALUE / 2 - 1) pero se ejecutará durante MUY LARGO tiempo.

Answer 2

En realidad, su primer ciclo tendría desbordamiento int en el cálculo de (2 * i + 1) cuando i sea ​​lo suficientemente grande, por lo que no confiaría en la salida del mismo.

El segundo ciclo, por otro lado, produce una salida más correcta, ya que (2 * j + 1) no se desborda, ya que realiza long multiplicación long .

Esto hace que "int-loop" calcule PI más preciso que "long-loop"

Probablemente sea solo una coincidencia, ya que los cálculos en el bucle int desbordan.

Answer 3

Porque estás recibiendo un desbordamiento en la línea

result1 += sign/(2 * i + 1);

Donde el valor de 2*i cruza el valor entero máximo

el rango int es -2,147,483,648 to 2,147,483,647 pero cuando se hace 2*i para un valor mayor, se cruza ese rango.

Es mejor quedarse con el long y eso le da salida correcta.

Answer 4

Tienes un desbordamiento de enteros .

La capacidad máxima de un int firmado es (2 ^ 31) -1, o 2,147,483,647.

(1,607,702,095 * 2) es 3215404190, que es más grande que 2,147,483,647.

Cuando cambias i a un valor largo, aumentas la capacidad de i a (2 ^ 63) -1.

Answer 5

2 * i cuando estoy cerca del final de su ciclo, desborde el valor máximo int que es 2147483647

Usar una operación larga que no se desborde.

El procedimiento correcto es usar un tipo largo. Probablemente debido a que los valores se agregan y eliminan alrededor del PI correcto para algún comportamiento extraño, los desbordamientos calculan momentaneamente a un valor más cercano al PI correcto.

Supongo que cambiar el límite del bucle for de algunos valores cambiará el resultado final a un valor que esté más alejado del PI correcto.