指数近似不适合小输入或大输入

Exponential approximation not good for small or large input

本文关键字：输入 不适合 指数      更新时间：2023-10-16

基于裁缝级数的指数逼近代码https://en.wikipedia.org/wiki/Taylor_series对于零附近的输入来说效果很好，但在任何方向上移动得更远时都是完全无用的。下面是我的小测试代码的输出，它计算-12到12范围内输入的exp，并打印与std：：exp结果相比的错误，边界处的错误非常大。例如，-12输入的错误约为148255571469%：

in = -12 error = 148255571469.28%
in = -11.00 error = 18328703925.31%
in = -10.00 error = 2037562880.10%
in = -9.00 error = 199120705.27%
in = -8.00 error = 16588916.06%
in = -7.00 error = 01128519.76%
in = -6.00 error = 00058853.00%
in = -5.00 error = 00002133.29%
in = -4.00 error = 00000045.61%
in = -3.00 error = 00000000.42%
in = -2.00 error = 00000000.00%
in = -1.00 error = 00000000.00%
in = 0.00 error = 00000000.00%
in = 1.00 error = 00000000.00%
in = 2.00 error = 00000000.00%
in = 3.00 error = 00000000.00%
in = 4.00 error = 00000000.03%
in = 5.00 error = 00000000.20%
in = 6.00 error = 00000000.88%
in = 7.00 error = 00000002.70%
in = 8.00 error = 00000006.38%
in = 9.00 error = 00000012.42%
in = 10.00 error = 00000020.84%
in = 11.00 error = 00000031.13%
in = 12.00 error = 00000042.40%

我需要在尽可能大的范围内用小于1%的误差进行近似。有什么想法可以实现吗？

我的小测试代码如下：

#include <cmath>
#include <iostream>
#include <iomanip>
double my_exp(double x) //based on https://en.wikipedia.org/wiki/Exponential_function
{
double res = 1. + x, t = x;
unsigned long factorial = 1;
for (unsigned char i = 2; i <= 12; ++i)
{
t *= x, factorial *= i;
res += t / factorial;
}
return res;
}
int main(int argc, char* argv[])
{
for (double in = -12; in <= 12; in += 1.)
{
auto error = std::abs(my_exp(in) - std::exp(in));
auto percent = error * 100. / std::exp(in);
std::cout << "in = " << in << " error = "
<< std::fixed << std::setw( 11 ) << std::setprecision( 2 )
<< std::setfill( '0' ) << percent << "%" << std::endl;
}
return 0;
}

"近似e^x"中看似相似的问题的解决方案近似e^x并不能解决这个问题：

基于Remez和Pade近似的
  • 解决方案只能在有限范围内提供精度(https://stackoverflow.com/a/6985347/5750612)
  • e^x=2x/ln(2(归结为pow的近似，我找不到精确的
  • 裁缝系列不适用于大小输入
  • expf_fast解决方案在所有范围内产生更均匀的误差，但仍然太大(在范围结束时约为20%(

使用Tailor展开找到近似的最简单方法之一是检查收敛速度，只需添加一个新的更高项并确认结果。

以下是我的c++代码来支持上述想法。

#include <iostream>
#include <cmath>
double my_exp(const double x, const double x0 = 0, const double ncut = 1e-3)
{
double res = 1.; 
double addterm = (x - x0);
size_t norder = 1; 
while(true)
{
double res_update = res + addterm;
if(std::abs(res_update - res)/std::abs(res) < ncut){
break;
}
norder += 1;
addterm *= (x - x0)/norder;
res = res_update;
}
return res;
}

int main(int argc, char* argv[])
{
const double x = std::atof(argv[1]);
const double approxi = my_exp(x);
const double exactResult = std::exp(x);
std::cout<<"approxi : "<< approxi<<std::endl;
std::cout<<"exact : "<< exactResult<<std::endl;
std::cout<<"err: "<< (1 - std::abs(approxi/exactResult))*100 <<std::endl;
return 0;
}
相关文章：