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

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

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

Обновление C++

Как правильно заметил Лимес, я изначально ссылался на ссылку для сложной версии pow, в то время как несложная версия утверждает, что это ошибка домена проект стандарта C++ возвращается к черновик стандарта C, а также C99 и C11 в разделе 7.12.7.4 Функции pow параграф 2 говорит (выделено мной):

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

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

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

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

Обновить Javascript

Для Javascript Спецификация языка ECMAScript® в разделе 15.8 < em>Математический объект под 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 году следующим:

И еще больше углубился в детали в своей статье Two Notes on Notation< /а>.

• http://mathforum.org/dr.math/faq/faq.0.to.0.power.html
• http://www.quora.com/Mathematics/What-is-math-0-0-math?share=1
• https://math.stackexchange.com/questions/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.