java - valor - operadores de incrementos
¿Cómo alterar un flotador por su menor incremento en Java? (6)
Tengo un double valor d y me gustaría una forma de empujarlo ligeramente más grande (o más pequeño) para obtener un nuevo valor que sea lo más cercano posible al original pero aún estrictamente mayor que (o menor que) el original.
No tiene que estar cerca del último bit, es más importante que cualquier cambio que haga esté garantizado para producir un valor diferente y no redondear al original.
(Esta pregunta ha sido formulada y contestada para C, C ++)
La razón por la que necesito esto, es que estoy asignando desde Doble a (algo), y puedo tener varios elementos con el doble "valor" de guardar, pero todos deben ir individualmente al mapa.
Mi código actual (que hace el trabajo) se ve así:
private void putUniqueScoreIntoMap(TreeMap map, Double score,
A entry) {
int exponent = 15;
while (map.containsKey(score)) {
Double newScore = score;
while (newScore.equals(score) && exponent != 0) {
newScore = score + (1.0d / (10 * exponent));
exponent--;
}
if (exponent == 0) {
throw new IllegalArgumentException("Failed to find unique new double value");
}
score = newScore;
}
map.put(score, entry);
}
¿Ha considerado utilizar una estructura de datos que permita múltiples valores almacenados bajo la misma clave (por ejemplo, un árbol binario) en lugar de intentar piratear el valor de la clave?
¿Qué hay de usar Double.MIN_VALUE ?
En Java 1.6 y Math.nextAfter(double, double) posteriores, el Math.nextAfter(double, double) es la forma más limpia de obtener el siguiente valor double después de un valor double dado.
El segundo parámetro es la dirección que desee. Alternativamente, puede usar Math.nextUp(double) (Java 1.6 y Math.nextUp(double) posteriores) para obtener el siguiente número más grande y, desde Java 1.8, también puede usar Math.nextDown(double) para obtener el siguiente número más pequeño. Estos dos métodos son equivalentes a usar nextAfter con infinito positivo o negativo como la dirección doble.
Específicamente, Math.nextAfter(score, Double.MAX_VALUE) le dará la respuesta en este caso.
Use Double.doubleToRawLongBits y Double.longBitsToDouble :
double d = // your existing value;
long bits = Double.doubleToLongBits(d);
bits++;
d = Double.longBitsToDouble(bits);
La forma en que funciona IEEE-754, le dará exactamente el siguiente doble viable, es decir, la cantidad más pequeña mayor que el valor existente.
(Eventualmente llegará a NaN y probablemente se quedará allí, pero debería funcionar con valores razonables).
Utilice Double.MIN_VALUE.
El javadoc para ello:
A constant holding the smallest positive nonzero value of type double, 2-1074. It is equal to the hexadecimal floating-point literal 0x0.0000000000001P-1022 and also equal to Double.longBitsToDouble(0x1L).
d += Double.MIN_VALUE
(o -= si quieres quitarlo)