Все мы знаем, что 0 ⁰ неопределенно.

Но , Javascript говорит , что:

Math.pow(0, 0) === 1 // true

и C ++ говорит то же самое:

pow(0, 0) == 1 // true

ЗАЧЕМ?

Я знаю это:

>Math.pow(0.001, 0.001)
0.9931160484209338

Но почему не Math.pow(0, 0)выдает ошибок? Или, может NaNбыть, лучше, чем 1.

В C ++ в результате мощно (0, 0) результат в основном определяется реализация поведения , поскольку математически мы имеем противоречивую ситуацию , в которой N^0всегда должно быть , 1но 0^Nвсегда должно быть 0на N > 0, так что вы не должны иметь никаких ожиданий математически в результате этого либо. Эти сообщения на форуме Wolfram Alpha содержат более подробную информацию.

Хотя pow(0,0)результат 1полезен для многих приложений, так как в Обосновании международного стандарта - Языки программирования - C говорится в разделе, посвященном поддержке арифметики с плавающей запятой МЭК 60559 :

Как правило, C99 избегает результата NaN, когда полезно числовое значение. [...] Результаты pow (∞, 0) и pow (0,0) равны 1, потому что есть приложения, которые могут использовать это определение. Например, если x (p) и y (p) - любые аналитические функции, которые становятся равными нулю при p = a, то pow (x, y), что равно exp (y * log (x)), приближается к 1, когда p приближается а.

Обновить C ++

Как leemes правильно указал , что я изначально связанно с ссылкой на комплексную версию мощна в то время как несложная версию утверждает , что это ошибка домена проекта стандарта C ++ возвращается к проекту стандарта C и как С99 и С11 в разделе 7.12.7.4 военнопленной функции пункт 2 говорит ( выделено мной ):

[...] Ошибка домена может возникнуть, если x равен нулю, а y равен нулю. [...]

что, насколько я могу судить, означает, что это поведение является неопределенным. Перемотка назад битового раздела 7.12.1 Обработка условий ошибки говорит:

[...] ошибка домена возникает, если входной аргумент находится за пределами домена, в котором определена математическая функция. [...] При ошибке домена функция возвращает значение, определяемое реализацией; если целочисленное выражение math_errhandling & MATH_ERRNO не равно нулю, целочисленное выражение errno получает значение EDOM; [...]

Так что если была ошибка домена , то это будет реализация определяется поведение , но в обоих последних версиях gccи clangстоимости errnoявляется 0так это не ошибка домена для этих компиляторов.

Обновить Javascript

Для Javascript в спецификации языка ECMAScript® в разделе 15.8 «Математический объект» под 15.8.2.13 pow (x, y) среди других условий говорится, что:

Если y равно +0, результат равен 1, даже если x равен NaN.

В JavaScript Math.powопределяется следующим образом :

• Если y равно NaN, результатом будет NaN.
• Если y равно +0, результат равен 1, даже если x равен NaN.
• Если y равен −0, результат равен 1, даже если x равен NaN.
• Если x равен NaN, а y отличен от нуля, результат равен NaN.
• Если abs (x)> 1 и y равно + ∞, результат равен + ∞.
• Если abs (x)> 1 и y равно −∞, результат равен +0.
• Если abs (x) == 1 и y равно + ∞, результатом будет NaN.
• Если abs (x) == 1 и y равно −∞, результатом будет NaN.
• Если abs (x) <1 и y равно + ∞, результат равен +0.
• Если abs (x) <1 и y равно −∞, результат равен + ∞.
• Если x равно + ∞ и y> 0, результат равен + ∞.
• Если x равно + ∞ и y <0, результат равен +0.
• Если x равно −∞, y> 0 и y - нечетное целое число, результат равен −∞.
• Если x равно −∞, y> 0 и y не является нечетным целым числом, результат равен + ∞.
• Если x равно −∞, y <0 и y - нечетное целое число, результат равен −0.
• Если x равен −∞, y <0 и y не является нечетным целым числом, результат равен +0.
• Если x равно +0 и y> 0, результат равен +0.
• Если x равно +0 и y <0, результат равен + ∞.
• Если x равно −0, y> 0 и y - нечетное целое число, результат равен −0.
• Если x равно −0, а y> 0 и y не является нечетным целым числом, результат равен +0.
• Если x равно −0, y <0 и y - нечетное целое число, результат равен −∞.
• Если x равен −0, y <0 и y не является нечетным целым числом, результат равен + ∞.
• Если x <0 и x конечно, y конечно и y не является целым числом, результатом будет NaN.

_{акцент мой}

Как правило, собственные функции для любого языка должны работать, как описано в спецификации языка. Иногда это включает явно «неопределенное поведение», когда разработчик должен определить, каким должен быть результат, однако это не случай неопределенного поведения.

Это просто условность определить его как 1, 0или оставить его undefined. Определение широко распространено из-за следующего определения:

В документации ECMA-Script говорится следующее pow(x,y):

