Приблизительный пример

Как насчет такой стратегии, которая использует формулу

e^x = 2^x/ln(2)

1. Предварительный расчет 1/ln(2)
2. Умножьте эту константу на свой аргумент (1 умножение)
3. Используйте двоичные сдвиги, чтобы возвести 2 в целочисленную часть степени (предполагается формат exp+mantissa)
4. Отрегулируйте на основе остатка дробной степени 2 (вероятно, второго умножения)

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

Кроме того, если ваше приложение достаточно специализировано, вы можете попытаться перестроить весь числовой код, который будет работать на вашем оборудовании, чтобы он был в системе счисления с основанием e, и реализовать ваше оборудование с плавающей запятой для также работают в базе e. Тогда вообще никакой конвертации не нужно.

Если x является целым числом, вы можете просто умножать e само на себя снова и снова.

Если x не является целым числом, вы можете рассчитать e^floor(x), используя описанный выше метод, а затем умножить его на небольшую поправку. Этот поправочный член может быть легко рассчитан с использованием ряда методов аппроксимации. Один из таких способов таков:

e^f ≈ 1 + f(1 + f/2(1 + f/3(1 + f/4))), где f — дробная часть x

Это происходит из (оптимизированного) разложения e^x по степеням, которое очень точно для небольших значений x. Если вам нужна большая точность, просто добавьте в серию больше терминов.

Этот вопрос math.stackexchange содержит несколько дополнительных умных ответов. .

РЕДАКТИРОВАТЬ: обратите внимание, что существует более быстрый способ вычисления eⁿ, который называется возведение в степень в квадрате.

Во-первых, что мотивирует это приближение? Другими словами, что именно не так с прямым exp(x)?

Тем не менее, типичная реализация exp(x) заключается в следующем:

• Найдите целое число k и число с плавающей запятой r так, чтобы x=k*log(2) + r и r находились в диапазоне от -0,5*log(2) до 0,5*log(2).
• При таком уменьшении exp(x) равно 2^k*exp(r).
• Вычислить 2^k совсем несложно.
• Стандартные реализации exp(x) используют алгоритм типа Ремеса для получения минимаксного многочлена, приближающегося к exp(r).
• Вы можете сделать то же самое, но использовать полином уменьшенного порядка.

Вот кикер: независимо от того, что вы делаете, очень высока вероятность того, что ваша функция будет работать намного, намного медленнее, чем просто вызов exp(). Большая часть функций exp() реализована в математическом сопроцессоре вашего компьютера. Повторная реализация этой функциональности в программном обеспечении, даже с меньшей точностью, будет на порядок медленнее, чем простое использование exp().

Или вы можете просто сделать pow(M_E, x) в C. (Некоторые платформы не имеют определенного M_E; на них вам, возможно, придется вручную указать значение e, которое приблизительно равно 2.71828182845904523536028747135266249775724709369995.)

(Как отмечает Дэвид в комментариях, exp(x) будет более эффективным, чем pow(M_E, x). Опять же, мозг еще не включился.)

Есть ли у вас пример использования, в котором вычисление e^x является доказанным узким местом? Если нет, вы должны сначала кодировать для удобочитаемости; пробуйте такие виды оптимизации только в том случае, если очевидный подход слишком медленный.

http://martin.ankerl.com/2007/02/11/optimized-exponential-functions-for-java/ с использованием метода Шраудольф (http://nic.schraudolph.org/pubs/Schraudolph99.pdf) в Java:

public static double exp(double val) {
    final long tmp = (long) (1512775 * val) + (1072693248 - 60801);
    return Double.longBitsToDouble(tmp << 32);
}

и https://math.stackexchange.com/a/56064 (ищите аппроксимацию Паде).

Это не запрошенная вами гладкая сплайн-интерполяция, но она эффективна в вычислительном отношении:

float expf_fast(float x) {
   union { float f; int i; } y;
   y.i = (int)(x * 0xB5645F + 0x3F7893F5);
   return (y.f);
}

Вывод графика

