residuo - ¿Por qué la división por cero con números de coma flotante(o precisión doble) no arroja java.lang.ArithmeticException:/por cero en Java

parte entera de una division java

Question

La siguiente declaración arroja java.lang.ArithmeticException: / by zero como obvio.

System.out.println(0/0);

porque el literal 0 se considera un literal int y la división por cero no está permitido en la aritmética de enteros.

El siguiente caso, sin embargo , no lanza ninguna excepción como java.lang.ArithmeticException: / by zero .

int a = 0;
double b = 6.199;
System.out.println((b/a));

Muestra Infinity .

La siguiente instrucción produce NaN (No es un número) sin excepción.

System.out.println(0D/0); //or 0.0/0, or 0.0/0.0 or 0/0.0 - floating point arithmetic.

En este caso, ambos operandos se consideran dobles.

Del mismo modo, las siguientes afirmaciones no arrojan ninguna excepción.

double div1 = 0D/0; //or 0D/0D
double div2 = 0/0D; //or 0D/0D

System.out.printf("div1 = %s : div2 = %s%n", div1, div2);
System.out.printf("div1 == div2 : %b%n", div1 == div2);
System.out.printf("div1 == div1 : %b%n", div1 == div1);
System.out.printf("div2 == div2 : %b%n", div2 == div2);
System.out.printf("Double.NaN == Double.NaN : %b%n", Double.NaN == Double.NaN);
System.out.printf("Float.NaN == Float.NaN : %b%n", Float.NaN == Float.NaN);

Ellos producen la siguiente salida.

div1 = NaN : div2 = NaN
div1 == div2 : false
div1 == div1 : false
div2 == div2 : false
Double.NaN == Double.NaN : false
Float.NaN == Float.NaN : false

Todos ellos devuelven false. ¿Por qué se permite esta operación (división por cero) con números de punto flotante o de precisión doble?

Por cierto, puedo entender que los números de coma flotante (números de precisión doble) tienen sus valores que representan infinito positivo , infinito negativo , no un número ( NaN ) ...

Answer 1

Cuando hay una división por cero, la computadora no puede crear una representación del resultado como un número. La computadora necesita indicar que el resultado no es un número.

Para valores de coma flotante, puede producir un valor centinela especial que no sea un número, porque hay patrones de bits de 32 bits (para float ) y de 64 bits (para double ) que no representan un número, y por lo tanto pueden interpretarse como no-un-número ( NaN ).

Para valores enteros que usan el esquema de complemento de dos a dos (como requiere Java), todos los patrones de bits de 32 bits (para int ) y de 64 bits (para long ) representan un número. Entonces la computadora no puede reportar el problema usando un centinela. Debe informar el problema "fuera de banda" de alguna manera. Lanzar una excepción es el método fuera de banda elegido para Java.

Answer 2

En resumen, así es como se especifica en el estándar IEEE-754, que es en lo que se basan las operaciones de coma flotante de Java.

¿Por qué la división por cero (o desbordamiento, o subdesbordamiento) detiene el programa o desencadena un error? ¿Por qué un estándar en números incluye "not-a-number" (NaN)?

El modelo 754 alienta programas robustos. Está destinado no solo para analistas numéricos sino también para usuarios de hojas de cálculo, sistemas de bases de datos o incluso cafeteras. Las reglas de propagación para NaNs e infinitos permiten que desaparezcan las excepciones sin consecuencia. De manera similar, el subdesbordamiento gradual mantiene las propiedades de error en un rango de precisión.

Cuando las situaciones excepcionales requieren atención, pueden examinarse de inmediato a través de trampas o en un momento conveniente a través de indicadores de estado. Las trampas se pueden usar para detener un programa, pero las situaciones irrecuperables son extremadamente raras. Simplemente detener un programa no es una opción para sistemas embebidos o agentes de red. Con mayor frecuencia, las trampas registran información de diagnóstico o sustituyen resultados válidos.

Las banderas ofrecen un flujo de control y velocidad predecibles. Su uso requiere que el programador tenga en cuenta las condiciones excepcionales, pero la adherencia de la bandera permite a los programadores retrasar el manejo de condiciones excepcionales hasta que sea necesario.

Answer 3

Es así porque así es como lo definió IEEE 754.

La división por un punto flotante 0.0 produce NaN o +/- Inf, dependiendo de si el numerador es 0 o no.

La división por un número entero 0 no está cubierta por IEEE 754, y genera una excepción: no hay otra forma de indicar el error porque un int no puede representar NaN o Inf .

Generar una excepción es similar al INT (software) generado por una división por cero en microprocesadores x86.

Answer 4

Java sigue el estándar IEEE 754 que define valores para devolver por defecto en el caso de una división por cero. http://en.wikipedia.org/wiki/IEEE_754#Exception_handling

División por cero (una operación en operandos finitos da un resultado infinito exacto, por ejemplo, 1/0 o log (0)) (devuelve ± infinito por defecto).

Answer 5

Al infinito y más allá

class DoubleDivision {

    public static void main(String[] args) {
        System.out.println(5.0/0.0);
    }
}

El código anterior y los fragmentos que mencionaste dan infinity .

Por qué Java usa Double s para representar decimales. Binary no puede representar completamente un número, solo puede representar una aproximación y, por lo tanto, tampoco puede duplicar Java.

Imagina un número increíblemente cercano a cero. Si conoce el cálculo, imagine un límite en cero. La variable se acercaría a cero a alguna distancia imaginariamente pequeña pero nunca igual exactamente. Puedes imaginar eso, ¿verdad? Bueno, supongamos que ese número necesita tanta precisión para que Java lo represente, se da por vencido y lo llama 0.0 porque no tiene una buena alternativa. Eso es lo que está sucediendo aquí. Cualquier número regular dividido por un número super cerrado a cero es básicamente infinito . Pruébalo: 5 / (10^-100) .

Consulte también la sección: Valores especiales de coma flotante en Errores matemáticos para obtener más información :)

Pregunta relacionada: ¿por qué 1/0 da error pero 1.0 / 0/0 da inf

ACTUALIZACIÓN: INT no tiene un valor de infinito y NaN en conjunto, mientras que flotante tiene un valor de infinito y NaN . (Según los estándares IEEE 754 que sigue a java)

Answer 6

import java.util.Scanner;

public class Division {

    public static void main(String[] args) {
        int a, b;
        float result;

        Scanner input = new Scanner(System.in);
        System.out.println("Enter value for a : ");
        a = input.nextInt();

        System.out.println("Enter value for b : ");
        b = input.nextInt();

        try {
            /* here we used "if clause" because result will be in float
             note: Here result is in float, so JVM Cant Catch Exception.
             if we Try to Divide with Zero with Float Values It gives Output as
             Divided by Zero is Infinity */
            if (b != 0) {
                result = (float) a / b;
                System.out.println("Result of " + a + " divided by " + b + " is : " + result);
            } else // here result will be in integer so Jvm can easily Catch The Exception
            {
                result = a / b;
            }
        } catch (ArithmeticException e) {
            System.out.println("Sorry Division By Zero Is Not Possible");
        }
    }
}

/* Ouput :
Enter value for a :2
Enter value for b : 7
Result of 2 divided by 7 is : 0.2857143 */

 /* Ouput :
Enter value for a : 16
Enter value for b : 0
Sorry Division By Zero Is Not Possible */