¿Para qué valor de i hace while (i == i + 1) {} bucle para siempre?

Crucé este rompecabezas de un curso de programación avanzada en un examen universitario del Reino Unido .

Considere el siguiente ciclo, en el que, hasta ahora, no está declarado:

while (i == i + 1) {}

Encuentre la definición de i, que precede a este bucle, de modo que el bucle while continúe para siempre.

La siguiente pregunta, que hizo la misma pregunta para este fragmento de código:

while (i != i) {}

fue obvio para mí. Por supuesto que en esta otra situación lo es, NaNpero estoy realmente atascado en la anterior. ¿Tiene esto que ver con el desbordamiento? ¿Qué haría que tal bucle se repita para siempre en Java?

En primer lugar, dado que el while (i == i + 1) {}ciclo no cambia el valor de i, hacer que este ciclo sea infinito es equivalente a elegir un valor de ique satisfaga i == i + 1.

Hay muchos valores de este tipo:

Empecemos por los "exóticos":

double i = Double.POSITIVE_INFINITY;

o

double i =  Double.NEGATIVE_INFINITY;

La razón por la que estos valores son satisfactorios i == i + 1se establece en
JLS 15.18.2. Operadores aditivos (+ y -) para tipos numéricos :

La suma de un valor infinito y finito es igual al operando infinito.

Esto no es sorprendente, ya que agregar un valor finito a un valor infinito debería resultar en un valor infinito.

Dicho esto, la mayoría de los valores ique satisfacen i == i + 1son simplemente valores grandes double(o float):

Por ejemplo:

double i = Double.MAX_VALUE;

o

double i = 1000000000000000000.0;

o

float i = 1000000000000000000.0f;

Los tipos doubley floattienen una precisión limitada, por lo que si toma un valor doubleo lo suficientemente grande float, agregarlo 1dará como resultado el mismo valor.

Estos rompecabezas se describen en detalle en el libro "Java Puzzlers: Traps, Pitfalls, and Corner Cases" de Joshua Bloch y Neal Gafter.

double i = Double.POSITIVE_INFINITY;
while (i == i + 1) {}

o:

double i = 1.0e40;
while (i == i + 1) {}

ambos darán como resultado un bucle infinito, porque agregar 1a un valor de coma flotante que sea suficientemente grande no cambiará el valor, porque no "cierra la brecha" con su sucesor ¹ .

Una nota sobre el segundo acertijo (para futuros lectores):

double i = Double.NaN;
while (i != i) {}

también da como resultado un bucle infinito, porque NaN no es igual a ningún valor de punto flotante, incluido él mismo ² .

^{1 - Rompecabezas de Java: trampas, trampas y casos de esquina (capítulo 4 - Rompecabezas de loopy).}

^{2 - JLS §15.21.1}

double i = Double.POSITIVE_INFINITY;

Solo una idea: ¿qué pasa con los booleanos?

bool i = TRUE;

¿No es este un caso donde i + 1 == i?