Почему NaN^0 == 1

Об этом говорится на странице справки, на которую ссылается ?'NaN'

"Стандарт IEC 60559, также известный как стандарт ANSI/IEEE 754 для операций с плавающей запятой.

http://en.wikipedia.org/wiki/NaN".

И там вы найдете это утверждение относительно того, что должно создать NaN:

 "There are three kinds of operations that can return NaN:[5]
       Operations with a NaN as at least one operand.

Вероятно, это от конкретного компилятора C, как указано в примечании, на которое вы ссылаетесь. Вот что говорится в документации GNU C:

http://www.gnu.org/software/libc/manual/html_node/Infinity-and-NaN.html

«NaN, с другой стороны, заражает любой расчет, который включает его. Если вычисление не будет давать тот же результат, независимо от того, какое реальное значение заменило NaN, результатом будет NaN».

Так что кажется, что разработчики GNU-C имеют в виду другой стандарт при написании своего кода. Сообщается, что версия стандарта с плавающей запятой ANSI/IEEE 754 от 2008 года содержит такое предложение:

http://en.wikipedia.org/wiki/NaN#Function_definition

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

http://ieeexplore.ieee.org/xpl/mostRecentIssue.jsp?punumber=4610933

Ответ можно резюмировать словами «по историческим причинам».

Похоже, что IEEE 754 представил две разные функции мощности — pow и powr, причем последняя сохраняет NaN в случае OP. а также возвращает NaN для Inf^0, 0^0, 1^Inf, но в конечном итоге последний был исключен, как кратко объясняется здесь.

Концептуально я нахожусь в лагере сохранения NaN, потому что я подхожу к проблеме с точки зрения ограничений, но с точки зрения удобства я ожидаю, что с текущими соглашениями немного легче иметь дело, даже если они не приносят многого. смысла в некоторых случаях (например, sqrt(-1)^0 равно 1, в то время как все операции выполняются над действительными числами, имеет мало смысла, если вообще есть).

Да, я опоздал, но как участник R Core, который участвовал в этом дизайне, позвольте мне напомнить то, что я прокомментировал выше. Сохранение NaN и сохранение NA работают «эквивалентно» в R, поэтому, если вы согласны с тем, что NA^0 должно давать 1, NaN^0 |-> 1 является следствием.

Действительно (как говорили другие), вам действительно следует читать справочные страницы R, а не стандарты C или IEEE, чтобы отвечать на такие вопросы, и SimonO101 правильно процитировал

1 ^ y и y ^ 0 равны 1, всегда

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

Или, другими словами, простое правило, подобное приведенному выше (возвращающее не-NaN во всех случаях), является хорошим правилом, потому что оно поддерживает непрерывность в математическом смысле: lim_x f(x) = f(lim x). У нас было несколько случаев, когда было явно выгодно (т.е. не требовался специальный корпус, я повторяю ..) придерживаться вышеуказанного правила «= 1», а не распространять NaN. Как я сказал выше, sqrt(-1)^0 также является таким примером, так как 1 является правильным результатом, как только вы расширяете комплексную плоскость.

Вот одно рассуждение. Источник Goldberg:

В IEEE 754 значения NaN часто представляются как числа с плавающей запятой с показателем степени e_max + 1 и ненулевыми значащими.

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

Также обратите внимание:

> 1^NaN
[1] 1

Единица — это число, показатель которого уже равен нулю.

Концептуально единственная проблема с NaN^0 == 1 заключается в том, что нулевые значения могут быть получены по крайней мере четырьмя различными способами, но формат IEEE использует одно и то же представление для трех из них. Приведенная выше формула равенства имеет смысл для наиболее распространенного случая (которого является одним из трех), но не для остальных.

Кстати, я бы назвал четыре случая:

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

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

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

Если вы посмотрите на тип NaN, это все еще число, просто это не конкретное число, которое может быть представлено числовым типом.

РЕДАКТИРОВАТЬ:

Например, если вы должны были взять 0/0. Что в итоге? Если вы попытаетесь решить это уравнение на бумаге, вы застрянете на самой первой цифре, сколько нулей вписывается в другой 0? Можно поставить 0, можно поставить 1, можно поставить 8, все они укладываются в 0*x=0, но невозможно узнать, какой из них правильный. Однако это не означает, что ответ больше не является числом, это просто не число, которое можно представить.

Несмотря на это, любое число, даже число, которое вы не можете представить, в степени нуля все еще равно 1. Если вы немного разберете математику, x^8 * x^0 можно еще упростить с помощью x^(8+0), что соответствует x^8, куда делось x^0? Имеет смысл, если x^0 = 1, потому что тогда уравнение x^8 * 1 объясняет, почему x^0 просто исчезает из существования.