que - isnan matlab

Las variables contienen metadatos adicionales ocultos, también conocido como When is zero not zero(pero aún lo es)

Question

Odio tener que preguntar esto porque asumo que la respuesta debe ser simple, pero no puedo, por mi vida, seguir la fuente. Al intentar reescribir una función, encontré este problema:

a = -j
x = real(a)  
y = imag(a)
y/x

Lo que escupe Inf , inesperadamente para mí. Sin embargo...

a = 0
b = -1
b/a

regresa -Inf , como yo esperaría. Indagando más, a == x , b == y . Claramente, eso no es verdad sin embargo. Finalmente encontré el problema después de mucha frustración. Si la entrada original para a es en cambio 0-j (vs. -j ) entonces no hay problema.

Tanto real(-j) como real(0-j) devuelven cero y se prueban como cero, pero obviamente parecen retener algunos metadatos relacionados con su origen que no puedo descubrir. ¿Qué es precisamente lo que me falta aquí? Se sentirá francamente mal si tengo que resolver esto con algo como if (x == 0) then x = 0;

Answer 1

Cuando se usan números de coma flotante IEEE 754, existe una convención de tener un número que se aproxima a cero que no puede representarse con el flotador más pequeño posible llamado subdesbordamiento, donde la precisión del número se pierde con cada paso por debajo del flotador más pequeño posible. Algunos sistemas operativos considerarán que el underflow es igual a cero.

Me sorprendió probar algún software y descubrí que una prueba de umbral de cero en realidad estaba por debajo de cero casi tan lejos como el flotador negativo más pequeño posible.

Tal vez es por eso que obtener un infinito negativo en lugar de un error de dividir por cero que asumo es el problema al que se refiere.

Answer 2

No metadatos, solo el signo de la flotación de doble precisión.

>> a = 0-j;
>> b = -j;
>> ra = real(a)
ra =
     0
>> rb = real(b)
rb =
     0
>> ra==0
ans =
     1
>> isequal(ra,rb)
ans =
     1

Se ve lo mismo hasta ahora. Sin embargo, la diferencia es que con b , establecemos el bit de signo para las partes real e imaginaria cuando hacemos -j = -complex(0,1) vs. 0-j = complex(0,-1) (vea Crear Números complejos ). Mirando más profundo con typecast , que no convierte los datos subyacentes:

>> dec2bin(typecast(ra,''uint64''),64)
ans =
0000000000000000000000000000000000000000000000000000000000000000
>> dec2bin(typecast(rb,''uint64''),64)
ans =
1000000000000000000000000000000000000000000000000000000000000000

Ese 1 es el bit 63 (de 0) en la representación de coma flotante de precisión doble IEEE 754 :

Voila! -0 existe en MATLAB también!