Будет ли (int)pow(n,m) неправильным для некоторых натуральных чисел n,m?

Стандарт C не предъявляет никаких требований к точности арифметических операций с плавающей запятой. Точность определяется реализацией, что означает, что реализации должны ее документировать. Однако реализации остаются со значительным «отсутствием»: (5.2.4.2.2, абзац 6, курсив добавлен.)

Точность операций с плавающей запятой (+, -, *, /) и библиотечных функций в <math.h> и <complex.h>, которые возвращают результаты с плавающей запятой, определяется реализацией, как и точность преобразования между внутренними представлениями с плавающей запятой. и строковые представления, выполняемые библиотечными функциями в <stdio.h>, <stdlib.h> и <wchar.h>. В реализации может быть указано, что точность неизвестна.

И действительно, gcc использует это преимущество, указывая, что точность неизвестна. Тем не менее, точность вычислений glibc довольно высока, хотя и не гарантируется.

Известно, что реализация MS libc иногда выдает ошибку 1ULP для функции pow с целочисленными аргументами, что приводит к неправильному значению, если результат операции pow просто усекается до int. (Я не смог найти никаких спецификаций в документации Visual Studio о точности с плавающей запятой, но я считаю, что приведенный ниже список вопросов SO подтверждает мое утверждение.)

В архитектурах x86 большинство реализаций пытаются реализовать IEEE 754, поскольку собственное представление с плавающей запятой соответствует. Однако до редакции 2008 года IEEE-754 требовал только правильно округленные результаты от +, -, *, / и sqrt. После пересмотра рекомендуется, чтобы ряд других функций возвращал правильно округленные результаты, но все эти рекомендации необязательны, и лишь немногие математические библиотеки реализуют их все.

Если вы действительно хотите использовать pow для вычисления целых степеней целых чисел, рекомендуется (и просто) использовать lround(pow(n, m)) вместо (long)(pow(n, m)), что округлит результат до ближайшего целого числа, а не оптимистично полагаясь на положительную ошибку. Это должно дать правильное целочисленное значение для результатов до 2⁵² (с удвоением IEEE-754), если pow находится в пределах 1ULP. Между 2⁵² и 2⁵³ ошибка 1ULP будет равна 0,5, что иногда округляется до неправильного целого числа. За пределами 2⁵³ не все целые числа могут быть представлены как двойные числа.

SO на самом деле полон вопросов, связанных с этой конкретной проблемой. Видеть:

• Обратное пятизначное число с функцией POW в C
• Функция C pow() согласно заголовочному файлу ‹math.h› не работает должным образом
• Странное поведение функции pow
• Почему я получаю неожиданный результат при использовании floor с pow?
• Почему pow(10,5) = 9999 в C++
• возвращаемое значение pow() округляется в меньшую сторону, если ему присвоено целое число (найдено с помощью Лу Винь Фук)
• неправильный вывод по силовой функции - C (также)

и, несомненно, многие другие.

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

glibc, например, имеет 'C ' реализации, а также реализации для конкретных платформ с таблицами поиска, полиномиальными аппроксимациями и т. д. Многие производные от Sun/BSD, по-видимому, обрабатывают целочисленные показатели как особый случай.

Что еще более важно, IEEE-754 не требует этого. Он также не определяет требуемую точность результата. glibc документирует максимальное количество ошибок ulp, хотя эта страница может быть не актуальной.

Таким образом, не рассчитывайте на точный целочисленный результат, даже если pow(n,m) имеет точное представление с плавающей запятой.

На платформах, где int имеет 64 бита, а double также имеет 64 бита, это может не работать, поскольку double (аргументы и результат pow()) не имеют достаточной мантиссы для точного представления каждого 64-битного целого числа. На обычной платформе, где int имеет 32 бита, а double является 64-битным типом с плавающей запятой IEEE 754, ваше предположение верно.

Это зависит от размеров ваших целых чисел и удвоений.

С 32-битным целым числом и 64-битным двойником IEEE 754 он даст вам правильный ответ для всех возможных целых чисел.

Число с плавающей запятой IEEE 754 binary64 (которое является обычным представлением двойных чисел на большинстве современных машин) может точно представлять все целые числа [0,2^53].