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

например:

min = float('inf')

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

который я предпочитаю устанавливать min первоначально до первого значения somelist

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

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

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

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

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

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

использовать Infinity и -Infinity при реализации математического алгоритма вызывает его.

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

для например, я использую следующий бит кода в части вычисления некоторого отношения правдоподобия лог. Я явно указать -Infinity чтобы определить значение, даже если k is 0 или n и x is 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 infinity можно использовать для реализации ленивых списков. Скажем, я хочу 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/

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

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

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

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

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

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

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

интересно, почему это.

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

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

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

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

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

Это позволяет легко выражать такие понятия, как kleene star и plus в вашем DSL.

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

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

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

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

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

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

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

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

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

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

Я уверен, что есть другие способы сделать это, но вы можете использовать Infinity для проверки разумных входных данных в преобразовании String-to-Float. В Java, по крайней мере, поплавок.статический метод isNaN () вернет false для чисел с бесконечной величиной, указывая, что они являются допустимыми числами, даже если ваша программа может захотеть классифицировать их как недопустимые. Сверяюсь с поплавком.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.");
  }
}

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

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

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

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

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

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

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

на мой взгляд, это более ясно, чем типичный стиль "set to -1 to retry forever", поскольку он буквально говорит "retry, пока количество попыток подключения не превысит бесконечность".

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

Если вы хотите, наибольшее число из входного, но они могут использовать очень большие минусы. Если я введу -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, так что позже, когда я проверю " это сообщение длиннее максимальной длины?- ответ всегда будет ложным, не требуя особого случая.

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

import decimal
decimal.Decimal("Infinity")

или:

from decimal import *
Decimal("Infinity")