Это может быть полезно в качестве начального значения при поиске минимального значения.

Например:

min = float('inf')

for x in somelist:
  if x<min: 
    min=x

Я предпочитаю изначально устанавливать min на первое значение somelist.

Конечно, в Python в большинстве случаев вам следует просто использовать встроенную функцию min ().

При работе в проблемной области, где используется триггер (особенно касательный), бесконечность - это ответ, который может возникнуть. В конечном итоге Trig активно используется в графических приложениях, играх и геопространственных приложениях, а также в очевидных математических приложениях.

В некоторых физических вычислениях вы можете нормализовать неоднородности (например, бесконечные числа) одного порядка друг с другом, отменяя их обе и позволяя получить приблизительный результат.

Когда вы имеете дело с ограничениями, могут быть достигнуты вычисления вроде (бесконечность / бесконечность) -> приближение к конечному числу. Для языка полезно иметь возможность перезаписывать обычную ошибку деления на ноль.

Я уверен, что есть другие способы сделать это, но вы можете использовать Infinity для проверки разумных вводов при преобразовании String-to-Float. В Java, по крайней мере, статический метод Float.isNaN () будет возвращать false для чисел с бесконечной величиной, указывая, что они являются действительными числами, даже если ваша программа может захотеть классифицировать их как недопустимые. Проверка на соответствие константам Float.POSITIVE_INFINITY и Float.NEGATIVE_INFINITY решает эту проблему. Например:

// Some sample values to test our code with
String stringValues[] = {
  "-999999999999999999999999999999999999999999999",
  "12345",
  "999999999999999999999999999999999999999999999"
};

// Loop through each string representation
for (String stringValue : stringValues) {
  // Convert the string representation to a Float representation
  Float floatValue = Float.parseFloat(stringValue);

  System.out.println("String representation: " + stringValue);
  System.out.println("Result of isNaN: " + floatValue.isNaN());

  // Check the result for positive infinity, negative infinity, and
  // "normal" float numbers (within the defined range for Float values).
  if (floatValue == Float.POSITIVE_INFINITY) {
    System.out.println("That number is too big.");
  } else if (floatValue == Float.NEGATIVE_INFINITY) {
    System.out.println("That number is too small.");
  } else {
    System.out.println("That number is jussssst right.");
  }
}

Пример вывода:

Строковое представление: -9999999999999999999999999999999999999999999
Результат isNaN: false
Это слишком мало.

Строковое представление: 12345
Результат isNaN: false
Это число совершенно верно.

Строковое представление: 9999999999999999999999999999999999999999999
Результат isNaN: false
Это слишком большое число.

Алгоритм Дейкстры обычно назначает бесконечность в качестве начальных весов ребер в графе. Это не имеют как «бесконечность», просто некоторая произвольная константа, но в java я обычно использую Double.Infinity. Я предполагаю, что рубин можно использовать аналогичным образом.

Альфа-бета обрезка

Некоторые программисты используют Infinity или NaNs, чтобы показать, что переменная никогда не была инициализирована или назначена в программе.

Я использую его, когда у меня есть объект Range, у которого должен быть открыт один или оба конца.

Используйте Infinity и -Infinity, когда это требует математический алгоритм.

В Ruby Infinity и -Infinity обладают хорошими сравнительными свойствами, так что -Infinity <x <Infinity для любого действительного числа x. Например, Math.log(0) возвращает -Infinity, расширяя до 0 свойство, которое x > y подразумевает, что Math.log(x) > Math.log(y). Кроме того, Infinity * x - это Infinity, если x> 0, -Infinity, если x <0, и 'NaN' (не число, то есть не определено), если x равно 0.

Например, я использую следующий фрагмент кода в части вычисления некоторого логарифмические отношения правдоподобия. Я явно ссылаюсь на -Infinity, чтобы определить значение, даже если k - это 0 или n, И x - это 0 или 1.

Infinity = 1.0/0.0
def Similarity.log_l(k, n, x)
  unless x == 0 or x == 1
    k * Math.log(x.to_f) + (n-k) * Math.log(1.0-x)
  end
    -Infinity
  end
end

Кажется, подразумевается «Почему эта функция вообще существует?» в вашем вопросе. Причина в том, что Ruby и Python просто предоставляют доступ ко всему диапазону значений, которые можно указать в форме с плавающей запятой, как указано в IEEE.

Эта страница, кажется, хорошо описывает это: http://steve.hollasch.net/cgindex/coding/ieeefloat.html

В результате у вас также могут быть значения NaN (Not-a-number) и -0.0, хотя у вас также может не сразу появиться реальное применение для них.

Я использовал его в минимаксный алгоритм. Когда я генерирую новые ходы, если минимальный игрок выигрывает на этом узле, то значение узла равно -∞. И наоборот, если побеждает максимальный игрок, то значение этого узла равно + ∞.

