当前位置：文江博客话题详情

近似 e^x

发布于 2024-11-28 14:55:34 字数 540 浏览 2 评论 0原文

我想近似 e^x 函数。

是否可以使用基于多样条类型的方法来做到这一点？即在 x₁ 和 x₂ 之间，那么

y₁ = a₁x + b₁，介于 x₂ 之间> 和 x₃,

然后

y₂ = a₂x + b₂

等

这是针对专用 fpga 硬件而不是通用 CPU 。因此我需要自己创建该函数。准确性就不再那么令人担忧了。此外，我真的买不起超过一个乘法电路和/或多个移位/加法器。另外我想要比 CORDIC 函数小得多的东西，事实上大小是至关重要的。

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

悲喜皆因你 2024-12-05 14:55:34

像这样使用公式的策略怎么样

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

预先计算 1/ln(2)
将此常量乘以您的参数（1 次乘法）
使用二进制移位以将 2 提高到幂的整数部分（假设 exp+尾数格式）
根据 2 的分数幂余数进行调整（可能是第二次乘法）

我意识到这不是一个完整的解决方案，但它只需要单身的乘法并将剩下的问题简化为近似 2 的分数次方，这应该更容易在硬件中实现。

此外，如果您的应用程序足够专业，您可以尝试重新导出将在您的硬件上运行的所有数字代码，使其位于基数系统中，并实现您的浮点硬件也可以在基地e工作。那么根本不需要转换。

回复收藏 0 原文

等待圉鍢 2024-12-05 14:55:34

如果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ⁿ 的方法，称为通过平方求幂。

回复收藏 0 原文

绝情姑娘 2024-12-05 14:55:34

首先，是什么推动了这种近似？换句话说，简单的 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) 的标准实现使用 Remes 类型算法来得出近似于 exp(r) 的极小极大多项式。
您可以执行相同的操作，但使用降阶多项式。

关键在于：无论您做什么，您的函数都比仅调用 exp() 慢得多。 exp() 的大部分功能都是在计算机的数学协处理器中实现的。在软件中重新实现该功能，即使精度降低，也会比仅使用 exp() 慢一个数量级。

回复收藏 0 原文

我的黑色迷你裙 2024-12-05 14:55:34

对于硬件，如果您需要位级精确度，我可以为您提供一个很棒的解决方案。（否则只需像上面那样进行近似）。恒等式为 exp(x) = cosh(x) + sinh(x)，即双曲正弦和余弦。问题是双曲正弦和余弦可以使用 CORIC 技术计算，最重要的是，它们是 FAST CORDIC 函数之一，这意味着它们看起来几乎像乘法而不是除法！

这意味着对于数组乘法器的面积，您只需 2 个周期即可计算任意精度的指数！

查找 CORDIC 方法 - 它对于硬件实现来说非常神奇。

另一种硬件方法是使用一个小表和其他人提到的公式：exp(x + y) = exp(x) * exp(y)。您可以将数字分解为小的位字段（例如一次 4 或 8 位），然后只需查找该位字段的指数即可。可能只对狭窄的计算有效，但这是另一种方法。

回复收藏 0 原文

皓月长歌 2024-12-05 14:55:34

http://martin.ankerl.com/2007 /02/11/optimized-exponential-functions-for-java/
使用 Schraudolph 的方法 (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（寻找 Pade 近似）。

http://martin.ankerl.com/2007/02/11/optimized-exponential-functions-for-java/
using Schraudolph's method (http://nic.schraudolph.org/pubs/Schraudolph99.pdf)
in Java:

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

and
https://math.stackexchange.com/a/56064 (look for Pade approximant).

回复收藏 0 原文

Hello爱情风 2024-12-05 14:55:34

这不是您请求的平滑样条插值，但其计算效率很高：

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

绘图输出

This is not the smooth spline interpolation you requested but its computationally efficient:

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

Plot Output

回复收藏 0 原文

对你再特殊 2024-12-05 14:55:34

当然是“可能”的。有几个问题。

您对准确度有什么要求？
您愿意使用高阶样条线吗？
您愿意为此花费多少内存？足够小的间隔内的线性函数将近似指数函数到所需的任何精度，但它可能需要非常小的间隔。

编辑：

鉴于提供的附加信息，我进行了快速测试。范围缩减始终可用于指数函数。因此，如果我想计算任意 x 的 exp(x)，那么我可以用以下形式重写问题...

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

其中 xi 是 x 的整数部分，xf 是小数部分。整数部分很简单。以二进制形式计算 xi，然后重复平方和乘法允许您以相对较少的运算计算 exp(xi)。（其他技巧，使用 2 的幂和其他间隔可以为您提供更快的速度，以满足您对速度的渴望。）

现在剩下的就是计算 exp(xf)。我们是否可以使用具有线性段的样条曲线来计算 exp(xf)，在区间 [0,1] 上仅使用 4 个线性段，精度为 0.005？

最后一个问题是由我几年前编写的一个函数解决的，该函数将使用给定阶数的样条函数逼近一个函数，使其在最大误差的固定容差范围内。该代码需要区间 [0,1] 内的 8 个段才能通过分段线性样条函数实现所需的公差。如果我选择将间隔进一步减小到 [0,0.5]，我现在可以达到规定的容差。

所以答案很简单。如果您愿意缩小范围以将 x 减小到区间 [0.0.5]，然后进行适当的计算，那么您可以使用 4 段的线性样条曲线来达到所要求的精度。

最后，使用硬编码的指数函数总是会更好。如果 exp(x) 可用，上面提到的所有操作肯定会比编译器提供的慢。

Of course it is "possible". There are several issues.

What is your requirement for the accuracy?
Are you willing to use higher order splines?
How much memory are you willing to spend on this? Linear function over small enough intervals will approximate the exponential function to any degree of accuracy needed, but it may require a VERY small interval.

Edit:

Given the additional information provided, I ran a quick test. Range reduction can always be used on the exponential function. Thus, if I wish to compute exp(x) for ANY x, then I can rewrite the problem in the form...

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

where xi is the integer part of x, and xf is the fractional part. The integer part is simple. Compute xi in binary form, then repeated squarings and multiplications allow you to compute exp(xi) in relatively few operations. (Other tricks, using powers of 2 and other intervals can give you yet more speed for the speed hungry.)

All that remains is now to compute exp(xf). Can we use a spline with linear segments to compute exp(xf), over the interval [0,1] with only 4 linear segments, to an accuracy of 0.005?

This last question is resolved by a function that I wrote a few years ago, that will approximate a function with a spline of a given order, to within a fixed tolerance on the maximum error. This code required 8 segments over the interval [0,1] to achieve the required tolerance with a piecewise linear spline function. If I chose to reduce the interval further to [0,0.5], I could now achieve the prescribed tolerance.

So the answer is simple. If you are willing to do the range reductions to reduce x to the interval [0.0.5], then do the appropriate computations, then yes you can achieve the requested accuracy with a linear spline in 4 segments.

In the end, you will always be better off using a hard coded exponential function though. All of the operations mentioned above will surely be slower than what your compiler will provide, IF exp(x) is available.

回复收藏 0 原文