FORCAL参数优化动态库FcOpt

欢迎访问 Forcal程序设计

FORCAL参数优化动态库FcOpt V1.0

1 什么是FcOpt

2 Forcal参数优化函数

fcopt::Opt求无约束条件下的n维极小值优化能力一般，速度快。fcopt::ROpt求约束条件下的n维极小值优化能力一般，速度快。fcopt::GOpt求无约束条件下的n维极小值优化能力强，速度慢。fcopt::RGOpt求约束条件下的n维极小值优化能力一般，速度慢。fcopt::ROptIni求满足约束条件的一组值　fcopt::OneOpt求无约束条件下的n维极小值优化能力强，速度较快。fcopt::ROneOpt求约束条件下的n维极小值优化能力一般，速度较快。fcopt::OptPassword获取机器码，免费注册后使用FcOpt的全部功能　3 优化实例3.1 较难的例子选自网上的难题例子　3.2 非线性拟合测试题选自1stOpt的九道测试题　　　　

1 什么是FcOpt [返回页首]

FcOpt32W.dll是一个Forcal参数优化动态库，主要包含一些参数优化函数。

在FcSystem中的函数是通过二级函数命名空间“fcopt”输出的，所有函数均具有类似“fcopt::Opt(...)”的格式。使用!using("fcopt");可简化FcOpt中的函数访问。

FcOpt32W.dll需要FcData32W.dll的支持，FcData32W.dll要先于FcOpt32W.dll加载。

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)的值，由用户自编。格式如下：

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)²+(1-x0)²

程序如下：

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)的值，由用户自编。格式如下：

r：自定义n元函数句柄，必须由二级函数HFor获得该句柄，用于计算约束条件r(x1,x2,...,xn)的值（返回非0值表示满足约束条件，若不满足约束条件，应返回0），由用户自编。格式如下：

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)²]*x1³/[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)的值，由用户自编。格式如下：

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)的值，由用户自编。格式如下：

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)的值，由用户自编。格式如下：

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::optmaxmax,maxmax : &x1, &x2, ... ... , &xn)：求无约束条件下的n维极小值

f：自定义n元函数句柄，必须由二级函数HFor获得该句柄，用于计算目标函数f(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::optmaxmax,maxmax：代表搜索精度的极大值，maxmax>=3。可以缺省该参数，缺省值为1e10。通常不需要修改该参数。当优化参数多于10个时，通常需要修改该参数为更大的值。
&x1, &x2, ... ... , &xn：参数初值，返回最优参数值。要求初始参数有意义。

返回值：目标函数终值（极小值）。

说明1：fcopt::optmax、fcopt::optbuf、fcopt::opteps、fcopt::optmode等标识参数类型，次序是任意的，可缺省。

说明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::optmaxmax,maxmax : &x1,x1min,x1max, &x2,x2min,x2max, ... ... , &xn,xnmin,xnmax)：求约束条件下的n维极小值

f：自定义n元函数句柄，必须由二级函数HFor获得该句柄，用于计算目标函数f(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::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：该函数搜索全局最小值。初值对搜索结果有重要影响，应变换初值的符号和大小进行搜索，以最小者为最优。

例子：求全局最小值：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,100000, optbuf,&k, optexpand,2, optcontract,0.9 : &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}
};

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+abs[1-s(k,q1,q2,q3)]*100000
};

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, optcontract,0.7, optexpand,2 , optsame,1 : &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.2 非线性拟合测试题

参考：http://www.7d-soft.com/Regression_Test.htm

非线性拟合测试题

NIST的测试题对于其它拟合软件，可当作验证标准，但对于1stOpt，实在过于简单，缺乏挑战性。下面我们给出九道测试题及由1stOpt计算出的最优解（RMSE：均方差； R^2：相关系数之平方），每道题有且只有唯一的最优解。有兴趣的用户可尝试任何其它相关软件工具，看能否得出与我们相同或更优的结果。