Кроме того, если вы генерируете узлы / игровые состояния, а затем пробуете несколько эвристик, вы можете установить все значения узлов на -∞ / + ∞, что когда-либо имеет смысл, а затем, когда вы запускаете эвристику, легко установить значение узла :

node_val = -∞
node_val = max(heuristic1(node), node_val)
node_val = max(heuristic2(node), node_val)
node_val = max(heuristic2(node), node_val)

Я использовал его в DSL, похожем на has_one и has_many от Rails:

has 0..1 :author
has 0..INFINITY :tags

Это упрощает выражение таких понятий, как звезда Kleene и плюс в вашем DSL.

Я использую его, чтобы указать массу и инерцию статического объекта в физическом моделировании. Статические объекты практически не подвержены влиянию гравитации и других сил моделирования.

Я использовал его для случаев, когда вы хотите определить диапазоны предпочтений / разрешенных.

Например, в приложениях 37signals у вас есть ограничение на количество проектов.

Infinity = 1 / 0.0
FREE = 0..1
BASIC = 0..5
PREMIUM = 0..Infinity

тогда вы можете делать такие проверки, как

if PREMIUM.include? current_user.projects.count 
 # do something
end

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

Даны два диапазона A = [a, b) и C = [c, d), пересекаются ли они, один больше другого или один содержит другой?

A > C iff a >= d
A < C iff b <= c
etc...

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

Он довольно широко используется в графике. Например, любой пиксель в трехмерном изображении, который не является частью реального объекта, помечается как бесконечно удаленный. Чтобы потом его можно было заменить фоновым изображением.

Я использовал его для представления расстояния фокусировки камеры и, к моему удивлению, в Python:

>>> float("inf") is float("inf")
False
>>> float("inf") == float("inf")
True

Интересно, почему это так.

В Ruby бесконечность можно использовать для реализации ленивых списков. Скажем, мне нужно N чисел, начинающихся с 200, которые каждый раз последовательно увеличиваются на 100 единиц:

Inf = 1.0 / 0.0
(200..Inf).step(100).take(N)

Подробнее здесь: http://banisterfiend.wordpress.com/2009/10/02/wtf-infinite-ranges-in-ruby/

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

Поскольку я ожидаю, что все задействованные числа будут положительными, минимизировать легко: 0. Поскольку я не знаю, чего ожидать от максимума, я бы хотел, чтобы верхняя граница была какой-то бесконечностью. Таким образом, мне не придется выяснять, с каким «максимумом» мне следует сравнивать.

Поскольку это проект, над которым я работаю на работе, технически это «проблема реального мира». Это может быть немного редко, но, как и многие абстракции, удобно, когда вам это нужно!

Кроме того, тем, кто говорит, что этот (и другие примеры) надуманы, я хотел бы указать, что абстракции все несколько надуманы; это не значит, что они полезны, когда вы их придумываете.

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

my_connection = ConnectionLibrary(max_connection_attempts = float('inf'))

На мой взгляд, он более понятен, чем типичный стиль «установить на -1, чтобы повторить попытку навсегда», поскольку он буквально говорит «повторите попытку, пока количество попыток подключения не превысит бесконечность».

Вы можете использовать:

import decimal
decimal.Decimal("Infinity")

или же:

from decimal import *
Decimal("Infinity")

Для сортировки

Я видел, как оно использовалось как значение сортировки, чтобы сказать «всегда сортировать эти элементы вниз».

Если вы хотите получить наибольшее число от ввода, но они могут использовать очень большие негативы. Если я введу -13543124321.431, оно все равно будет работать как наибольшее число, так как оно больше, чем -inf.

enter code here
initial_value = float('-inf')
while True:
    try:
        x = input('gimmee a number or type the word, stop ')
    except KeyboardInterrupt:
        print("we done - by yo command")
        break
    if x == "stop":
        print("we done")
        break
    try:
        x = float(x)
    except ValueError:
        print('not a number')
        continue
    if x > initial_value: initial_value = x
print("The largest number is: " + str(initial_value))

Чтобы указать несуществующий максимум

Если вы имеете дело с числами, nil представляет собой неизвестное количество, и в этом случае его следует предпочесть 0. Точно так же Infinity представляет собой неограниченное количество, и в этом случае он должен быть предпочтительнее (arbitrarily_large_number).

Я думаю, это может сделать код чище. Например, я использую Float::INFINITYв рубиновом камне именно для этого: пользователь может указать максимальную длину строки для сообщения или он может указать :all. В этом случае я представляю максимальную длину как Float::INFINITY, чтобы позже, когда я проверяю, "длиннее ли это сообщение максимальной длины?" ответ всегда будет ложным, без особых случаев.