Ответ 1

Dijkstra Algorithm обычно присваивает бесконечность как начальные веса графа в графе. Это не должно быть "бесконечность", просто какая-то произвольно постоянная, но в java я обычно использую Double.Infinity. Я предполагаю, что рубин можно использовать аналогичным образом.

Ответ 2

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

Например:

min = float('inf')

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

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

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

Ответ 3

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

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

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

Ответ 4

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

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

Ответ 5

Используйте Infinity и -Infinity при выполнении математического алгоритма для этого.

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

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

Ответ 6

Обрезка альфа-бета

Ответ 7

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

Ответ 8

В 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/

Ответ 9

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

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

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

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

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

Ответ 10

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

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

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

Ответ 11

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

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

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

Ответ 12

Я использовал его в DSL, подобном Rails 'has_one и has_many:

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

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

Ответ 13

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

Ответ 14

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

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

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

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

Ответ 15

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

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

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

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

Ответ 16

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

Ответ 17

Я уверен, что есть другие способы сделать это, но вы можете использовать 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.");
  }
}

Результат вывода:

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

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

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

Ответ 18

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

Ответ 19

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

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

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

Ответ 20

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

Ответ 21

Если вы хотите получить наибольшее число от ввода, но они могут использовать очень большие негативы. Если я вхожу в -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))

Ответ 22

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

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

Ответ 23

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

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

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

Ответ 24

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

import decimal
decimal.Decimal("Infinity")

или

from decimal import *
Decimal("Infinity")