Для аппаратного обеспечения у меня есть отличное решение для вас, ЕСЛИ вам нужно, чтобы оно было точным на уровне битов. (В противном случае просто сделайте приближение, как указано выше). Тождество exp(x) = ch(x) + sh(x), гиперболический синус и косинус. Загвоздка в том, что гиперболические синус и косинус можно вычислить с помощью метода CORIC, и, что лучше всего, они являются одной из функций FAST CORDIC, то есть они выглядят почти как умножение, а не почти как деление!

Это означает, что для площади множителя массива вы можете вычислить показатель степени с произвольной точностью всего за 2 цикла!

Посмотрите метод CORDIC - он УДИВИТЕЛЬНЫЙ для аппаратной реализации.

Еще один аппаратный подход использует небольшую таблицу в сочетании с формулой, упомянутой другими: exp(x + y) = exp(x) * exp(y). Вы можете разбить число на небольшие битовые поля — скажем, по 4 или 8 бит за раз — и просто найти показатель степени для этого битового поля. Вероятно, эффективен только для узких вычислений, но это другой подход.

Wolfram предлагает несколько хороших способов аппроксимации с точки зрения серий и т. д.:

• страница Wolfram для e^x

Страница Википедии в Taylor Series также показывает пример расширения e^{x около 0:}

Конечно, это возможно". Есть несколько проблем.

1. Каковы ваши требования к точности?

2. Готовы ли вы использовать сплайны более высокого порядка?

3. Сколько памяти вы готовы потратить на это? Линейная функция на достаточно малых интервалах будет аппроксимировать экспоненциальную функцию с любой необходимой степенью точности, но для этого может потребоваться ОЧЕНЬ маленький интервал.

Редактировать:

Учитывая предоставленную дополнительную информацию, я провел быстрый тест. Уменьшение диапазона всегда можно использовать для экспоненциальной функции. Таким образом, если я хочу вычислить exp(x) для ЛЮБОГО x, я могу переписать задачу в виде...

y = exp(xi + xf) = exp(xi)*exp(xf)

где xi — целая часть x, а xf — дробная часть. Целая часть проста. Вычислите xi в двоичной форме, затем повторные возведения в квадрат и умножения позволят вам вычислить exp(xi) за относительно небольшое количество операций. (Другие приемы, использование степеней двойки и других интервалов могут дать вам еще больше скорости для жаждущих скорости.)

Теперь осталось только вычислить exp(xf). Можем ли мы использовать сплайн с линейными сегментами для вычисления exp(xf) на интервале [0,1] всего с 4 линейными сегментами с точностью до 0,005?

Этот последний вопрос решается с помощью функции, которую я написал несколько лет назад, которая будет аппроксимировать функцию сплайном заданного порядка в пределах фиксированного допуска на максимальную ошибку. Этот код требовал 8 сегментов в интервале [0,1] для достижения требуемого допуска с помощью кусочно-линейной сплайн-функции. Если бы я решил еще уменьшить интервал до [0,0,5], я бы теперь мог достичь предписанного допуска.

Итак, ответ прост. Если вы хотите уменьшить диапазон, чтобы уменьшить x до интервала [0,0,5], затем выполните соответствующие вычисления, тогда да, вы можете достичь требуемой точности с помощью линейного сплайна в 4 сегментах.

В конце концов, вам всегда будет лучше использовать жестко закодированную экспоненциальную функцию. Все упомянутые выше операции, безусловно, будут медленнее, чем то, что предоставит ваш компилятор, ЕСЛИ доступно exp(x).

Это не подходит для пользовательских FPGA, но стоит упомянуть.

http://www.machinedlearnings.com/2011/06/fast-closed-logarithm-exponential.html

И исходный код:

https://code.google.com/archive/p/fastприблизительно/downloads

«Более быстрая» реализация включает только 3 шага (умножение, добавление, преобразование float в int) и окончательное приведение обратно к float. По моему опыту, точность составляет 2%, чего может быть достаточно, если вас не волнует фактическое значение, но вы используете значение в итерации максимизации логарифмического правдоподобия.