• Если y равно +0, результат равен 1, даже если x равен NaN.
• Если y равен −0, результат равен 1, даже если x равен NaN.

[ http://www.ecma-international.org/ecma-262/5.1/#sec-15.8.2.13 ]

Согласно Википедии:

В большинстве случаев, не связанных с непрерывностью показателя степени, интерпретация 0 ⁰ как 1 упрощает формулы и устраняет необходимость в особых случаях в теоремах.

Есть несколько возможных способов лечения, 0**0имеющих плюсы и минусы для каждого (см. Википедию). обсуждение ).

Стандарт IEEE 754-2008 с плавающей запятой рекомендует три разные функции:

• powотносится 0**0как 1. Это самая старая определенная версия. Если степень является точным целым числом, результат будет таким же, как для pown, в противном случае результат будет таким же powr(за исключением некоторых исключительных случаев).
• pownрассматривает 0 ** 0 как 1. Степень должна быть точным целым числом. Значение определяется для отрицательных оснований; например, pown(−3,5)есть −243.
• powrобрабатывает 0 ** 0 как NaN (Not-a-Number - undefined). Значение также NaN для случаев, powr(−3,2)когда основание меньше нуля. Значение определяется выражением exp (power '× log (base)).

Дональд Кнут

В 1992 году эти дебаты были решены следующим образом:

И еще более подробно описал в своей статье Две заметки о нотации. .

По сути, хотя у нас нет 1 в качестве предела f(x)/g(x)для всех не всех функций, f(x)и g(x)он все равно упрощает определение комбинаторики 0^0=1, а затем просто создает особые случаи в тех немногих местах, где вам нужно учитывать такие функции, как 0^x, в любом случае странные. В конце концовx^0 всплывает намного чаще.

Вот некоторые из лучших известных мне дискуссий по этой теме (кроме статьи Кнута):

• http://mathforum.org/dr.math/faq/faq.0.to.0.power.html
• http://www.quora.com/Mat Mathematics/What-is-math-0-0-math?share=1
• /math/475337/the-binomial-formula-and-the-value-of-00

Когда вы хотите знать, какое значение вы должны дать, f(a)когда fоно не вычисляется напрямую a, вы вычисляете предел того, fкогда xстремится к a.

В случае x^y, обычные ограничения имеют тенденцию к тому, 1когда xи yимеют тенденцию 0, и особенно x^xк тому, 1когда xсклонны к 0.

См. Http://www.math.hmc.edu/funfacts/ffiles/10005.3-5.shtml.

Определение языка C гласит (7.12.7.4/2):

Ошибка домена может возникнуть, если x равен нулю, а y равен нулю.

В нем также говорится (7.12.1 / 2):

При ошибке домена функция возвращает значение, определяемое реализацией; если целочисленное выражение math_errhandling & MATH_ERRNO не равно нулю, целочисленное выражение errno получает значение EDOM; если целочисленное выражение math_errhandling & MATH_ERREXCEPT не равно нулю, возникает «недопустимое» исключение с плавающей запятой.

По умолчанию значение math_errhandlingравно MATH_ERRNO, поэтому проверьте errnoзначение EDOM.

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

Возведение в степень не очень хорошо сочетается с другими нашими математическими обозначениями, поэтому определение, которое мы все изучаем, оставляет место для путаницы. Немного другой подход к этому - сказать, что a ^ b (или exp (a, b), если хотите) возвращает значение, мультипликативно эквивалентное умножению чего- то другого. на a, повторенное b раз.

Когда мы умножаем 5 на 4, 2 раза, получаем 80. Мы умножили 5 на 16. Итак, 4 ^ 2 = 16.

Когда вы умножаете 14 на 0, 0 раз, у нас остается 14. Мы умножили его на 1. Следовательно, 0 ^ 0 = 1.

Такой образ мышления может также помочь прояснить отрицательные и дробные показатели. 4 ^ (- 2) - 16-е, потому что «отрицательное умножение» - это деление - мы делим на четыре дважды.

a ^ (1/2) - это корень (a), потому что умножение чего-либо на корень a составляет половину мультипликативной работы по сравнению с умножением на сам a - вам придется сделать это дважды, чтобы умножить что-то на 4 = 4 ^ 1 = (4 ^ (1/2)) ^ 2

Чтобы это понять, вам нужно решить исчисление:

Расширяя x^xоколо нуля с помощью ряда Тейлора, мы получаем:

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

Нам нужно использовать преобразование:

Теперь после этого преобразования мы можем использовать правило Л'Опиталя , которое гласит:

Итак, дифференцируя это преобразование, мы получаем:

Итак, мы рассчитали этот срок log(x)*x приближается к 0, когда x приближается к 0. Легко видеть, что другие последовательные члены также стремятся к нулю и даже быстрее, чем второй член.

Итак, в данный момент x=0серия становится 1 + 0 + 0 + 0 + ...равной 1.