FORCAL参数优化动态库FcOpt V1.0
目 录
1 什么是FcOpt |
||
fcopt::Opt | 求无约束条件下的n维极小值 | 优化能力一般,速度快。 |
fcopt::ROpt | 求约束条件下的n维极小值 | 优化能力一般,速度快。 |
fcopt::GOpt | 求无约束条件下的n维极小值 | 优化能力强,速度慢。 |
fcopt::RGOpt | 求约束条件下的n维极小值 | 优化能力一般,速度慢。 |
fcopt::ROptIni | 求满足约束条件的一组值 | |
fcopt::OneOpt | 求无约束条件下的n维极小值 | 优化能力强,速度较快。 |
fcopt::ROneOpt | 求约束条件下的n维极小值 | 优化能力一般,速度较快。 |
fcopt::SimOpt | 单形调优法求n维极小值 | 获得局部最优值,速度快。 |
fcopt::OptPassword | 获取机器码,免费注册后使用FcOpt的全部功能 | |
3 优化实例 | ||
3.1 较难的例子 | 选自网上的难题例子 | |
3.2 非线性拟合测试题 | 选自1stOpt的九道测试题 | |
FcOpt32W.dll是一个Forcal参数优化动态库,主要包含一些参数优化函数。
在FcSystem中的函数是通过二级函数命名空间“fcopt”输出的,所有函数均具有类似“fcopt::Opt(...)”的格式。使用!using("fcopt");可简化FcOpt中的函数访问。
FcOpt32W.dll需要FcData32W.dll的支持,FcData32W.dll要先于FcOpt32W.dll加载。
除了使用FcOpt中的优化函数之外,还可使用徐士良算法库XSLSF中的两个局部优化函数:“jsim:求n维极值的单形调优法”和“cplx:求约束条件下n维极值的复形调优法”。
免费注册说明:为了演示设计商业性Forcal扩展动态库的可行性,FcOpt设计成须注册后使用其全部功能。如果没有注册,当优化参数多于2个时,GOpt、RGOpt、OneOpt和ROneOpt函数仅返回最小值,不能返回优化参数。注册是免费的,用函数fcopt::OptPassword获取机器码后,在以下网址回帖或者通过E-mail获取注册码。
网址1:http://blog.csdn.net/forcal/archive/2009/12/27/5087101.aspx
网址2:http://hi.baidu.com/forcal/blog/item/f1bb5c3488f34745241f14cc.html
函数OptPassword的格式(整数函数,返回值及参数pw1,pw1,... ...,pwn将返回多个机器码):fcopt::OptPassword(&pw1,&pw1,... ...,&pwn)
函数OptPassword的用法1:i: fcopt::OptPassword();
函数OptPassword的用法2:i: (:pw)=fcopt::OptPassword(&pw),pw;
函数OptPassword的用法3:i: (:pw)=fcopt::OptPassword(0,&pw),pw;
获取注册码后,在加载FcOpt32W.dll时提供注册码即可。以OpenFC为例,打开工作区文件,修改以下部分(注册码在冒号后):"dll\FcOpt32W.dll:604508320"
只有用GOpt、RGOpt、OneOpt或ROneOpt函数算出了用户认可的极小值后,才需要进行注册。
2 Forcal参数优化函数 [返回页首]
[返回页首][实数函数] fcopt::Opt(f, fcopt::optmax,max, fcopt::optbuf,&buf, fcopt::opteps,eps, fcopt::optinimode,inimode, fcopt::optmode,mode, fcopt::optstep,step, fcopt::optexpand,expand, fcopt::optcontract,contract : &x1, &x2, ... ... , &xn):求无约束条件下的n维极小值
f:自定义n元函数句柄,必须由二级函数HFor获得该句柄,用于计算目标函数f(x1,x2,...,xn)的值,由用户自编。格式如下:
f(x1,x2,...,xn)=
{
g(x1,x2,...,xn)
};
fcopt::optmax,max:max>=2,控制搜索精度,max越大精度越高,但时间越长。可以缺省该参数,缺省值为1000。
fcopt::optbuf,buf:buf>=10,指定缓冲区数目。函数返回时,buf返回实际要求的缓冲区数目。若指定的缓冲区数目小于实际需要的缓冲区数目,可能对搜索结果有影响。
可以缺省该参数,缺省值为50。
fcopt::opteps,eps:控制精度要求,eps>0。可以缺省该参数,缺省值为1e-6。
fcopt::optinimode,inimode:初值搜索模式。inimode取0~7的整数,inimode越大搜索范围越大,但时间越长。inimode=0时,将严格按初始参数执行搜索,inimode>0将尝试调整初始参数。inimode的值仅对初始参数产生影响。可以缺省该参数,缺省值为0。
fcopt::optmode,mode:mode只能取0、1、2。当mode=0时,执行简化搜索,速度最快,但准确度最低;mode=1时,执行中等搜索,速度较快,但准确度较低;mode=2时,执行优化搜索,速度最慢,
但准确度最高。可以缺省该参数,缺省值为2。
fcopt::optstep,step:步长修正系数。step>=1。一般取1~2之间的数。step越小越精确,但时间越长。可以缺省该参数,缺省值为1.5。
fcopt::optexpand,expand:扩张系数。expand>=1。expand越大搜索范围越大,当expand增加时需适当增加max以提高精度。可以缺省该参数,缺省值为64。
fcopt::optcontract,contract:收缩系数。contract>0且contract<=1。
该系数越小,收缩越快;若contract=1,不收缩。不收缩就难以求精,但收缩太快则容易遗漏最优解。可以缺省该参数,缺省值为0.5。
&x1, &x2, ... ... , &xn:参数初值,返回最优参数值。要求初始参数有意义。
返回值:目标函数终值(极小值)。
说明1:fcopt::optmax、fcopt::optbuf、fcopt::opteps、fcopt::optinimode、fcopt::optmode、fcopt::optstep等标识参数类型,次序是任意的,可缺省。
说明2:该函数主要搜索全局最小值附近的极小值,搜索结果可作为优化函数或解方程函数的初值。该函数的初值对搜索结果有重要影响,应变换初值的符号和大小进行搜索,以最小者为最优。
提示:若搜索时间较长,inimode取3以下的数值,mode取0或1可加快速度。
运行错误:
1:指定的表达式不存在或者是常量表达式;
2:表达式的自变量不能重新赋值;
3:参数不匹配;
4:不可识别描述符;
5:参数不符合要求;
6:内存错误。
例子:计算目标函数
J=100*(x1-x0*x0)2+(1-x0)2
程序如下:
f(x0,x1)=
//目标函数定义
{
100*(x1-x0*x0)^2+(1-x0)^2
};
main(:d,k,x0,x1)=
{
k=50,x0=20,x1=-50,
d=fcopt::Opt[HFor("f"),fcopt::optmax,10000,fcopt::optbuf,&k,fcopt::opteps,1e-9:
&x0, &x1],
printff{"\r\nx0={1,r}, x1={2,r}, k={3,i},
f={4,r}\r\n",x0,x1,k,d}
};
[返回页首][实数函数] fcopt::ROpt(f,r, fcopt::optmax,max, fcopt::optbuf,&buf, fcopt::opteps,eps, fcopt::optinimode,inimode, fcopt::optmode,mode, fcopt::optstep,step, fcopt::optexpand,expand, fcopt::optcontract,contract : &x1,x1min,x1max, &x2,x2min,x2max, ... ... , &xn,xnmin,xnmax):求约束条件下的n维极小值
f:自定义n元函数句柄,必须由二级函数HFor获得该句柄,用于计算目标函数f(x1,x2,...,xn)的值,由用户自编。格式如下:
f(x1,x2,...,xn)=
{
g(x1,x2,...,xn)
};
r:自定义n元函数句柄,必须由二级函数HFor获得该句柄,用于计算约束条件r(x1,x2,...,xn)的值 (返回非0值表示满足约束条件,若不满足约束条件,应返回0),由用户自编。格式如下:
r(x1,x2,...,xn)=
{
g(x1,x2,...,xn)
};
fcopt::optmax,max:max>=2,控制搜索精度,max越大精度越高,但时间越长。
可以缺省该参数,缺省值为1000。
fcopt::optbuf,buf:buf>=10,指定缓冲区数目。函数返回时,buf返回实际要求的缓冲区数目。若指定的缓冲区数目小于实际需要的缓冲区数目,可能对搜索结果有影响。
可以缺省该参数,缺省值为50。
fcopt::opteps,eps:控制精度要求,eps>0。可以缺省该参数,缺省值为1e-6。
fcopt::optinimode,inimode:初值搜索模式。inimode取0~7的整数,inimode越大搜索范围越大,但时间越长。inimode=0时,将严格按初始参数执行搜索,inimode>0将尝试调整初始参数。inimode的值仅对初始参数产生影响。可以缺省该参数,缺省值为0。
fcopt::optmode,mode:mode只能取0、1、2。当mode=0时,执行简化搜索,速度最快,但准确度最低;mode=1时,执行中等搜索,速度较快,但准确度较低;mode=2时,执行优化搜索,速度最慢,但准确度最高。可以缺省该参数,缺省值为2。
fcopt::optstep,step:步长修正系数。step>=1。一般取1~2之间的数。step越小越精确,但时间越长。可以缺省该参数,缺省值为1.5。
fcopt::optexpand,expand:扩张系数。expand>=1。expand越大搜索范围越大,当expand增加时需适当增加max以提高精度。可以缺省该参数,缺省值为64。
fcopt::optcontract,contract:收缩系数。contract>0且contract<=1。
该系数越小,收缩越快;若contract=1,不收缩。不收缩就难以求精,但收缩太快则容易遗漏最优解。可以缺省该参数,缺省值为0.5。
&xi,ximin,ximax:第i个参数初值及搜索区间,要求ximin<ximax。返回时,xi存放第i个参数最优值。要求初始参数满足所有约束条件。
返回值:目标函数终值(极小值)。
说明1:fcopt::optmax、fcopt::optbuf、fcopt::opteps、fcopt::optinimode、fcopt::optmode、fcopt::optstep等标识参数类型,次序是任意的,可缺省。
说明2:该函数主要搜索全局最小值附近的极小值,搜索结果可作为优化函数的初值。该函数的初值对搜索结果有重要影响,应变换初值的符号和大小进行搜索,以最小者为最优。
提示:若搜索时间较长,inimode取3以下的数值,mode取0或1可加快速度。
运行错误:
1:指定的表达式不存在、不匹配或者是常量表达式;
2:表达式的自变量不能重新赋值;
3:参数不匹配;
4:不可识别描述符;
5:参数不符合要求,特别检查初始参数是否满足所有约束条件;
6:内存错误;
7:无法满足约束条件,搜索停止。
例子:计算目标函数
J=f(x0,x1)=-[9-(x0-3)2]*x13/[27*sqrt(3)]
满足约束条件
x0≥0
x1≥0
0≤x1≤x0/sqrt(3)
0≤x0+sqrt(3)*x1≤6
的极小值点与极小值。
其中常量约束条件中的下界为a0=0,a1=0,上界取b0=1000,b1=1000。
程序如下:
f(x0,x1)=
//目标函数定义
{
-[9-(x0-3)^2]*x1^3/[27*sqrt(3)]
};
s(x0,x1)= //约束条件定义
{
if{x1<=x0/sqrt(3)
& x0+sqrt(3)*x1<=6,
return(1)},0
};
main(:d,k,x0,x1)=
{
k=50,x0=1,x1=0.1,
d=fcopt::ROpt[HFor("f"),HFor("s"),fcopt::optmax,10000,fcopt::optbuf,&k,fcopt::opteps,1e-9:
&x0,0,1000, &x1,0,1000],
printff{"\r\nx0={1,r}, x1={2,r}, k={3,i},
f={4,r}\r\n",x0,x1,k,d}
};
[返回页首][实数函数] fcopt::GOpt(f, fcopt::optmax,max, fcopt::optbuf,&buf, fcopt::opteps,eps, fcopt::optit,&it, fcopt::optdx,dx, fcopt::optmode,mode, fcopt::optstep,step, fcopt::optsame,same, fcopt::optsameeps,sameeps, fcopt::optarray,array,&k, fcopt::optdebug,debug, fcopt::optexpand,expand, fcopt::optcontract,contract, fcopt::optfast,fast, fcopt::optdeep,deep : &x1, &x2, ... ... , &xn):求无约束条件下的n维极小值
f:自定义n元函数句柄,必须由二级函数HFor获得该句柄,用于计算目标函数f(x1,x2,...,xn)的值,由用户自编。格式如下:
f(x1,x2,...,xn)=
{
g(x1,x2,...,xn)
};
fcopt::optmax,max:max>=2,控制搜索精度,max越大精度越高,但时间越长。可以缺省该参数,缺省值为1000。
fcopt::optbuf,buf:buf>=1,指定缓冲区数目。函数返回时,buf返回实际要求的缓冲区数目。若指定的缓冲区数目小于实际需要的缓冲区数目,可能对搜索结果有影响。可以缺省该参数,缺省值为10。
fcopt::opteps,eps:控制精度要求,eps>0。可以缺省该参数,缺省值为1e-6。
fcopt::optit,it:迭代次数。it>=1。it越大精度越高,但时间越长。函数返回时,it返回实际迭代次数;若实际迭代次数与设置的迭代次数相等,可能没有满足精度要求。可以缺省该参数,缺省值为10。
fcopt::optdx,dx:极小值,影响极值点的准确性,取合适的数值。dx>0。可以缺省该参数,缺省值为1e-5。通常不需要修改该参数。
fcopt::optmode,mode:mode只能取0、1、2。当mode=0时,执行简化搜索,速度快,但准确度低;mode=1时,执行优化搜索,速度慢,但准确度
高;mode=2时,执行优化搜索,速度最慢,但准确度高。可以缺省该参数,缺省值为0。
fcopt::optstep,step:步长修正系数。step>=1。一般取1~2之间的数。step越小越精确,但时间越长。可以缺省该参数,缺省值为1.5。
fcopt::optsame,same:缓冲区中允许保存的相同值数目,same>=1。可以缺省该参数,缺省值为3。
fcopt::optsameeps,sameeps:比较两组值是否相等的极小值。sameeps>0。可以缺省该参数,缺省值为1e-2。
fcopt::optarray,array,k:返回极小值的二维数组m×(n+1);n为自变量的个数,最多返回m组数据,每组数据中,前n个数为极小值点处的自变量,最后一个存放极小值;k返回实际数据组数。可以缺省该参数。
fcopt::optdebug,debug:debug>=0。debug为0时执行正常的优化搜索;若debug为1,仅根据给定的初值搜索1次;若debug为2,根据给定的初值搜索2次;以此类推。可以缺省该参数,缺省值为0。
fcopt::optexpand,expand:扩张系数。expand>=1。expand越大搜索范围越大,当expand增加时需适当增加max以提高精度。可以缺省该参数,缺省值为64。
fcopt::optcontract,contract:收缩系数。contract>0且contract<=1。
该系数越小,收缩越快;若contract=1,不收缩。不收缩就难以求精,但收缩太快则容易遗漏最优解。可以缺省该参数,缺省值为0.5。
fcopt::optfast,fast:加速系数。fast>=0且fast<=1。该系数越大,速度越快,但准确度降低。可以缺省该参数,缺省值为1.0。
fcopt::optdeep,deep:深度搜索。deep为整数,deep=0,不进行深度搜索,否则进行深度搜索,深度搜索时将降低求解速度。可以缺省该参数,缺省值为0。
&x1, &x2, ... ... , &xn:参数初值,返回最优参数值。要求初始参数有意义。
返回值:目标函数终值(极小值)。
说明1:fcopt::optmax、fcopt::optbuf、fcopt::opteps、fcopt::optmode、fcopt::optstep等标识参数类型,次序是任意的,可缺省。
说明2:该函数搜索全局最小值。初值对搜索结果有重要影响,应变换初值的符号和大小进行搜索,以最小者为最优。
运行错误:
1:指定的表达式不存在或者是常量表达式;
2:表达式的自变量不能重新赋值;
3:参数不匹配;
4:不可识别描述符;
5:参数不符合要求;
6:内存错误;
7:指定的数组不存在;
8:不是二维数组;
9:数组维数不正确。
例子1:求下列隐函数z的最小值(能求出此例最小值的软件目前还不多):
z=sin[(z*x-0.5)^2+2*x*y*y-z/10]*exp{-[(x-0.5-exp(-y+z))^2+y*y-z/5+3]}
其中x范围[-1,7],y范围[-2,2]。
程序如下:
f(x,y,z)=
//构造目标函数,注意1e10
{
z+1e10*{z-sin[(z*x-0.5)^2+2*x*y*y-z/10]*exp{-[(x-0.5-exp(-y+z))^2+y*y-z/5+3]}}^2
};
验证(x,y,z)= z-sin[(z*x-0.5)^2+2*x*y*y-z/10]*exp{-[(x-0.5-exp(-y+z))^2+y*y-z/5+3]};
//用于验证结果的准确性,越小越准确
main(:f,x,y,z)=
{
x=1,y=-1,z=-1,
f=fcopt::GOpt[HFor("f"), fcopt::optmax,3000, fcopt::optmode,1
: &x, &y, &z],
printff{"\r\nx={1,r}, y={2,r}, z={3,r}, f={4,r}\r\n", x, y,
z, f},
验证(x,y,z)
};
例子2:求针状函数的全局最小值,并返回10个极小值:
f(r)=-sin(r)/r+1
其中:r=sqrt[(x-50)^2+(y-50)^2]+exp[1]。
程序如下:
!using("fcopt","XSLSF");
f(x,y:t)= //目标函数定义
{
t=sqrt[(x-50)^2+(y-50)^2]+exp[1],
-sin[t]/t-1
};
main(:i,k,x,y,f,array)=
{
array=new[rtoi(real_s),rtoi(10),rtoi(3)],
i=20,x=30,y=20,
f=GOpt[HFor("f"), optbuf,&i, optmode,1, optstep,1,
optarray,array,&k : &x, &y],
printff{"\r\n实际缓冲区数目={1,i}, 返回极小值组数={2,i}, x={3,r}, y={4,r},
f={5,r}\r\n\r\n",i,k,x,y,f},
i=0,(i<k).while{
printff{"x={1,r,-25.16}y={2,r,-25.16}极小值={3,r,-25.16}\r\n",array.getrai[i,0],array.getrai[i,1],array.getrai[i,2]},
i++
},
delete[array],
f(x,y)
};
[返回页首][实数函数] fcopt::RGOpt(f,r, fcopt::optmax,max, fcopt::optbuf,&buf, fcopt::opteps,eps, fcopt::optit,&it, fcopt::optdx,dx, fcopt::optmode,mode, fcopt::optstep,step, fcopt::optsame,same, fcopt::optsameeps,sameeps, fcopt::optarray,array,&k, fcopt::optdebug,debug, fcopt::optexpand,expand, fcopt::optcontract,contract, fcopt::optfast,fast, fcopt::optdeep,deep : &x1,x1min,x1max, &x2,x2min,x2max, ... ... , &xn,xnmin,xnmax):求约束条件下的n维极小值
f:自定义n元函数句柄,必须由二级函数HFor获得该句柄,用于计算目标函数f(x1,x2,...,xn)的值,由用户自编。格式如下:
f(x1,x2,...,xn)=
{
g(x1,x2,...,xn)
};
r:自定义n元函数句柄,必须由二级函数HFor获得该句柄,用于计算约束条件r(x1,x2,...,xn)的值 (返回非0值表示满足约束条件,若不满足约束条件,应返回0),由用户自编。格式如下:
r(x1,x2,...,xn)=
{
g(x1,x2,...,xn)
};
fcopt::optmax,max:max>=2,控制搜索精度,max越大精度越高,但时间越长。可以缺省该参数,缺省值为1000。
fcopt::optbuf,buf:buf>=1,指定缓冲区数目。函数返回时,buf返回实际要求的缓冲区数目。若指定的缓冲区数目小于实际需要的缓冲区数目,可能对搜索结果有影响。可以缺省该参数,缺省值为10。
fcopt::opteps,eps:控制精度要求,eps>0。可以缺省该参数,缺省值为1e-6。
fcopt::optit,it:迭代次数。it>=1。it越大精度越高,但时间越长。函数返回时,it返回实际迭代次数;若实际迭代次数与设置的迭代次数相等,可能没有满足精度要求。可以缺省该参数,缺省值为10。
fcopt::optdx,dx:极小值,影响极值点的准确性,取合适的数值。dx>0。可以缺省该参数,缺省值为1e-5。通常不需要修改该参数。
fcopt::optmode,mode:mode只能取0、1、2。当mode=0时,执行简化搜索,速度快,但准确度低;mode=1时,执行优化搜索,速度慢,但准确度高;mode=2时,执行优化搜索,速度最慢,但准确度高。可以缺省该参数,缺省值为0。
fcopt::optstep,step:步长修正系数。step>=1。一般取1~2之间的数。step越小越精确,但时间越长。可以缺省该参数,缺省值为1.5。
fcopt::optsame,same:缓冲区中允许保存的相同值数目,same>=1。可以缺省该参数,缺省值为3。
fcopt::optsameeps,sameeps:比较两组值是否相等的极小值。sameeps>0。可以缺省该参数,缺省值为1e-2。
fcopt::optarray,array,k:返回极小值的二维数组m×(n+1);n为自变量的个数,最多返回m组数据,每组数据中,前n个数为极小值点处的自变量,最后一个存放极小值;k返回实际数据组数。可以缺省该参数。
fcopt::optdebug,debug:debug>=0。debug为0时执行正常的优化搜索;若debug为1,仅根据给定的初值搜索1次;若debug为2,根据给定的初值搜索2次;以此类推。可以缺省该参数,缺省值为0。
fcopt::optexpand,expand:扩张系数。expand>=1。expand越大搜索范围越大,当expand增加时需适当增加max以提高精度。可以缺省该参数,缺省值为64。
fcopt::optcontract,contract:收缩系数。contract>0且contract<=1。
该系数越小,收缩越快;若contract=1,不收缩。不收缩就难以求精,但收缩太快则容易遗漏最优解。可以缺省该参数,缺省值为0.5。
fcopt::optfast,fast:加速系数。fast>=0且fast<=1。该系数越大,速度越快,但准确度降低。可以缺省该参数,缺省值为1.0。
fcopt::optdeep,deep:深度搜索。deep为整数,deep=0,不进行深度搜索,否则进行深度搜索,深度搜索时将降低求解速度。可以缺省该参数,缺省值为0。
&xi,ximin,ximax:第i个参数初值及搜索区间,要求ximin<ximax。返回时,xi存放第i个参数最优值。要求初始参数满足所有约束条件。
返回值:目标函数终值(极小值)。
说明1:fcopt::optmax、fcopt::optbuf、fcopt::opteps、fcopt::optmode、fcopt::optstep等标识参数类型,次序是任意的,可缺省。
说明2:该函数搜索全局最小值。初值对搜索结果有重要影响,应变换初值的符号和大小进行搜索,以最小者为最优。
运行错误:
1:指定的表达式不存在、不匹配或者是常量表达式;
2:表达式的自变量不能重新赋值;
3:参数不匹配;
4:不可识别描述符;
5:参数不符合要求,特别检查初始参数是否满足所有约束条件;
6:内存错误;
7:指定的数组不存在;
8:不是二维数组;
9:数组维数不正确。
例子:求下列函数的最小值:
-(x*sin(9*Pi*y) + y*cos(25*Pi*x) + 20)
约束条件: x范围[-9,0],y范围[-9,0];x^2
+ y^2 <= 9^2。
程序如下:
!using["fcopt"];
f(x,y:Pi)=
//目标函数定义
{
Pi=3.141592653589793,
-(x*sin(9*Pi*y) + y*cos(25*Pi*x) + 20)
};
s(x,y)=
//约束条件定义
{
if{x^2 + y^2 <= 9^2, return(1)},0
};
main(:d,k,x,y)=
{
k=100,x=-2,y=-2,
d=RGOpt[HFor("f"),HFor("s"),optmax,8000, optcontract,0.9,
optbuf,&k,opteps,1e-9,optmode,1,optstep,1.1,optit,20: &x,-9,0, &y,-9,0],
printff{"\r\nx={1,r}, y={2,r}, k={3,i}, f={4,r}\r\n",x,y,k,d}
};
[返回页首][实数函数] fcopt::ROptIni(f,r, fcopt::optmax,max, fcopt::opteps,eps, fcopt::optexpand,expand, fcopt::optcontract,contract, fcopt::optmaxmax,maxmax : &x1,x1min,x1max, &x2,x2min,x2max, ... ... , &xn,xnmin,xnmax):求满足约束条件的 一组值
f:自定义n元函数句柄,必须由二级函数HFor获得该句柄,用于计算目标函数f(x1,x2,...,xn)的值,由用户自编。格式如下:
f(x1,x2,...,xn)=
{
g(x1,x2,...,xn)
};
r:自定义n元函数句柄,必须由二级函数HFor获得该句柄,用于计算约束条件r(x1,x2,...,xn)的值(返回非0值表示满足约束条件,若不满足约束条件,应返回0),由用户自编。格式如下:
r(x1,x2,...,xn)=
{
g(x1,x2,...,xn)
};
fcopt::optmax,max:max>=3,控制搜索精度,max越大精度越高,但时间越长。可以缺省该参数,缺省值为1000。
fcopt::opteps,eps:极小值,eps>0。一般缺省该参数,缺省值为1e-6。
fcopt::optexpand,expand:扩张系数。expand>=1。expand越大搜索范围越大,当expand增加时需适当增加max以提高精度。可以缺省该参数,缺省值为64。
fcopt::optcontract,contract:收缩系数。contract>0且contract<1。该系数越小,收缩越快。可以缺省该参数,缺省值为0.5。
fcopt::optmaxmax,maxmax:代表搜索精度的极大值,maxmax>=3。可以缺省该参数,缺省值为1e10。通常不需要修改该参数。当优化参数多于10个时,通常需要修改该参数为更大的值。
&xi,ximin,ximax:第i个参数初值及搜索区间,要求ximin<ximax。返回时,xi存放第i个参数最优值。
返回值:若为0,没有搜到满足约束条件的一组值;否则搜索成功,返回一组最优的初值。
说明:初值对搜索结果有重要影响,应变换初值的符号和大小进行搜索,以最小者为最优。
运行错误:
1:指定的表达式不存在、不匹配或者是常量表达式;
2:表达式的自变量不能重新赋值;
3:参数不匹配;
4:不可识别描述符;
5:参数不符合要求;
6:内存错误。
例子:求满足下面约束条件的一组值:
-(x*sin(9*Pi*y) + y*cos(25*Pi*x) + 20)
约束条件: x范围[-9,0],y范围[-9,0];x^2
+ y^2 <= 9^2。
程序如下:
!using["fcopt"];
f(x,y:Pi)=
//目标函数定义
{
Pi=3.141592653589793,
-(x*sin(9*Pi*y) + y*cos(25*Pi*x) + 20)
};
s(x,y)=
//约束条件定义
{
if{x^2 + y^2 <= 9^2, return(1)},0
};
main(:d,x,y)=
{
x=-2,y=-2,
d=ROptIni[HFor("f"),HFor("s") : &x,-9,0, &y,-9,0],
printff{"\r\nx={1,r}, y={2,r}, 函数值={3,r}, 标志={4,i}\r\n",x,y,f(x,y),d}
};
[返回页首][实数函数] fcopt::OneOpt(f, fcopt::optmax,max, fcopt::optbuf,&buf, fcopt::opteps,eps, fcopt::optit,&it, fcopt::optdx,dx, fcopt::optmode,mode, fcopt::optsame,same, fcopt::optsameeps,sameeps, fcopt::optarray,array,&k, fcopt::optdebug,debug, fcopt::optexpand,expand, fcopt::optcontract,contract, fcopt::optfast,fast, fcopt::optmaxmax,maxmax : &x1, &x2, ... ... , &xn):求无约束条件下的n维极小值
f:自定义n元函数句柄,必须由二级函数HFor获得该句柄,用于计算目标函数f(x1,x2,...,xn)的值,由用户自编。格式如下:
f(x1,x2,...,xn)=
{
g(x1,x2,...,xn)
};
fcopt::optmax,max:max>=3,控制搜索精度,max越大精度越高,但时间越长。可以缺省该参数,缺省值为1000。
fcopt::optbuf,buf:buf>=1,指定缓冲区数目。函数返回时,buf返回实际要求的缓冲区数目。若指定的缓冲区数目小于实际需要的缓冲区数目,可能对搜索结果有影响。可以缺省该参数,缺省值为10。
fcopt::opteps,eps:控制精度要求,eps>0。可以缺省该参数,缺省值为1e-6。
fcopt::optit,it:迭代次数。it>=1。it越大精度越高,但时间越长。函数返回时,it返回实际迭代次数;若实际迭代次数与设置的迭代次数相等,可能没有满足精度要求。可以缺省该参数,缺省值为10。
fcopt::optdx,dx:极小值,影响极值点的准确性,取合适的数值。dx>0。可以缺省该参数,缺省值为1e-5。通常不需要修改该参数。
fcopt::optmode,mode:工作模式。mode>=0。当mode=0时,执行最优化搜索,速度最慢,但准确度最高;mode>=1时,mode越大搜索范围越大,速度
越慢,但准确度越高;mode大到一定值后,相当于mode=0。可以缺省该参数,缺省值为5。
fcopt::optsame,same:缓冲区中允许保存的相同值数目,same>=1。可以缺省该参数,缺省值为3。
fcopt::optsameeps,sameeps:比较两组值是否相等的极小值。sameeps>0。可以缺省该参数,缺省值为1e-2。
fcopt::optarray,array,k:返回极小值的二维数组m×(n+1);n为自变量的个数,最多返回m组数据,每组数据中,前n个数为极小值点处的自变量,最后一个存放极小值;k返回实际数据组数。可以缺省该参数。
fcopt::optdebug,debug:debug>=0。debug为0时执行正常的优化搜索;若debug为1,仅根据给定的初值搜索1次;若debug为2,根据给定的初值搜索2次;以此类推。可以缺省该参数,缺省值为0。
fcopt::optexpand,expand:扩张系数。expand>=1。expand越大搜索范围越大,当expand增加时需适当增加max以提高精度。可以缺省该参数,缺省值为64。
fcopt::optcontract,contract:收缩系数。contract>0且contract<=1。
该系数越小,收缩越快;若contract=1,不收缩。不收缩就难以求精,但收缩太快则容易遗漏最优解。可以缺省该参数,缺省值为0.5。
fcopt::optfast,fast:加速系数。fast=0,速度慢,但准确度高;否则,速度快,但准确度低。可以缺省该参数,缺省值为0。
fcopt::optmaxmax,maxmax:代表搜索精度的极大值,maxmax>=3。可以缺省该参数,缺省值为1e10。通常不需要修改该参数。当优化参数多于10个时,通常需要修改该参数为更大的值。
&x1, &x2, ... ... , &xn:参数初值,返回最优参数值。要求初始参数有意义。
返回值:目标函数终值(极小值)。
说明1:fcopt::optmax、fcopt::optbuf、fcopt::opteps、fcopt::optmode等标识参数类型,次序是任意的,可缺省。
说明2:该函数搜索全局最小值。初值对搜索结果有重要影响,应变换初值的符号和大小进行搜索,以最小者为最优。
运行错误:
1:指定的表达式不存在或者是常量表达式;
2:表达式的自变量不能重新赋值;
3:参数不匹配;
4:不可识别描述符;
5:参数不符合要求;
6:内存错误;
7:指定的数组不存在;
8:不是二维数组;
9:数组维数不正确。
例子1:求下列隐函数z的最小值(能求出此例最小值的软件目前还不多):
z=sin[(z*x-0.5)^2+2*x*y*y-z/10]*exp{-[(x-0.5-exp(-y+z))^2+y*y-z/5+3]}
其中x范围[-1,7],y范围[-2,2]。
程序如下:
f(x,y,z)=
//构造目标函数,注意1e10
{
z+1e10*{z-sin[(z*x-0.5)^2+2*x*y*y-z/10]*exp{-[(x-0.5-exp(-y+z))^2+y*y-z/5+3]}}^2
};
验证(x,y,z)= z-sin[(z*x-0.5)^2+2*x*y*y-z/10]*exp{-[(x-0.5-exp(-y+z))^2+y*y-z/5+3]};
//用于验证结果的准确性,越小越准确
main(:f,x,y,z)=
{
x=1,y=-1,z=-1,
f=fcopt::OneOpt[HFor("f"), fcopt::optmax,5000, fcopt::optexpand,3
: &x, &y, &z],
printff{"\r\nx={1,r}, y={2,r}, z={3,r}, f={4,r}\r\n", x, y,
z, f},
验证(x,y,z)
};
例子2:求针状函数的全局最小值,并返回10个极小值:
f(r)=-sin(r)/r+1
其中:r=sqrt[(x-50)^2+(y-50)^2]+exp[1]。
程序如下:
!using("fcopt","XSLSF");
f(x,y:t)= //目标函数定义
{
t=sqrt[(x-50)^2+(y-50)^2]+exp[1],
-sin[t]/t-1
};
main(:i,k,x,y,f,array)=
{
array=new[rtoi(real_s),rtoi(10),rtoi(3)],
i=20,x=30,y=30,
f=OneOpt[HFor("f"), optbuf,&i, optmax,5000, optexpand,3,
optarray,array,&k : &x, &y],
printff{"\r\n实际缓冲区数目={1,i}, 返回极小值组数={2,i}, x={3,r}, y={4,r},
f={5,r}\r\n\r\n",i,k,x,y,f},
i=0,(i<k).while{
printff{"x={1,r,-25.16}y={2,r,-25.16}极小值={3,r,-25.16}\r\n",array.getrai[i,0],array.getrai[i,1],array.getrai[i,2]},
i++
},
delete[array],
f(x,y)
};
[返回页首][实数函数] fcopt::ROneOpt(f,r, fcopt::optmax,max, fcopt::optbuf,&buf, fcopt::opteps,eps, fcopt::optit,&it, fcopt::optdx,dx, fcopt::optmode,mode, fcopt::optsame,same, fcopt::optsameeps,sameeps, fcopt::optarray,array,&k, fcopt::optdebug,debug, fcopt::optexpand,expand, fcopt::optcontract,contract, fcopt::optfast,fast, fcopt::optmaxmax,maxmax : &x1,x1min,x1max, &x2,x2min,x2max, ... ... , &xn,xnmin,xnmax):求约束条件下的n维极小值
f:自定义n元函数句柄,必须由二级函数HFor获得该句柄,用于计算目标函数f(x1,x2,...,xn)的值,由用户自编。格式如下:
f(x1,x2,...,xn)=
{
g(x1,x2,...,xn)
};
r:自定义n元函数句柄,必须由二级函数HFor获得该句柄,用于计算约束条件r(x1,x2,...,xn)的值(返回非0值表示满足约束条件,若不满足约束条件,应返回0),由用户自编。格式如下:
r(x1,x2,...,xn)=
{
g(x1,x2,...,xn)
};
fcopt::optmax,max:max>=3,控制搜索精度,max越大精度越高,但时间越长。可以缺省该参数,缺省值为1000。
fcopt::optbuf,buf:buf>=1,指定缓冲区数目。函数返回时,buf返回实际要求的缓冲区数目。若指定的缓冲区数目小于实际需要的缓冲区数目,可能对搜索结果有影响。可以缺省该参数,缺省值为10。
fcopt::opteps,eps:控制精度要求,eps>0。可以缺省该参数,缺省值为1e-6。
fcopt::optit,it:迭代次数。it>=1。it越大精度越高,但时间越长。函数返回时,it返回实际迭代次数;若实际迭代次数与设置的迭代次数相等,可能没有满足精度要求。可以缺省该参数,缺省值为10。
fcopt::optdx,dx:极小值,影响极值点的准确性,取合适的数值。dx>0。可以缺省该参数,缺省值为1e-5。通常不需要修改该参数。
fcopt::optmode,mode:工作模式。mode>=0。当mode=0时,执行最优化搜索,速度最慢,但准确度最高;mode>=1时,mode越大搜索范围越大,速度越慢,但准确度越高;mode大到一定值后,相当于mode=0。可以缺省该参数,缺省值为5。
fcopt::optsame,same:缓冲区中允许保存的相同值数目,same>=1。可以缺省该参数,缺省值为3。
fcopt::optsameeps,sameeps:比较两组值是否相等的极小值。sameeps>0。可以缺省该参数,缺省值为1e-2。
fcopt::optarray,array,k:返回极小值的二维数组m×(n+1);n为自变量的个数,最多返回m组数据,每组数据中,前n个数为极小值点处的自变量,最后一个存放极小值;k返回实际数据组数。可以缺省该参数。
fcopt::optdebug,debug:debug>=0。debug为0时执行正常的优化搜索;若debug为1,仅根据给定的初值搜索1次;若debug为2,根据给定的初值搜索2次;以此类推。可以缺省该参数,缺省值为0。
fcopt::optexpand,expand:扩张系数。expand>=1。expand越大搜索范围越大,当expand增加时需适当增加max以提高精度。可以缺省该参数,缺省值为64。
fcopt::optcontract,contract:收缩系数。contract>0且contract<=1。
该系数越小,收缩越快;若contract=1,不收缩。不收缩就难以求精,但收缩太快则容易遗漏最优解。可以缺省该参数,缺省值为0.5。
fcopt::optfast,fast:加速系数。fast=0,速度慢,但准确度高;否则,速度快,但准确度低。可以缺省该参数,缺省值为0。
fcopt::optmaxmax,maxmax:代表搜索精度的极大值,maxmax>=3。可以缺省该参数,缺省值为1e10。通常不需要修改该参数。当优化参数多于10个时,通常需要修改该参数为更大的值。
&xi,ximin,ximax:第i个参数初值及搜索区间,要求ximin<ximax。返回时,xi存放第i个参数最优值。要求初始参数满足所有约束条件。
返回值:目标函数终值(极小值)。
说明1:fcopt::optmax、fcopt::optbuf、fcopt::opteps、fcopt::optmode、fcopt::optstep等标识参数类型,次序是任意的,可缺省。
说明2:该函数搜索全局最小值。初值对搜索结果有重要影响,应变换初值的符号和大小进行搜索,以最小者为最优。
运行错误:
1:指定的表达式不存在、不匹配或者是常量表达式;
2:表达式的自变量不能重新赋值;
3:参数不匹配;
4:不可识别描述符;
5:参数不符合要求,特别检查初始参数是否满足所有约束条件;
6:内存错误;
7:指定的数组不存在;
8:不是二维数组;
9:数组维数不正确。
例子:求全局最小值:f(x,y)=cos(x)-exp((x-0.5)*y);
约束条件:x^2+y^2<=1
程序如下:
!using["fcopt"];
f(x,y)=cos(x)-exp((x-0.5)*y);
//目标函数定义
s(x,y)=which{x^2 + y^2 <= 1, 1, 0};
//约束条件定义
main(:d,k,x,y)=
{
k=100,x=-0.5, y=0.5,
d=ROneOpt[HFor("f"),HFor("s"),optmax,200000, optbuf,&k,
optexpand,2 : &x,-1,1, &y,-1,1],
printff{"\r\nx={1,r}, y={2,r}, k={3,i}, f={4,r}\r\n",x,y,k,d}
};
[返回页首][实数函数] fcopt::SimOpt(f,fcopt::optmax,max, fcopt::opteps,eps, fcopt::optexpand,expand, fcopt::optcontract,contract, fcopt::optstep,step : &x1,&x2, ... ... , &xn,&MinVal):单形调优法求n维极小值
f:自定义n元函数句柄,必须由二级函数HFor获得该句柄,用于计算目标函数f(x1,x2,...,xn)的值,由用户自编。格式如下:
f(x1,x2,...,xn)=
{
g(x1,x2,...,xn)
};
fcopt::optmax,max:max>=1,允许的最大迭代次数。可以缺省该参数,缺省值为1000。
fcopt::opteps,eps:控制精度要求,eps>0。可以缺省该参数,缺省值为1e-6。
fcopt::optexpand,expand:扩张系数。expand>0,一般取1.2~2.0。可以缺省该参数,缺省值为1.6。
fcopt::optcontract,contract:收缩系数。contract>0,一般取0~1。可以缺省该参数,缺省值为0.5。
fcopt::optstep,step:初始单形中任意两顶点间的距离。当step=0时,需在 &x1,&x2, ... ... , &xn,&MinVal
中提供一组初值。可以缺省该参数,缺省值为1。
&x1,&x2, ... ... , &xn:该参数用于返回最优参数值。当step=0时,需在 &x1,&x2, ... ... , &xn
中提供一组初值。
&MinVal:用于返回目标函数终值(极小值)。当step=0时,存放一个调整系数,最好在0~2之间,但不能为1。
返回值:返回实际迭代次数。若返回值=max,可能没有满足精度要求,返回的值仅作参考。。
说明1:fcopt::optmax、fcopt::opteps、fcopt::optstep等标识参数类型,次序是任意的,可缺省。
说明2:该函数搜索局部最小值。初值对搜索结果有重要影响,应变换初值的符号和大小进行搜索,以最小者为最优。
运行错误:
1:参数不匹配;
2:指定的表达式不存在或者是常量表达式;
3:不可识别描述符;
4:参数不符合要求;
5:内存错误。
例子:计算目标函数
J=100*(x1-x0*x0)2+(1-x0)2
的极小值点与极小值。
程序如下:
f(x0,x1)=
//函数定义
{
100*(x1-x0*x0)^2+(1-x0)^2
};
main(:x0,x1,min,i)=
{
i=fcopt::SimOpt[HFor("f"),&x0,&x1,&min],
printff{"\r\n实际迭代次数={1,i}, x0={2,r}, x1={3,r}, min={4,r}\r\n",i,x0,x1,min}
};
3 优化实例
3.1 较难的例子
3.1.1 拟合公式:y = (p1)+(p2*Exp(-p3*x/p5)+p4/(1+p4*p5*x))
p1,p2,p3,p4,p5为待求参数
数据(x, y)
0, 0.928
0.0000098, 1.02
0.0000195, 1.12
0.0000293, 1.25
0.0000391, 1.42
0.0000488, 1.7
0.0000586, 2.01
0.0000684, 2.26
0.0000781, 2.46
0.0000879, 2.63
0.0000977, 2.82
0.0001074, 3.01
0.0001172, 3.2
0.000127, 3.41
0.0001367, 3.59
0.0001465, 3.72
0.0001562, 3.85
0.000166, 3.98
0.0001758, 4.08
(正解的均方差RMSE=0.033377163531,残差平方和为0.0211666658630,相关系数R = 0.999497560)
Forcal代码:
!using["fcopt"];
f(p1,p2,p3,p4,p5:i,s,x,y:Array,max)=
//目标函数定义
{
s=0,i=0,(i<max).while{
Array.XSLSF::getra[i*2,&x,&y],
s=s+[(p1)+(p2*exp(-p3*x/p5)+p4/(1+p4*p5*x))-y]^2,
i++
},
sqrt[s/max]
};
main(:d,k,p1,p2,p3,p4,p5:Array,max)=
{
max=19,
Array=new{rtoi(real_s),rtoi(max),rtoi(2),rtoi(EndType),
0, 0.928,
0.0000098, 1.02,
0.0000195, 1.12,
0.0000293, 1.25,
0.0000391, 1.42,
0.0000488, 1.7,
0.0000586, 2.01,
0.0000684, 2.26,
0.0000781, 2.46,
0.0000879, 2.63,
0.0000977, 2.82,
0.0001074, 3.01,
0.0001172, 3.2,
0.000127, 3.41,
0.0001367, 3.59,
0.0001465, 3.72,
0.0001562, 3.85,
0.000166, 3.98,
0.0001758, 4.08
},
k=30,p1=-1,p2=-1,p3=-1,p4=-1,p5=-1,
d=GOpt[HFor("f"),optmax,1000, optbuf,&k, optcontract,0.9,
optmode,1, optstep,1.1 : &p1, &p2, &p3, &p4, &p5],
printff{"\r\np1={1,r}, p2={2,r}, p3={3,r}, p4={4,r},
p5={5,r}, k={6,i}, f={7,r}\r\n",p1,p2,p3,p4,p5,k,d}
};
3.1.2 拟合公式:z = p0*(1-exp(-p1*(x-p2)))+p3*x^p4+p5*x*y;
参数:p0 - p5
变量:x,y,z
数据(x,y,z):
2 101 172
3 14 210
4 136 241
5 52 265
6 67 280
7 81 289
8 54 294
9 20 302
10 6 299
11 2 306
Forcal代码:
!using["fcopt"];
f(p0, p1, p2, p3, p4, p5 :i,s,x,y,z:Array,max)=
//目标函数定义
{
s=0,i=0,(i<max).while{
Array.XSLSF::getra[i*3, &x, &y, &z],
s=s+[
p0*(1-exp(-p1*(x-p2)))+p3*x^p4+p5*x*y-z]^2,
i++
},
sqrt[s/max]
};
main(:d,k, p0, p1, p2, p3, p4, p5 :Array,max)=
{
max=10,
Array=new{rtoi(real_s),rtoi(max),rtoi(3)}.io::arrayns{
"2 101 172
3 14 210
4 136 241
5 52 265
6 67 280
7 81 289
8 54 294
9 20 302
10 6 299
11 2 306"
},
k=10,p0=1,p1=1, p2=1, p3=1, p4=1, p5=1,
d=GOpt[HFor("f"),optmax,1000, optcontract,0.9, optbuf,&k :
&p0, &p1, &p2, &p3, &p4, &p5],
printff{"\r\np0={1,r}, p1={2,r}, p2={3,r}, p3={4,r},
p4={5,r}, p5={6,r}, k={7,i}, f={8,r}\r\n", p0, p1, p2, p3, p4, p5,k,d},
delete[Array]
};
3.1.3 拟合公式:y=a*(x-d)^4+b*(x-d)^2+c;
x y
-0.08 20.26008
-0.065 19.72613
-0.05 19.501619
-0.03 18.72662
-0.015 18.58769
0.015 18.592199
0.03 18.88372
0.05 19.5453
0.065 19.88743
0.08 20.9914
0 18.12336
Forcal代码:
!using["fcopt"];
f(a, b, c, d :i,s,x,y:Array,max)= //目标函数定义
{
s=0,i=0,(i<max).while{
Array.XSLSF::getra[i*2, &x, &y],
s=s+[ a*(x-d)^4+b*(x-d)^2+c-y]^2,
i++
},
sqrt[s/max]
};
main(:f, a, b, c, d :Array,max)=
{
max=11,
Array=new{rtoi(real_s),rtoi(max),rtoi(2)}.io::arrayns{
"-0.08 20.26008
-0.065 19.72613
-0.05 19.501619
-0.03 18.72662
-0.015 18.58769
0.015 18.592199
0.03 18.88372
0.05 19.5453
0.065 19.88743
0.08 20.9914
0
18.12336"
},
a=1,b=1, c=1, d=1,
f=GOpt[HFor("f") : &a, &b, &c, &d],
printff{"\r\na={1,r}, b={2,r}, c={3,r}, d={4,r},
f={5,r}\r\n", a, b, c, d, f},
delete[Array]
};
3.1.4 求k的全局最小值:
约束条件:
10*q2^2*q3^3+10*q2^3*q3^2+200*q2^2*q3^2+100*q2^3*q3+
100*q2*q3^3+q1*q2*q3^2+q1*q2^2*q3+1000*q2*q3^2+
8*q1*q3^3+1000*q2^2*q3+8*q1*q2^2+6*q1*q2*q3-
q1^2+60*q1*q3+60*q1*q2-200*q1<=0;
q1>=800*(1-k);
q1<=800*(1+k);
q2>=2*(2-k);
q2<=2*(2+k);
q3>=3*(2-k);
q3<=3*(2+k);
Forcal代码:
!using["fcopt"];
s(k,q1,q2,q3)= //约束条件定义
{
if{ 10*q2^2*q3^3+10*q2^3*q3^2+200*q2^2*q3^2+100*q2^3*q3+
100*q2*q3^3+q1*q2*q3^2+q1*q2^2*q3+1000*q2*q3^2+
8*q1*q3^2+1000*q2^2*q3+8*q1*q2^2+6*q1*q2*q3-
q1^2+60*q1*q3+60*q1*q2-200*q1<=0 &
q1>=800*(1-k) &
q1<=800*(1+k) &
q2>=2*(2-k) &
q2<=2*(2+k) &
q3>=3*(2-k) &
q3<=3*(2+k),
return(1)
},
0
};
f(k,q1,q2,q3)=k; //目标函数定义
main(:d,i,k,q1,q2,q3)=
{
i=1000,k=1, q1=1, q2=1, q3=1,
d=ROptIni[HFor("f"),HFor("s"),optmax,10000 : &k,-1e10,1e10,
&q1,-1e10,1e10, &q2,-1e10,1e10, &q3,-1e10,1e10],
d=ROneOpt[HFor("f"),HFor("s"),optmax,50000,optbuf,&i,
optexpand,2, optcontract,0.7 : &k,-1e10,1e10, &q1,-1e10,1e10,
&q2,-1e10,1e10, &q3,-1e10,1e10],
printff{"\r\nk={1,r}, q1={2,r}, q2={3,r}, q3={4,r}, k={5,i},
f={6,r}\r\n",k,q1,q2,q3,i,d}
};
3.1.5 求k的全局最小值:
约束条件:
q3+9.625*q1*w+16*q2*w+16*w^2+12-4*q1-q2-78*w=0;
16*q1*w+44-19*q1-8*q2-q3-24*w=0;
2.25-0.25k<=q1<=2.25+0.25*q1;
1.5-0.5*k<=q2<=1.5+0.5*k;
1.5-1.5*k<=q3<=1.5+1.5*k;
Forcal代码:
!using["fcopt"];
s(k,q1,q2,q3,w)= //约束条件定义
{
if{ 2.25-0.25*k<=q1 &
q1<=2.25+0.25*q1 &
1.5-0.5*k<=q2 &
q2<=1.5+0.5*k &
1.5-1.5*k<=q3 &
q3<=1.5+1.5*k,
return(1)
},
0
};
f(k,q1,q2,q3,w)= //目标函数定义
{
k+[q3+9.625*q1*w+16*q2*w+16*w^2+12-4*q1-q2-78*w]^2+[16*q1*w+44-19*q1-8*q2-q3-24*w]^2
};
main(:d,i,k,q1,q2,q3,w)=
{
i=1000,k=1, q1=1, q2=1, q3=1, w=1,
d=ROptIni[HFor("f"),HFor("s"),optmax,10000 : &k,-1e10,1e10,
&q1,-1e10,1e10, &q2,-1e10,1e10, &q3,-1e10,1e10, &w,-1e10,1e10],
d=ROneOpt[HFor("f"),HFor("s"),optmax,2000, optbuf,&i,
optexpand,2, optcontract,0.5, optmode,0, optfast,1 : &k,-1e10,1e10,
&q1,-1e10,1e10, &q2,-1e10,1e10, &q3,-1e10,1e10, &w,-1e10,1e10],
printff{"\r\nk={1,r}, q1={2,r}, q2={3,r}, q3={4,r}, w={5,r},
i={6,i}, f={7,r}\r\n",k,q1,q2,q3,w,i,d},
f(k,q1,q2,q3,w)
};
3.2 非线性拟合测试题
参考:http://www.7d-soft.com/Regression_Test.htm
非线性拟合测试题 NIST的测试题对于其它拟合软件,可当作验证标准,但对于1stOpt,实在过于简单,缺乏挑战性。下面我们给出九道测试题及由1stOpt计算出的最优解(RMSE:均方差; R^2:相关系数之平方),每道题有且只有唯一的最优解。有兴趣的用户可尝试任何其它相关软件工具,看能否得出与我们相同或更优的结果。 当用1stOpt求解时,优化算法均选用麦夸特(LM) + 通用全局优化算法(UGO)。有些试题难度较大,在优化参数设定时可考虑增加”重复数“,比如从缺省的30变为50
测试题1数据
|
第1题:尚未获得正解
第2题:尚未获得正解
第3题:比较简单
!using["fcopt"];
g(x,y,p1,p2,p3)={p1/(1+p2/x+x/p3)-y}^2;
f(p1,p2,p3)= //函数定义
{
sqrt{[g(80.0 , 6.64 ,p1,p2,p3)+
g(140.9 , 11.54 ,p1,p2,p3)+
g(204.7 , 15.89 ,p1,p2,p3)+
g(277.9 , 20.16 ,p1,p2,p3)+
g(356.8 , 21.56 ,p1,p2,p3)+
g(453.0 , 21.69 ,p1,p2,p3)+
g(505.6 , 22.66 ,p1,p2,p3)+
g(674.5 , 23.15 ,p1,p2,p3)+
g(802.32 , 18.16 ,p1,p2,p3)+
g(936.04 , 16.81 ,p1,p2,p3)]/10}
};
main(:k,x,y,z,d)=
{
k=20,x=1,y=1 ,z=1,
d=GOpt[HFor("f"), optcontract,0.7, optbuf,&k,optmode,1,
optstep,1.1 : &x, &y, &z],
printff{"\r\nk={1,i}, x={2,r}, y={3,r}, z={4,r}, ppp={5,r}\r\n",k,x,
y,z,d}
};
第4题:约6分钟求得最优解
!using["fcopt"];
f(a0, a1, a2, a3, a4,b1,b2,b3,b4:i,s,x1,x2,x3,x4,y:Array,max)= //目标函数定义
{
s=0,i=0,(i<max).while{
Array.XSLSF::getra[i*5, &x1, &x2,
&x3, &x4,&y],
s=s+[(a0+a1*x1+a2*x2+a3*x3+a4*x4)/(1+b1*x1+b2*x2+b3*x3+b4*x4)-y]^2,
i++
},
sqrt[s/max]
};
main(:d,k, a0, a1, a2, a3, a4,b1,b2,b3,b4:Array,max)=
{
max=23,
Array=new{rtoi(real_s),rtoi(max),rtoi(5),rtoi(EndType),
14 , 1.38 , -34, 16, 582 ,
10, 0.52 , -29, 2 , 458 ,
13 , 1.70 , -32 , 13 , 559 ,
24 , 0.80 , 24 , 1 , 322 ,
12 , 1.83 , 41 , 11, 399 ,
6 , 1.77 , -50 , 7 , 523 ,
18, 1.23 , 27 , 4 , 322 ,
-10, 0.28, -8, 6 , 358 ,
0 , 1.20 , 66 , 6 , 354 ,
14 , 1.75, -60 , 6 , 574 ,
12 , 1.78 , -70 , 7 , 489 ,
-18, 1.37, -15 , 0 , 232 ,
16, 1.38, 0 , 4 , 440 ,
-4, 0.29, -9 , -7, 421 ,
-23, 1.12, -12, -14, 181 ,
5 , 1.52, 0 , 10 , 426 ,
-16, 0.63, 34 , 1 , 364 ,
-1 , 1.32 , 22 , -7 , 375 ,
-18, 1.18, 4 , -11, 224 ,
8, 1.50 , -11 , 5 , 514 ,
-8 , 1.43, 4 , -12, 381 ,
-11, 0.74, 10 , 0 , 275 ,
-19, 1.07, -5, 0 , 426
},
k=10,a0=1, a1=1, a2=1, a3=1, a4=1, b1=1, b2=1, b3=1, b4=1,
d=GOpt[HFor("f"),optmax,1000, optfast,0.7,
optcontract,0.9, optbuf,&k, optmode,1, optstep,1.1 : &a0, &a1, &a2, &a3, &a4,
&b1, &b2, &b3, &b4],
printff{"\r\na0={1,r}, a1={2,r}, a2={3,r}, a3={4,r},
a4={5,r}, b1={6,r}, b2={7,r}, b3={8,r}, b4={9,r}, k={10,i}, f={11,r}\r\n", a0,
a1, a2, a3, a4,b1,b2,b3,b4,k,d},
delete[Array]
};
第5题:尚未获得正解
第6题:约1分钟求得最优解
!using["fcopt"];
f(a0, a1, a2, a3, k1,k2,k3 :i,s,x,y:Array,max)=
//目标函数定义
{
s=0,i=0,(i<max).while{
Array.XSLSF::getra[i*2, &x, &y],
s=s+[
a0+a1*x^k1+a2*x^k2+a3*x^k3-y]^2,
i++
},
sqrt[s/max]
};
main(:d,k, a0, a1, a2, a3, k1,k2,k3:Array,max)=
{
max=10,
Array=new{rtoi(real_s),rtoi(max),rtoi(2),rtoi(EndType),
1.0, 8.2,
2.0, 4.6,
3.0, 4.3,
4.0, 4.6,
5.0, 5.1,
6.0, 5.5,
7.0, 5.7,
8.0, 5.5,
9.0, 5.0,
10.0,3.8
},
k=20,a0=-1e-5, a1=-1e-5, a2=-1e-5, a3=-1e-5, k1=-1e-5,
k2=-1e-5, k3=-1e-5,
d=GOpt[HFor("f"),optmax,2000, optcontract,0.9, optbuf,&k,
optmode,1, optstep,1.1, optdebug,0: &a0, &a1, &a2, &a3, &k1, &k2, &k3],
printff{"\r\na0={1,r}, a1={2,r}, a2={3,r}, a3={4,r},
k1={5,r}, k2={6,r}, k3={7,r}, k={8,i}, f={9,r}\r\n", a0, a1, a2, a3,
k1,k2,k3,k,d},
delete[Array]
};
第7题:尚未获得正解
第8题:约1分钟求得最优解
!using["fcopt"];
f(p1, p2, p3, p4, p5,p6:i,s,x1,x2,x3,y:Array,max)=
//目标函数定义
{
s=0,i=0,(i<max).while{
Array.XSLSF::getra[i*4, &x1, &x2,
&x3, &y],
s=s+[
p1/((p2+x1)*(1+p3*x2)*(x3-p4)^2)+p5*x3^p6-y]^2,
i++
},
sqrt[s/max]
};
main(:d,k, p1, p2, p3, p4, p5,p6:Array,max)=
{
max=27,
Array=new{rtoi(real_s),rtoi(max),rtoi(4),rtoi(EndType),
34.9, 0.043378, 8, 0.996556 ,
34.9, 0.216888, 8, 0.985708 ,
34.9, 0.433776, 8, 0.973826 ,
58.2, 0.026027, 8, 0.999409 ,
58.2, 0.130133, 8, 0.99817 ,
58.2, 0.260265, 8, 1.000176 ,
93.1, 0.016267, 8 , 0.995131 ,
93.1, 0.081333, 8, 1.009887 ,
93.1, 0.162666, 8, 1.008251 ,
34.9, 0.043378, 20, 0.835576 ,
34.9, 0.216888, 20, 0.777734 ,
34.9, 0.433776, 20, 0.715483 ,
58.2, 0.026027, 20, 0.854949 ,
58.2, 0.130133, 20, 0.822743 ,
58.2, 0.260265, 20, 0.784273 ,
93.1, 0.016267, 20, 0.85902 ,
93.1, 0.081333, 20, 0.841512 ,
93.1, 0.162666, 20, 0.81895 ,
34.9, 0.043378, 40, 0.387322 ,
34.9, 0.216888, 40, 0.338941 ,
34.9, 0.433776, 40, 0.293558 ,
58.2, 0.026027, 40, 0.342388 ,
58.2, 0.130133, 40, 0.311761 ,
58.2, 0.260265, 40, 0.280112 ,
93.1, 0.016267, 40, 0.308071 ,
93.1, 0.081333 , 40, 0.287257 ,
93.1, 0.162666, 40, 0.264443
},
k=20, p1=1, p2=1, p3=1, p4=1, p5=1, p6=1,
d=GOpt[HFor("f"),optmax,2000, optcontract,0.9, optbuf,&k,
optmode,1, optstep,1.1, optdebug,0: &p1, &p2, &p3, &p4, &p5, &p6],
//也可以使用以下语句获得正解,速度更快
//d=OneOpt[HFor("f"),optmax,2000, optcontract,0.9, optbuf,&k,
optexpand,10, optmode,1: &p1, &p2, &p3, &p4, &p5, &p6],
printff{"\r\np1={1,r},
p2={2,r}, p3={3,r}, p4={4,r}, p5={5,r}, p6={6,r}, k={7,i}, f={8,r}\r\n", p1, p2,
p3, p4, p5,p6 ,k,d}
};
第9题:比较简单
!using["fcopt"];
y(x,a,b,c,d)=a*exp(b*abs(x+c)^d);
f(a,b,c,d)= //目标函数定义
{
sqrt{{[y(27.25 ,a,b,c,d)-1]^2
+[y(27.75 ,a,b,c,d)-3]^2
+[y(28.25 ,a,b,c,d)-6]^2
+[y(28.75 ,a,b,c,d)-13]^2
+[y(29.25 ,a,b,c,d)-18]^2
+[y(29.75 ,a,b,c,d)-19]^2
+[y(30.25 ,a,b,c,d)-17]^2
+[y(30.75 ,a,b,c,d)-16]^2
+[y(31.25 ,a,b,c,d)-6]^2
+[y(31.75 ,a,b,c,d)-5]^2
+[y(32.25 ,a,b,c,d)-2]^2}/11}
};
main(:f,k,a,b,c,d)=
{
k=10,a=1,b=1,c=1,d=1,
f=GOpt[HFor("f"),
optmax,2000, optbuf,&k, optmode,1 : &a, &b, &c, &d],
printff{"\r\na={1,r}, b={2,r}, c={3,r}, d={4,r}, k={5,i},
f={6,r}\r\n",a,b,c,d,k,f}
};
版权所有© Forcal程序设计件
2002-2010,保留所有权利
E-mail: forcal@sina.com
QQ:630715621
最近更新:
2010年06月09日