近似搜索
这类似于二分搜索，但没有限制，搜索的函数/值/参数必须是严格的单调函数，同时共享 O(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*dai={ 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 是指向将计算实际错误的变量的指针。我选择了指针，这样在嵌套它时不会发生冲突，而且为了提高速度，因为将参数传递给频繁使用的函数会造成堆垃圾。
[注释]
这种近似搜索可以嵌套到任何维度（但粗略的你需要注意速度）查看一些示例
如果出现非函数拟合并且需要获取“所有”解决方案，您可以在找到解决方案后使用搜索间隔的递归细分来检查另一个解决方案。见例子：
您应该注意什么？
您必须仔细选择搜索间隔<a0,a1>，以便它包含解决方案但不会太宽（否则会很慢）。同样，初始步骤da 非常重要，如果它太大，您可能会错过局部最小/最大解决方案，或者如果太小，事情会变得太慢（尤其是对于嵌套多维拟合）。