当用1stOpt求解时，优化算法均选用麦夸特(LM) + 通用全局优化算法(UGO）。有些试题难度较大，在优化参数设定时可考虑增加”重复数“，比如从缺省的30变为50

测试题编号拟合模型公式变量名/变量数参数均方差 RMSE相关系数 R^21

y=1/(p1+p2*X^p3)+p4*x^p5

x, yp1 to p5

104.376667

0.996780042

y = (p1+p2*x1+p3*x2+p4*x3+p5*x4)/(1+a1*x1+a2*x2+a3*x3+a4*x4)

x1 to x4, yp1 to p5, a1 to a4

0.3028129

0.93464223

y = p1/(1+p2/x+x/p3)

x, yp1 to p3

0.8767278

0.9699295624y = (a0+a1*x1+a2*x2+a3*x3+a4*x4)/(1+b1*x1+b2*x2+b3*x3+b4*x4)x1 to x4, ya0 to a4, b1 to b4

48.05714

0.805142865z = p1+p2*x^p3+p4*y^p5+p6*x^p7*y^p8x, y, zp1 to p80.27032960.9946328486y = a0+a1*x^k1+a2*x^k2+a3*x^k3x, ya0 to a3, k1 to k30.02147261360.9996442617z = (p1+p2*x+p3*y+p4*x*y)/(1+p5*x+p6*y+p7*x*y)x, y, zp1 to p71.006260780.97154718y=p1/((p2+x1)*(1+p3*x2)*(x3-p4)^2)+p5*x3^p6x, yp1 to p60.019776980.9953729y=a*exp(b*abs(x+c)^d)x, ya, b, c, d1.15469090.9704752

测试题1数据

No x y

1 160.73 6266.7

2 159.82 6151.9

3 158.84 6035.1

4 157.86 5920.9

5 156.87 5812.6

6 155.88 5702.2

7 154.89 5594.9

8 153.96 5491.3

9 152.97 5385

10 151.98 5282.2

11 150.99 5181.3

12 150.06 5084.8

13 149.08 4988.8

14 148.09 4892.2

15 147.1 4796.9

16 146.17 4701

17 145.18 4608

18 144.2 4515.2

19 143.2 4429.6

20 142.21 4342.9

21 141.25 4255.6

22 140.2 4167.1

23 139.14 4077.6

24 138.05 3987.9

25 136.96 3898.9

26 135.94 3808.5

27 134.84 3717.7

28 133.74 3628.9

29 132.65 3543

30 131.57 3456.3

31 130.55 3372.5

32 129.47 3292.8

33 128.4 3212.7

34 127.33 3133.6

35 126.34 3056.6

36 125.29 2985.5

37 124.26 2912.5

38 123.23 2842.9

39 122.21 2774.1

40 121.21 2708.3

41 120.27 2642.1

42 119.27 2580.2

43 118.29 2518.7

44 117.32 2459.1

45 116.42 2401.1

46 115.48 2344.3

47 114.55 2290.9

48 113.62 2237.5

49 112.7 2189

50 111.85 2138.8

51 110.94 2089.4

52 110.03 2042.4

53 109.13 1998.1

54 108.28 1953.6

55 107.38 1906.6

56 106.48 1867.8

57 105.6 1824.5

58 104.72 1784.3

59 103.91 1745

60 103.05 1704.5

61 102.2 1668.7

62 101.35 1629

63 100.51 1590.4

64 99.739 1552.5

65 98.913 1514.7

66 98.103 1476.4

67 97.308 1444.3

68 96.513 1411.4

69 95.78 1378.5

70 95.002 1344.8

71 94.239 1307.8

72 93.482 1276.1

73 92.776 1243.5

74 92.039 1212.9

75 91.314 1178.7

76 90.604 1148.4

77 89.942 1115.9

78 89.244 1084.5

79 88.559 1051.5

80 87.889 1029.7

81 87.226 996.16

82 86.569 965.86

83 85.963 937.72

84 85.323 907.87

85 84.694 877.58

86 84.081 838.17

87 83.473 819.48

88 82.876 797.76

89 82.287 768.54

90 81.811 749.96

91 81.178 724.39

92 80.614 697.24

93 80.118 674.67

94 79.574 649.49

95 79.011 629.83

96 78.478 614.6

97 78.012 591.87

98 77.494 573.43

99 76.927 558.94

100 76.512 539.45

101 75.962 526.99

102 75.472 514.14

103 75.014 504.11

104 74.566 484.4

105 74.123 473.23

106 73.608 468.93

107 73.183 453.77

108 72.774 448.58

109 72.369 447.73

110 71.897 431.79

111 71.503 432.45

112 71.116 432.15

113 70.741 420.71

114 70.3 427.26

115 69.935 419.76

116 69.572 407.28

117 69.148 408.04

118 68.796 393.71

119 68.448 403.74

120 68.114 408.8

121 67.717 401.26

122 67.374 400.81

123 67.037 401.89

124 66.741 408.68

125 66.416 398.49

126 66.015 414.14

127 65.373 419.78

128 64.769 426.82

129 64.109 418.42

130 63.44 446.32

131 62.772 451.55

132 62.111 473.27

133 61.508 499.69

134 60.908 523.66

135 60.219 551.47

136 59.699 593.53

137 59.119 608.69

138 58.547 658.08

139 57.992 712.27

140 57.483 769.4

141 56.969 826.48

142 56.472 896.05

143 55.989 957.57

144 55.513 1065.1

145 55.088 1114.1

146 54.651 1195

147 54.237 1271.5

148 53.836 1355.6

149 53.318 1483.2

150 52.701 1690

151 52.08 2245.9

152 51.431 2470.4

153 50.877 2719.1

154 50.298 2957.5

155 49.74 3155.2

156 49.2 3279.4

157 48.702 3546.4

158 48.182 3741

159 47.681 4021

160 47.213 4015.1

161 46.768 4304.7

162 46.368 4127.9

163 45.956 4530.9

164 45.55 4802.9

165 45.157 5047.4

166 44.799 4804.3

167 44.43 5164.1

168 44.078 4781

169 43.727 5175.5

170 43.384 5708.6

171 43.079 5679.6

172 42.899 5161.8

173 42.719 5399.1

174 42.547 5483

175 42.253 4839.4

176 41.962 5360.7

177 41.691 5622

178 40.602 5772.3

测试题2数据

测试题3数据

测试题4数据

测试题5数据

No x1 x2 x3 x4 y

No x y

No x1 x2 x3 x4 y

No. x y z

1 15100 29000 508.0 180 3.40

2 20500 43350 453.7 141 3.00

3 80000 92610 487.9 132 2.70

4 91500 142775 572.3 182 3.37

5 82500 2123160 455.7 113 6.89

6 20000 227800 481.3 170 5.03

7 17800 140000 541.3 179 3.55

8 3900 15980 538.6 186 2.72

9 17300 223200 460.6 100 4.05

10 25700 229400 393.1 133 3.22

11 49400 424500 373.9 106 2.65

12 40700 561700 482.8 107 1.91

13 77000 563600 482.1 140 3.00

14 92900 557600 415.1 121 1.31

15 63300 528300 536.7 144 2.33

16 51600 488940 385.1 154 3.55

17 60000 480500 412.2 111 3.37

18 70000 530500 567.2 139 2.55

1 80.0 6.64

2 140.9 11.54

3 204.7 15.89

4 277.9 20.16

5 356.8 21.56

6 453.0 21.69

7 505.6 22.66

8 674.5 23.15

9 802.32 18.16

10 936.04 16.81

1 14 1.38 -34 16 582

2 10 0.52 -29 2 458

3 13 1.70 -32 13 559

4 24 0.80 24 1 322

5 12 1.83 41 11 399

6 6 1.77 -50 7 523

7 18 1.23 27 4 322

8 -10 0.28 -8 6 358

9 0 1.20 66 6 354

10 14 1.75 -60 6 574

11 12 1.78 -70 7 489

12 -18 1.37 -15 0 232

13 16 1.38 0 4 440

14 -4 0.29 -9 -7 421

15 -23 1.12 -12 -14 181

16 5 1.52 0 10 426

17 -16 0.63 34 1 364

18 -1 1.32 22 -7 375

19 -18 1.18 4 -11 224

20 8 1.50 -11 5 514

21 -8 1.43 4 -12 381

22 -11 0.74 10 0 275

23 -19 1.07 -5 0 426

1 500 25 1.5

2 500 50 2.25

3 500 100 3.15

4 500 200 4.0

5 500 300 4.2

6 500 400 4.3

7 1000 25 1.45

8 1000 50 2.35

9 1000 100 3.95

10 1000 200 6.95

11 1000 300 8.15

12 1000 400 8.4

13 1500 25 1.45

14 1500 50 2.45

15 1500 100 4.15

16 1500 200 7.45

17 1500 300 10.65

18 1500 400 11.85

19 2000 25 1.45

20 2000 50 2.5

21 2000 100 4.2

22 2000 200 7.75

23 2000 300 11.45

24 2000 400 14.3

测试题6数据

测试题7数据

测试题8数据

测试题9数据

No x y

No x y z

No x1 x2 x3 y

No x y

1 1.0 8.2

2 2.0 4.6

3 3.0 4.3

4 4.0 4.6

5 5.0 5.1

6 6.0 5.5

7 7.0 5.7

8 8.0 5.5

9 9.0 5.0

10 10.0 3.8

1 4332 26.94 43.70

2 4697 23.64 44.50

3 5062 25.19 47.70

4 5428 28.60 52.30

5 5793 28.74 54.21

6 6158 29.33 55.58

7 6523 32.92 55.70

8 6889 31.87 57.70

9 7254 33.07 58.60

10 7619 29.36 60.24

11 7984 27.96 59.13

12 8350 30.18 57.00

13 8715 37.84 57.30

14 9080 38.86 59.00

15 9445 35.18 60.20

16 9811 28.81 61.80

17 10176 34.57 63.17

18 10541 37.49 66.23

19 10906 29.30 61.80

20 11272 32.47 62.03

21 11637 38.24 65.30

1 34.9 0.043378 8 0.996556

2 34.9 0.216888 8 0.985708

3 34.9 0.433776 8 0.973826

4 58.2 0.026027 8 0.999409

5 58.2 0.130133 8 0.99817

6 58.2 0.260265 8 1.000176

7 93.1 0.016267 8 0.995131

8 93.1 0.081333 8 1.009887

9 93.1 0.162666 8 1.008251

10 34.9 0.043378 20 0.835576

11 34.9 0.216888 20 0.777734

12 34.9 0.433776 20 0.715483

13 58.2 0.026027 20 0.854949

14 58.2 0.130133 20 0.822743

15 58.2 0.260265 20 0.784273

16 93.1 0.016267 20 0.85902

17 93.1 0.081333 20 0.841512

18 93.1 0.162666 20 0.81895

19 34.9 0.043378 40 0.387322

20 34.9 0.216888 40 0.338941

21 34.9 0.433776 40 0.293558

22 58.2 0.026027 40 0.342388

23 58.2 0.130133 40 0.311761

24 58.2 0.260265 40 0.280112

25 93.1 0.016267 40 0.308071

26 93.1 0.081333 40 0.287257

27 93.1 0.162666 40 0.264443

1 27.25 1

2 27.75 3

3 28.25 6

4 28.75 13

5 29.25 18

6 29.75 19

7 30.25 17

8 30.75 16

9 31.25 6

10 31.75 5

11 32.25 2

第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}
};