¿Cómo implementar el infinito en Java?

¿Java tiene algo que represente el infinito para cada tipo de datos numéricos? ¿Cómo se implementa de modo que pueda realizar operaciones matemáticas con él?

P.ej

int myInf = infinity; //However it is done
myInf + 5; //returns infinity
myInf*(-1); //returns negative infinity

He intentado usar números muy grandes, pero quiero una solución adecuada y fácil .

double soporta Infinity

double inf = Double.POSITIVE_INFINITY;
System.out.println(inf + 5);
System.out.println(inf - inf); // same as Double.NaN
System.out.println(inf * -1); // same as Double.NEGATIVE_INFINITY

huellas dactilares

Infinity
NaN
-Infinity

nota: noInfinity - Infinity es un número .

Supongo que estás usando matemáticas enteras por una razón. Si es así, puede obtener un resultado funcionalmente similar al POSITIVE_INFINITY utilizando el campo MAX_VALUE de la Integerclase:

Integer myInf = Integer.MAX_VALUE;

(Y para NEGATIVE_INFINITY, podría usar MIN_VALUE.) Por supuesto, habrá algunas diferencias funcionales, por ejemplo, cuando se compara myInfcon un valor que resulta ser MAX_VALUE: claramente este número no es menor que myInf.

También hay una biblioteca que en realidad tiene campos POSITIVE_INFINITY y NEGATIVE_INFINITY, pero en realidad son nombres nuevos para MAX_VALUE y MIN_VALUE.

Para usar Infinity, puede usar Doublequé soportes Infinity: -

    System.out.println(Double.POSITIVE_INFINITY);
    System.out.println(Double.POSITIVE_INFINITY * -1);
    System.out.println(Double.NEGATIVE_INFINITY);

    System.out.println(Double.POSITIVE_INFINITY - Double.NEGATIVE_INFINITY);
    System.out.println(Double.POSITIVE_INFINITY - Double.POSITIVE_INFINITY);

SALIDA : -

Infinity
-Infinity
-Infinity

Infinity 
NaN

Los tipos Doubley Floattienen la POSITIVE_INFINITYconstante.

No estoy seguro de que Java tenga infinito para cada tipo numérico, pero para algunos tipos de datos numéricos la respuesta es positiva:

Float.POSITIVE_INFINITY
Float.NEGATIVE_INFINITY

o

Double.POSITIVE_INFINITY
Double.NEGATIVE_INFINITY

También puede resultarle útil el siguiente artículo, que representa algunas operaciones matemáticas que involucran +/- infinito: complejidades de números de punto flotante de Java .

Solo el tipo Double y Float admite POSITIVE_INFINITYconstante.

Para los tipos de envoltorio numérico.

por ejemplo, Double.POSITVE_INFINITY

Espero que esto te pueda ayudar.

Una solución genérica es introducir un nuevo tipo. Puede estar más involucrado, pero tiene la ventaja de trabajar para cualquier tipo que no defina su propio infinito.

Si Tes un tipo para el que lteqestá definido, puede definirlo InfiniteOr<T>con lteqalgo como esto:

class InfiniteOr with type parameter T:
    field the_T of type null-or-an-actual-T
    isInfinite()
        return this.the_T == null
    getFinite():
        assert(!isInfinite());
        return this.the_T
    lteq(that)
        if that.isInfinite()
            return true
        if this.isInfinite()
            return false
        return this.getFinite().lteq(that.getFinite())

Dejaré que traduzca esto a la sintaxis exacta de Java. Espero que las ideas sean claras; pero déjame deletrearlos de todos modos.

La idea es crear un nuevo tipo que tenga todos los mismos valores que algunos tipos ya existentes, más un valor especial que, por lo que puede ver a través de métodos públicos, actúa exactamente de la manera en que desea que actúe el infinito, por ejemplo, es mayor que Algo más. Estoy usando nullpara representar el infinito aquí, ya que eso parece lo más sencillo en Java.

Si desea agregar operaciones aritméticas, decida qué deben hacer, luego implemente eso. Probablemente sea más simple si maneja los casos infinitos primero y luego reutiliza las operaciones existentes en valores finitos del tipo original.

Puede haber o no un patrón general para determinar si es beneficioso o no adoptar una convención para manejar los infinitos del lado izquierdo antes que los infinitos del lado derecho o viceversa; No puedo decirlo sin probarlo, pero para menos que o igual ( lteq) creo que es más simple mirar primero el infinito del lado derecho. Tomo nota de que lteqes no conmutativo, pero addy mulson; Quizás eso sea relevante.

Nota: proponer una buena definición de lo que debería suceder en valores infinitos no siempre es fácil. Es para comparación, suma y multiplicación, pero tal vez no para resta. Además, hay una distinción entre los números cardinales y ordinales infinitos a los que puede prestar atención.

Como el número de clase no es definitivo, aquí hay una idea que aún no encuentro en las otras publicaciones. A saber, subclasificar el número de clase.

Esto de alguna manera entregaría un objeto que puede ser tratado como infinito para Integer, Long, Double, Float, BigInteger y BigDecimal.

Como solo hay dos valores, podríamos usar el patrón singleton:

public final class Infinity extends Number {
    public final static Infinity POSITIVE = new Infinity(false);
    public final static Infinity NEGATIVE = new Infinity(true);
    private boolean negative;
    private Infinity(boolean n) {
        negative = n;
    }
}

De alguna manera, creo que los métodos restantes intValue (), longValue () etc. deberían ser anulados para arrojar excepciones. Para que el valor de infinito no se pueda usar sin más precauciones.

Soy un principiante en Java ... Encontré otra implementación para el infinito en la documentación de Java, para los tipos booleany double. https://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.2.3

El cero positivo y el cero negativo se comparan igual; así, el resultado de la expresión 0.0 == - 0.0 es verdadero y el resultado de 0.0> -0.0 es falso. Pero otras operaciones pueden distinguir cero positivo y cero; por ejemplo, 1.0 / 0.0 tiene el valor infinito positivo, mientras que el valor de 1.0 / -0.0 es infinito negativo.

Se ve feo, pero funciona.

public class Main {

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

}