Question

[序言

这个 Q＆amp; A 旨在更清楚地解释我在这里首次发布的近似搜索类的内部工作

Increasing accuracy of solution of transcendental equation

我已经被要求提供关于这几次的更多详细信息（由于各种原因）所以我决定写关于此的 Q＆amp; A 风格主题，我将来可以很容易地参考，不要需要一遍又一遍地解释。

[问题]

如何逼近Real域（double）中的值/参数以实现多项式，参数函数或求解（困难）方程（如超越）的拟合？

限制

真实域名（double精度）
C ++ 语言
可配置的近似精度
已知搜索间隔
拟合值/参数不是严格单调的或根本不起作用

Answer 1

近似搜索

这类似于二分搜索，但没有限制，搜索的函数/值/参数必须是严格单调的函数，同时共享O(n.log(n))复杂度。

例如，假设以下问题

我们知道函数y=f(x)，并希望找到x0 y0=f(x0)。这基本上可以通过f的反函数来完成，但是有许多函数我们不知道如何计算它的反函数。那么在这种情况下如何计算呢？

<强>的已知，

y=f(x) - 输入功能
y0 - 想要点y值
a0,a1 - 解决方案x区间范围

<强>未知

x0 - 想要的点x值必须在x0=<a0,a1>范围内

<强>算法

探测某些点x(i)=<a0,a1>沿着该范围均匀分散，步骤da

例如x(i)=a0+i*da i={ 0,1,2,3... }

x(i)

计算ee 的距离/错误y=f(x(i))

这可以像下面这样计算：ee=fabs(f(x(i))-y0)但也可以使用任何其他指标。
记住点aa=x(i)，距离/错误最小ee
在x(i)>a1
递归提高准确度

所以首先将范围限制为仅搜索找到的解决方案，例如：
```
a0'=aa-da;
a1'=aa+da;
```
然后通过降低搜索步骤来提高搜索精度：
```
da'=0.1*da;
```
如果da'不是太小或者未达到最大递归次数，请转到＃1
找到的解决方案位于aa

这就是我的想法：

左侧是图示的初始搜索（项目符号＃1，＃2，＃3，＃4 ）。在右侧下一个递归搜索（项目符号＃5 ）。这将递归循环，直到达到所需的精度（递归次数）。每次递归都会提高准确度10次（0.1*da）。灰色垂直线代表探测x(i)点。

这里是C ++的源代码：

//---------------------------------------------------------------------------
//--- approx ver: 1.01 ------------------------------------------------------
//---------------------------------------------------------------------------
#ifndef _approx_h
#define _approx_h
#include <math.h>
//---------------------------------------------------------------------------
class approx
    {
public:
    double a,aa,a0,a1,da,*e,e0;
    int i,n;
    bool done,stop;

    approx()            { a=0.0; aa=0.0; a0=0.0; a1=1.0; da=0.1; e=NULL; e0=NULL; i=0; n=5; done=true; }
    approx(approx& a)   { *this=a; }
    ~approx()           {}
    approx* operator = (const approx *a) { *this=*a; return this; }
    //approx* operator = (const approx &a) { ...copy... return this; }

    void init(double _a0,double _a1,double _da,int _n,double *_e)
        {
        if (_a0<=_a1) { a0=_a0; a1=_a1; }
        else          { a0=_a1; a1=_a0; }
        da=fabs(_da);
        n =_n ;
        e =_e ;
        e0=-1.0;
        i=0; a=a0; aa=a0;
        done=false; stop=false;
        }
    void step()
        {
        if ((e0<0.0)||(e0>*e)) { e0=*e; aa=a; }         // better solution
        if (stop)                                       // increase accuracy
            {
            i++; if (i>=n) { done=true; a=aa; return; } // final solution
            a0=aa-fabs(da);
            a1=aa+fabs(da);
            a=a0; da*=0.1;
            a0+=da; a1-=da;
            stop=false;
            }
        else{
            a+=da; if (a>a1) { a=a1; stop=true; }       // next point
            }
        }
    };
//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------

这是如何使用它：

approx aa;
double ee,x,y,x0,y0=here_your_known_value;
//            a0,  a1, da,n, ee  
for (aa.init(0.0,10.0,0.1,6,&ee); !aa.done; aa.step())
    {
    x = aa.a;        // this is x(i)
    y = f(x)         // here compute the y value for whatever you want to fit
    ee = fabs(y-y0); // compute error of solution for the approximation search
    }

for (aa.init(...

是名为的操作数。 a0,a1是x(i)被探测的时间间隔，da是x(i)和n之间的初始步长是递归次数。因此，如果n=6和da=0.1 x的最终最大误差为~0.1/10^6=0.0000001。 &ee是指向变量的指针，其中将计算实际错误。我选择指针，因此在嵌套时没有碰撞。

<强> [注释]

这种近似搜索可以嵌套到任何维度（但粗略需要注意速度）参见一些例子

如果非功能适合并且需要获得“全部”解决方案，则可以在找到解决方案后检查其他解决方案时使用搜索间隔的递归细分。见例：

Given an X co-ordinate, how do I calculate the Y co-ordinate for a point so that it rests on a Bezier Curve

你应该注意什么？

你必须仔细选择搜索间隔<a0,a1>，因此它包含解决方案，但不是太宽（或者它会很慢）。初始步骤da非常重要，如果它太大，你可能会错过本地最小/最大解决方案，或者如果太小，那么事情会变得太慢（特别是对于嵌套的多维拟合）。

Answer 2

secant和bisection方法的组合要好得多：

我们通过割线找到根近似值，并将根保持在二等分中。

始终保持间隔的两条边，使得一边的delta为负，另一边为正，因此根保证在内;而不是减半，使用割线方法。

伪代码：

given a function f
given two points a, b, such that a < b and sign(f(a)) /= sign(f(b))
given tolerance tol
find root z of f such that abs(f(z)) < tol     -- stop_condition

DO:
    x = root of f by linear interpolation of f between a and b
    m = midpoint between a and b

    if stop_condition holds at x or m, set z and STOP

    [a,b] := [a,x,m,b].sort.choose_shortest_interval_with_
                                   _opposite_signs_at_its_ends

这显然在每次迭代时将间隔[a,b]减半，或者甚至更好;因此，除非函数表现极差（例如，sin(1/x)近x=0），这将非常快速地收敛，对于每个迭代步骤，最多只对f进行两次评估。

我们可以通过检查b-a是否变得太小来检测不良行为案例（特别是如果我们使用有限精度，就像在双打中一样）。

近似搜索如何工作

2 个答案: