Comment implémenter l'infini en Java?

Java a-t-il quelque chose pour représenter l'infini pour chaque type de données numériques? Comment est-il mis en œuvre pour que je puisse faire des opérations mathématiques avec?

Par exemple

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

J'ai essayé d'utiliser de très grands nombres, mais je veux une solution appropriée et simple .

double prend en charge 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

impressions

Infinity
NaN
-Infinity

Remarque: Infinity - Infinityn'est pas un nombre .

Je suppose que vous utilisez le calcul des nombres entiers pour une raison. Si tel est le cas, vous pouvez obtenir un résultat fonctionnellement presque identique à POSITIVE_INFINITY en utilisant le champ MAX_VALUE de la Integerclasse:

Integer myInf = Integer.MAX_VALUE;

(Et pour NEGATIVE_INFINITY, vous pouvez utiliser MIN_VALUE.) Il y aura bien sûr des différences fonctionnelles, par exemple, lors de la comparaison myInfavec une valeur qui se trouve être MAX_VALUE: clairement ce nombre n'est pas inférieur à myInf.

Il existe également une bibliothèque qui contient en fait les champs POSITIVE_INFINITY et NEGATIVE_INFINITY, mais ce ne sont en réalité que de nouveaux noms pour MAX_VALUE et MIN_VALUE.

Pour l'utiliser Infinity, vous pouvez utiliser Doublequels supports 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);

SORTIE : -

Infinity
-Infinity
-Infinity

Infinity 
NaN

Les types Doubleet Floatont la POSITIVE_INFINITYconstante.

Je ne suis pas sûr que Java ait l'infini pour chaque type numérique, mais pour certains types de données numériques, la réponse est positive:

Float.POSITIVE_INFINITY
Float.NEGATIVE_INFINITY

ou

Double.POSITIVE_INFINITY
Double.NEGATIVE_INFINITY

Vous pouvez également trouver utile l'article suivant qui représente certaines opérations mathématiques impliquant +/- infini: Intricacités de nombres à virgule flottante Java .

Seuls les types Double et Float prennent POSITIVE_INFINITYen charge la constante.

Pour les types d'encapsuleurs numériques.

par exemple Double.POSITVE_INFINITY

J'espère que cela pourrait vous aider.

Une solution générique consiste à introduire un nouveau type. Il est peut-être plus compliqué, mais il a l'avantage de fonctionner pour tout type qui ne définit pas sa propre infinité.

Si Test un type pour lequel lteqest défini, vous pouvez définir InfiniteOr<T>avec lteqquelque chose comme ceci:

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())

Je vous laisse le soin de traduire cela dans la syntaxe Java exacte. J'espère que les idées sont claires; mais laissez-moi les épeler de toute façon.

L'idée est de créer un nouveau type qui a toutes les mêmes valeurs que certains types déjà existants, plus une valeur spéciale qui - pour autant que vous puissiez en juger par les méthodes publiques - agit exactement comme vous voulez que l'infini agisse, par exemple, il est supérieur à rien d'autre. J'utilise nullpour représenter l'infini ici, car cela semble le plus simple en Java.

Si vous souhaitez ajouter des opérations arithmétiques, décidez de ce qu'elles doivent faire, puis implémentez-la. C'est probablement plus simple si vous gérez d'abord les cas infinis, puis réutilisez les opérations existantes sur des valeurs finies du type d'origine.

Il pourrait ou non y avoir un modèle général pour savoir s'il est avantageux ou non d'adopter une convention de gestion des infinis de gauche avant les infinis de droite ou vice versa; Je ne peux pas dire sans l'essayer, mais pour moins que ou égal ( lteq), je pense qu'il est plus simple de regarder d'abord l'infini de droite. Je note que ce lteqn'est pas commutatif, mais addet mulsont; c'est peut-être pertinent.

Remarque: trouver une bonne définition de ce qui doit se passer sur des valeurs infinies n'est pas toujours facile. C'est pour la comparaison, l'addition et la multiplication, mais peut-être pas la soustraction. En outre, il existe une distinction entre les nombres cardinaux et ordinaux infinis auxquels vous voudrez peut-être faire attention.

Puisque la classe Number n'est pas définitive, voici une idée, que je ne trouve pas encore dans les autres articles. À savoir pour sous-classer la classe Number.

Cela fournirait en quelque sorte un objet qui peut être traité comme l'infini pour Integer, Long, Double, Float, BigInteger et BigDecimal.

Comme il n'y a que deux valeurs, nous pourrions utiliser le modèle 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;
    }
}

D'une manière ou d'une autre, je pense que les méthodes restantes intValue (), longValue () etc. devraient alors être surchargées pour lancer des exceptions. De sorte que la valeur infinie ne peut être utilisée sans précautions supplémentaires.

Je suis un débutant en Java ... J'ai trouvé une autre implémentation pour l'infini dans la documentation Java, pour les types booleanet double. https://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.2.3

Le zéro positif et le zéro négatif sont égaux; ainsi le résultat de l'expression 0.0 == - 0.0 est vrai et le résultat de 0.0> -0.0 est faux. Mais d'autres opérations peuvent distinguer zéro positif et négatif; par exemple, 1.0 / 0.0 a la valeur infini positif, tandis que la valeur 1.0 / -0.0 est l'infini négatif.

Ça a l'air moche, mais ça marche.

public class Main {

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

}