¿Por qué i = i + me doy 0?

Tengo un programa simple:

public class Mathz {
    static int i = 1;
    public static void main(String[] args) {    
        while (true){
            i = i + i;
            System.out.println(i);
        }
    }
}

Cuando ejecuto este programa, todo lo que veo es 0para imi salida. Hubiera esperado que la primera ronda lo hiciéramos i = 1 + 1, seguida de i = 2 + 2, seguida de, i = 4 + 4etc.

¿Se debe esto al hecho de que tan pronto como intentamos volver a declarar ien el lado izquierdo, su valor se restablece a 0?

Si alguien puede señalarme los detalles más finos de esto, sería genial.

Cambie inta longy parece estar imprimiendo números como se esperaba. ¡Me sorprende lo rápido que alcanza el valor máximo de 32 bits!

El problema se debe al desbordamiento de enteros.

En aritmética de complemento a dos de 32 bits:

ide hecho, comienza con valores de potencia de dos, pero luego los comportamientos de desbordamiento comienzan una vez que llega a 2 ³⁰ :

2 ³⁰ + 2 ³⁰ = -2 ³¹

-2 ³¹ + -2 ³¹ = 0

... en intaritmética, ya que es esencialmente aritmética mod 2 ^ 32.

Introducción

El problema es el desbordamiento de enteros. Si se desborda, vuelve al valor mínimo y continúa desde allí. Si se desborda, vuelve al valor máximo y continúa desde allí. La siguiente imagen es de un odómetro. Utilizo esto para explicar los desbordamientos. Es un desbordamiento mecánico, pero sigue siendo un buen ejemplo.

En un odómetro, el max digit = 9, yendo más allá de los medios máximos 9 + 1, que se traslada y da un 0; Sin embargo, no hay un dígito más alto para cambiar a a 1, por lo que el contador se restablece zero. Entiendes la idea: ahora me vienen a la mente los "desbordamientos de enteros".

El literal decimal más grande de tipo int es 2147483647 (2 ³¹ -1). Todos los literales decimales de 0 a 2147483647 pueden aparecer en cualquier lugar donde pueda aparecer un literal int, pero el literal 2147483648 puede aparecer solo como el operando del operador de negación unario -.

Si una suma entera se desborda, entonces el resultado son los bits de orden inferior de la suma matemática representados en algún formato de complemento a dos suficientemente grande. Si se produce un desbordamiento, el signo del resultado no es el mismo que el signo de la suma matemática de los dos valores de operando.

Por lo tanto, se 2147483647 + 1desborda y se envuelve -2147483648. Por int i=2147483647 + 1lo tanto , se desbordaría, lo que no es igual a 2147483648. Además, dices "siempre imprime 0". No es así, porque http://ideone.com/WHrQIW . A continuación, estos 8 números muestran el punto en el que pivota y se desborda. Luego comienza a imprimir ceros. Además, no se sorprenda de lo rápido que calcula, las máquinas de hoy son rápidas.

268435456
536870912
1073741824
-2147483648
0
0
0
0

Por qué el desbordamiento de enteros "envuelve"

^{PDF original}

No, no imprime solo ceros.

Cámbielo a esto y verá qué pasa.

    int k = 50;
    while (true){
        i = i + i;
        System.out.println(i);
        k--;
        if (k<0) break;
    }

Lo que sucede se llama desbordamiento.

static int i = 1;
    public static void main(String[] args) throws InterruptedException {
        while (true){
            i = i + i;
            System.out.println(i);
            Thread.sleep(100);
        }
    }

sacar:

2
4
8
16
32
64
...
1073741824
-2147483648
0
0

when sum > Integer.MAX_INT then assign i = 0;

Como no tengo suficiente reputación, no puedo publicar la imagen de la salida para el mismo programa en C con salida controlada, puede probar usted mismo y ver que realmente se imprime 32 veces y luego, como se explica debido al desbordamiento i = 1073741824 + 1073741824 cambia a -2147483648 y una adición más está fuera del rango de int y se convierte en Zero.

