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

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

or

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.

Поскольку есть только два значения, мы могли бы использовать шаблон 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;
    }
}

Почему-то я думаю, что оставшиеся методы 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);
    }

}

Целочисленная бесконечность:

  Integer maxNumber = Integer.MAX_VALUE

Двойная бесконечность

  Double maxNumber = Double.MAX_VALUE;
  Double positiveInf = Double.POSITIVE_INFINITY;
  Double negativeInf = Double.NEGATIVE_INFINITY

Плавающая бесконечность

   Float positiveInf = Float.POSITIVE_INFINITY;
   Float negativeInf = Float.NEGATIVE_INFINITY
   Float maxNumber = Float.MAX_VALUE;