Как реализовать бесконечность в Java?

Есть ли в Java что-нибудь, что представляет бесконечность для каждого числового типа данных? Как это реализовано так, что я могу делать математические операции с ним?

Например

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

Я пытался использовать очень большие числа, но я хочу правильное и простое решение.

double поддерживает бесконечность

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

печать

Infinity
NaN
-Infinity

примечание: Infinity - Infinityэто не число .

Я полагаю, вы используете целочисленную математику по причине. Если это так, вы можете получить результат, который функционально почти такой же, как POSITIVE_INFINITY, используя поле MAX_VALUE Integerкласса:

Integer myInf = Integer.MAX_VALUE;

(А для NEGATIVE_INFINITY вы можете использовать MIN_VALUE.) Конечно, будут некоторые функциональные различия, например, при сравнении myInfсо значением, которое оказывается MAX_VALUE: ясно, что это число не меньше, чем myInf.

Есть также библиотека, которая на самом деле имеет поля POSITIVE_INFINITY и NEGATIVE_INFINITY, но на самом деле это просто новые имена для MAX_VALUE и MIN_VALUE.

Чтобы использовать Infinity, вы можете использовать Doubleкоторый поддерживает 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);

ВЫХОД : -

Infinity
-Infinity
-Infinity

Infinity 
NaN

DoubleИ Floatтипы имеют POSITIVE_INFINITYпостоянную.

Я не уверен, что в Java есть бесконечность для каждого числового типа, но для некоторых числовых типов данных ответ положительный:

Float.POSITIVE_INFINITY
Float.NEGATIVE_INFINITY

или

Double.POSITIVE_INFINITY
Double.NEGATIVE_INFINITY

Также вам может пригодиться следующая статья, в которой представлены некоторые математические операции, включающие бесконечность +/-: Java-числа с плавающей запятой .

Только Double и Float поддерживают POSITIVE_INFINITYконстанту.

Для числовых типов оболочек.

например, Double.POSITVE_INFINITY

Надеюсь, это поможет вам.

Общее решение состоит в том, чтобы ввести новый тип. Он может быть более сложным, но имеет преимущество работы с любым типом, который не определяет свою бесконечность.

Если Tэто тип , для которого lteqопределяется, вы можете определить , InfiniteOr<T>с lteqчем - то вроде этого:

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

Я оставлю это вам, чтобы перевести это на точный синтаксис Java. Я надеюсь, что идеи ясны; но позвольте мне разобрать их в любом случае.

Идея состоит в том, чтобы создать новый тип, который имеет все те же значения, что и некоторый уже существующий тип, плюс одно специальное значение, которое, насколько вы можете судить с помощью открытых методов, действует именно так, как вы хотите, чтобы бесконечность действовала, например, она больше, чем что-нибудь еще. Я использую, nullчтобы представить бесконечность здесь, так как это кажется самым простым в Java.

Если вы хотите добавить арифметические операции, решите, что они должны делать, а затем реализуйте это. Вероятно, проще всего сначала обработать бесконечные случаи, а затем повторно использовать существующие операции с конечными значениями исходного типа.

Может существовать или не существовать общая закономерность того, выгодно или нет принять соглашение об обработке бесконечностей левой стороны перед бесконечностью правой стороны или наоборот; Я не могу сказать, не попробовав это, но для менее или равно ( lteq) я думаю, что проще сначала взглянуть на бесконечность с правой стороны. Хочу отметить , что lteqэто не коммутативной, но addи mulявляются; может быть, это актуально.

Примечание: придумать хорошее определение того, что должно происходить с бесконечными значениями, не всегда легко. Это для сравнения, сложения и умножения, но, возможно, не вычитания. Кроме того, существует различие между бесконечными кардинальными и порядковыми числами, на которые вы можете обратить внимание.

Так как класс Number не окончательный, вот идея, которую я пока не нахожу в других постах. А именно для подкласса класса Number.

Это каким-то образом доставит объект, который можно рассматривать как бесконечность для Integer, Long, Double, Float, BigInteger и BigDecimal.

Поскольку существует только два значения, мы можем использовать шаблон синглтона:

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;
    }
}

Каким-то образом я думаю, что остальные методы intValue (), longValue () и т. Д. Должны быть переопределены, чтобы вызвать исключения. Так что значение бесконечности не может быть использовано без дополнительных мер предосторожности.

Я новичок в Java ... Я нашел другую реализацию бесконечности в документации Java, для booleanи doubleтипов. https://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.2.3

Положительный ноль и отрицательный ноль сравниваются равными; таким образом, результат выражения 0.0 == - 0.0 является истинным, а результат 0.0> -0.0 - ложным. Но другие операции могут различать положительный и отрицательный ноль; например, 1.0 / 0.0 имеет значение положительной бесконечности, а значение 1.0 / -0.0 - отрицательной бесконечности.

Это выглядит некрасиво, но это работает.

public class Main {

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

}