#include<stdio.h>
#include<conio.h>

int main()
{
static int i = 1;

    while (true){
        i = i + i;
      printf("\n%d",i);
      _getch();
    }
      return 0;
}

El valor de ise almacena en la memoria usando una cantidad fija de dígitos binarios. Cuando un número necesita más dígitos de los disponibles, solo se almacenan los dígitos más bajos (los dígitos más altos se pierden).

Sumar ia sí mismo es lo mismo que multiplicar ipor dos. Al igual que se puede multiplicar un número por diez en notación decimal deslizando cada dígito hacia la izquierda y poniendo un cero a la derecha, la multiplicación de un número por dos en notación binaria se puede realizar de la misma manera. Esto agrega un dígito a la derecha, por lo que se pierde un dígito a la izquierda.

Aquí el valor inicial es 1, así que si usamos 8 dígitos para almacenar i(por ejemplo),

• después de 0 iteraciones, el valor es 00000001
• después de 1 iteración, el valor es 00000010
• después de 2 iteraciones, el valor es 00000100

y así sucesivamente, hasta el paso final distinto de cero

• después de 7 iteraciones, el valor es 10000000
• después de 8 iteraciones, el valor es 00000000

No importa cuántos dígitos binarios se asignen para almacenar el número, y no importa cuál sea el valor inicial, eventualmente todos los dígitos se perderán a medida que se desplacen hacia la izquierda. Después de ese punto, continuar duplicando el número no cambiará el número; seguirá estando representado por todos los ceros.

Es correcto, pero después de 31 iteraciones, 1073741824 + 1073741824 no se calcula correctamente y luego imprime solo 0.

Puede refactorizar para usar BigInteger, por lo que su bucle infinito funcionará correctamente.

public class Mathz {
    static BigInteger i = new BigInteger("1");

    public static void main(String[] args) {    

        while (true){
            i = i.add(i);
            System.out.println(i);
        }
    }
}

Para depurar tales casos, es bueno reducir el número de iteraciones en el ciclo. Use esto en lugar de su while(true):

for(int r = 0; r<100; r++)

Luego puede ver que comienza con 2 y duplica el valor hasta que causa un desbordamiento.

Usaré un número de 8 bits como ilustración porque se puede detallar completamente en un espacio corto. Los números hexadecimales comienzan con 0x, mientras que los números binarios comienzan con 0b.

El valor máximo para un entero sin signo de 8 bits es 255 (0xFF o 0b11111111). Si agrega 1, normalmente esperaría obtener: 256 (0x100 o 0b100000000). Pero como son demasiados bits (9), está por encima del máximo, por lo que la primera parte simplemente se elimina, dejándolo con 0 de manera efectiva (0x (1) 00 o 0b (1) 00000000, pero con el 1 eliminado).

Entonces, cuando su programa se ejecuta, obtiene:

1 = 0x01 = 0b1
2 = 0x02 = 0b10
4 = 0x04 = 0b100
8 = 0x08 = 0b1000
16 = 0x10 = 0b10000
32 = 0x20 = 0b100000
64 = 0x40 = 0b1000000
128 = 0x80 = 0b10000000
256 = 0x00 = 0b00000000 (wraps to 0)
0 + 0 = 0 = 0x00 = 0b00000000
0 + 0 = 0 = 0x00 = 0b00000000
0 + 0 = 0 = 0x00 = 0b00000000
...

El literal decimal más grande de tipo intes 2147483648 (= 2 ³¹ ). Todos los literales decimales de 0 a 2147483647 pueden aparecer en cualquier lugar donde pueda aparecer un literal int, pero el literal 2147483648 puede aparecer solo como el operando del operador de negación unario -.

Si una suma entera se desborda, entonces el resultado son los bits de orden inferior de la suma matemática representados en algún formato de complemento a dos suficientemente grande. Si se produce un desbordamiento, el signo del resultado no es el mismo que el signo de la suma matemática de los dos valores de operando.