Lu参数优化动态库LuOpt V1.0
目 录
1 什么是LuOpt |
||
2 Lu优化函数 |
||
luopt::Opt | 求无约束或约束条件下的n维极小值 | 无约束优化能力极强,约束优化能力弱,速度快。随机生成初值,全局优化,解不稳定。 |
3 优化实例 | ||
3.1 较难的例子 | 选自网上的难题例子 | |
3.2 非线性拟合测试题 | 选自1stOpt的九道测试题 | |
3.3 微分方程参数优化(拟合) | 选自网上实例 | |
3.4 求解NIST非线性测试题 | NIST 27 道非线性拟合测试题 | |
4 求方程(组)的全部解 | ||
luopt::iFind | 求单变量方程(隐函数)的全部解 | 求解能力强,解是稳定的。 |
luopt::Find | 求方程组的全部解 | 求解能力强,解不稳定。 |
5 注册 | ||
luopt::OptPassword | 获取机器码,免费注册后使用LuOpt的全部功能 | 已取消免费注册,可直接使用LuOpt的全部功能。 |
LuOpt32.dll是一个Lu参数优化动态库,主要包含一些参数优化函数和解方程函数。
在LuOpt中的函数是通过二级函数命名空间“luopt”输出的,所有函数均具有类似“luopt::Opt(...)”的格式。使用!!!using("luopt");可简化LuOpt中的函数访问。
免费注册说明:为了演示设计商业性Lu扩展动态库的可行性,LuOpt设计成须注册后使用其全部功能。如果没有注册,当优化参数多于2个时,Opt函数仅返回最小值,不能返回优化参数。目前免费注册,用函数luopt::OptPassword获取机器码后,通过E-mail发送到forcal@sina.com获取注册码 (已取消免费注册,可直接使用LuOpt的全部功能)。
函数OptPassword的格式(返回值及参数pw1,pw1,... ...,pwn将返回多个机器码):luopt::OptPassword(&pw1,&pw1,... ...,&pwn)
函数OptPassword的用法1:luopt::OptPassword();
函数OptPassword的用法2:(:pw)=luopt::OptPassword(&pw),pw;
函数OptPassword的用法3:(:pw)=luopt::OptPassword(0,&pw),pw;
获取注册码后,在加载LuOpt32.dll时提供注册码即可。以OpenLu为例,打开工作区文件,修改以下部分(注册码在冒号后):"dll\LuOpt32.dll:604508320"
[返回页首] luopt::Opt(f, luopt::optconfun,r, luopt::optrange,x1min,x1max,x2min,x2max,...,xnmin,xnmax, luopt::optautorange,autorange, luopt::optmin0,min0, luopt::optmax,max, luopt::optbuf,&buf, luopt::optmode,mode, luopt::optdeep,deep, luopt::optfast,fast, luopt::optwaynull, luopt::optwaysim, luopt::optwaysimdeep, luopt::optwayconfra, luopt::opteps,eps, luopt::optsameeps,sameeps, luopt::optsameabs,sameabs, luopt::optout,out, luopt::optnum,num, luopt::optarray,a, luopt::optarraybegin,&k, luopt::optarraystarter,arraystarter, luopt::optexpand,expand, luopt::optcontract,contract, luopt::optstarter,&x1, &x2, ... ... , &xn, &min):求无约束或约束条件下的n维极小值
f:自定义n元函数句柄,用于计算目标函数f(x1,x2,...,xn)的值,不可缺省。该函数由用户自编,格式如下:
f(x1,x2,...,xn)=
{
g(x1,x2,...,xn)
};
luopt::optconfun,r:自定义n元函数句柄,用于计算约束条件r(x1,x2,...,xn)的值(返回非0值表示满足约束条件,若不满足约束条件,应返回0、false或nil),可缺省该参数。该函数由用户自编,格式如下:
r(x1,x2,...,xn)=
{
g(x1,x2,...,xn)
};
luopt::optrange,x1min,x1max,x2min,x2max,...,xnmin,xnmax:指定搜索区间。若缺省该参数,则所有变量区间均为[-1e20~1e20]。
luopt::optautorange,autorange:autorange!=0时将在指定搜索区间内自动调节合适的搜索区间,否则不进行调节。默认是自动调节搜索区间的。
luopt::optmin0,min0:解的可能的极小值。可以缺省该参数,缺省值为±1e-20。
luopt::optmax,max:max>=10,控制搜索精度,max越大精度越高,但时间越长。可以缺省该参数,缺省值为100。
luopt::optbuf,buf:buf>=1,控制缓冲区大小,缓冲区并非越大越好。可以缺省该参数,缺省值为5。
luopt::optmode,mode:mode>=0,控制工作模式。mode越大准确度越大。可以缺省该参数,缺省值为16。
luopt::optdeep,deep:deep>=0,控制搜索深度。deep越大准确度越大。可以缺省该参数,缺省值为20。
luopt::optfast,fast:fast!=0,进行快速搜索。可以缺省该参数,缺省值为fast=0。
luopt::optwaynull:清除所有局部搜索方法。
luopt::optwaysim:使用单形调优法局部搜索,这是默认的局部搜索方法。
luopt::optwaysimdeep:使用单形调优法局部深度搜索。
luopt::optwayconfra:使用连分式局部搜索方法。
luopt::opteps,eps:控制精度要求,eps>0。可以缺省该参数,缺省值为1e-6。
luopt::optsameeps,sameeps:相对比较两组值是否相等的极小值。sameeps>0。可以缺省该参数,缺省值为1e-2。
luopt::optsameabs,sameabs:绝对比较两组值是否相等的极小值。sameeps>=0。可以缺省该参数,缺省值为1e-3。
luopt::optout,out:是否输出结果。out非0时输出。可以缺省该参数,默认输出结果。
luopt::optnum,num:设置最多输出的极小值的个数。可以缺省该参数,默认输出1个极小值。
luopt::optarray,a:提供一个数组,用于接受结果。一组结果包括所有的自变量参数及极小值。默认从数组开始存放数据,也可用参数optarraybegin指定开始存放数据的位置。可以缺省该参数。
luopt::optarraybegin,&k:指定数组中开始存放数据的位置,k返回下一个存放位置。可以缺省该参数,默认从地址0开始存放。
luopt::optarraystarter,arraystarter:arraystarter!=0将指定数组中包含一组初值。可以缺省该参数,缺省值为arraystarter=0。若同时指定了optstarter,optstarter中的初值被忽略。
luopt::optexpand,expand:扩张系数。一般取1.2~2.0。可以缺省该参数,缺省值为1.6。
luopt::optcontract,contract:收缩系数。一般取0~1。可以缺省该参数,缺省值为0.5。
luopt::optstarter,&x1, &x2, ... ... , &xn, &min:前n个参数提供一组初值(可为任意值),返回最优参数值
,最后一个参数返回极小值。可以缺省该参数。
返回值:极小值个数。
说明1:luopt::optmax、luopt::optbuf、luopt::opteps等标识参数类型,次序是任意的,可缺省。
说明2:该函数使用随机算法搜索全局最小值,故解是不稳定的,应多次搜索甚至变换参数搜索,以最小者为最优。
运行错误:
1:指定的表达式不存在;
2:常量表达式或者自变量不能重新赋值;
3:内存错误;
4:参数不匹配;
5:不可识别描述符;
6:参数不符合要求;
7:约束函数有错误:参数不匹配、自变量重新赋值或者函数不存在;
8:自定义函数返回了非法值。
例子1:计算下列目标函数的极小值点与极小值。
J=100*(x1-x0*x0)2+(1-x0)2
程序如下:
f(x0,x1)=100*(x1-x0*x0)^2+(1-x0)^2;
luopt::Opt[@f];
结果:
1. 1. 0.
例子2:求下列隐函数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]。
程序如下:
!!!using("luopt");
f(x,y,z)=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;
//构造目标函数,注意1e10
Opt[@f, optwaysimdeep, optwayconfra, optrange,-1.,7., -2.,2., -1e10,1e10];
结果(需多次运行):
2.898338314819993 -0.8573299220967106 -2.33540823984039e-002 -2.335408239796544e-002
例子3:求针状函数的全局最小值,并返回10个极小值:
f(r)=-sin(r)/r+1
其中:r=sqrt[(x-50)^2+(y-50)^2]+exp[1.0]。
程序如下:
!!!using("luopt");
f(x,y:t)= //目标函数定义
{
t=sqrt[(x-50)^2+(y-50)^2]+exp[1.0],
-sin[t]/t-1
};
Opt[@f, optwaysimdeep, optwayconfra, optnum,10];
结果(需多次运行):
50.
50.
-1.151117991593894
45.04713670154168 50.73409357987649 -1.128374553525899
47.95358156651113 54.56960337517742 -1.128374553259392
48.61084727988142 45.18968474411513 -1.128374553040821
51.53888994360668 55.27956633578699 -1.11373603845343
50.0914003285785 38.652456006392 -1.070913459450462
55.57756844733133 40.1173971653779 -1.070913459450462
47.78264700546625 38.87080820770154 -1.070913459436176
43.59630987066741 40.6315049957481 -1.070913459402211
46.75204544703252 39.12675998582707 -1.070913459306036
10.
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)
Lu代码:
!!!using["luopt","math"];
f(p1,p2,p3,p4,p5:i,s,x,y:Array,max)=
{
s=0,i=0,(i<max).while{
x=Array[i,0], y=Array[i,1],
s=s+[(p1)+(p2*exp(-p3*x/p5)+p4/(1+p4*p5*x))-y]^2,
i++
},
sqrt[s/max]
};
main(::Array,max)=
{
max=19,
Array=new[reals,max,2].SetArray{
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
},
Opt[@f, optwaysimdeep, optwayconfra, optdeep,50]
};
结果(需多次求解):
6.855486033798995 4.813449005068769 -54298054.6899329 -10.72898361613976 -1516.502649185066 3.337716353170544e-002
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
Lu代码:
!!!using["luopt","math"];
f(p0, p1, p2, p3, p4, p5 :i,s,x,y,z:Array,max)=
{
s=0,i=0,(i<max).while{
x=Array[i,0], y=Array[i,1], z=Array[i,2],
s=s+[
p0*(1-exp(-p1*(x-p2)))+p3*x^p4+p5*x*y-z]^2,
i++
},
sqrt[s/max]
};
main(::Array,max)=
{
max=10,
Array=new[real_s,max,3].SetArray{
"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"
},
Opt[@f, optwayconfra]
};
结果(需多次求解):
306.0849059154657 0.4607174830055115 0.9026291308250309 248.1563530146011 -2.274779410407842 -3.621982090081021e-003 1.506033828737254
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
Lu代码:
!!!using["luopt","math"];
f(a, b, c, d :i,s,x,y:Array,max)=
{
s=0,i=0,(i<max).while{
x=Array[i,0], y=Array[i,1],
s=s+[ a*(x-d)^4+b*(x-d)^2+c-y]^2,
i++
},
sqrt[s/max]
};
main(::Array,max)=
{
max=11,
Array=new[reals,max,2].SetArray{
"-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"
},
Opt[@f, optwaysimdeep, optwayconfra]
};
结果(需多次求解):
420.0265769742538 -170.7483372687845 35.81768548688493 -0.449622975242104 0.1543213604571683
3.2 非线性拟合测试题
参考:http://www.7d-soft.com/Regression_Test.htm
非线性拟合测试题 NIST的测试题对于其它拟合软件,可当作验证标准,但对于1stOpt,实在过于简单,缺乏挑战性。下面我们给出九道测试题及由1stOpt计算出的最优解(RMSE:均方差; R^2:相关系数之平方),每道题有且只有唯一的最优解。有兴趣的用户可尝试任何其它相关软件工具,看能否得出与我们相同或更优的结果。 当用1stOpt求解时,优化算法均选用麦夸特(LM) + 通用全局优化算法(UGO)。有些试题难度较大,在优化参数设定时可考虑增加”重复数“,比如从缺省的30变为50
测试题1数据
|
第1题:
!!!using["luopt","math"];
f(p1,p2,p3,p4,p5:i,s,x,y:Array,max)=
{
s=0,i=0,(i<max).while{
x=Array[i,0], y=Array[i,1],
s=s+[1/(p1+p2*x^p3)+p4*x^p5-y]^2,
i++
},
sqrt[s/max]
};
main(::Array,max)=
{
max=178,
Array=new[reals,max,2].SetArray{
160.73, 6266.7,
159.82, 6151.9,
158.84, 6035.1,
157.86, 5920.9,
156.87, 5812.6,
155.88, 5702.2,
154.89, 5594.9,
153.96, 5491.3,
152.97, 5385,
151.98, 5282.2,
150.99, 5181.3,
150.06, 5084.8,
149.08, 4988.8,
148.09, 4892.2,
147.1 , 4796.9,
146.17, 4701,
145.18, 4608,
144.2 , 4515.2,
143.2 , 4429.6,
142.21, 4342.9,
141.25, 4255.6,
140.2 , 4167.1,
139.14, 4077.6,
138.05, 3987.9,
136.96, 3898.9,
135.94, 3808.5,
134.84, 3717.7,
133.74, 3628.9,
132.65, 3543,
131.57, 3456.3,
130.55, 3372.5,
129.47, 3292.8,
128.4 , 3212.7,
127.33, 3133.6,
126.34, 3056.6,
125.29, 2985.5,
124.26 , 2912.5,
123.23, 2842.9,
122.21, 2774.1,
121.21, 2708.3,
120.27, 2642.1,
119.27, 2580.2,
118.29, 2518.7,
117.32, 2459.1,
116.42, 2401.1,
115.48, 2344.3,
114.55, 2290.9,
113.62, 2237.5,
112.7 , 2189,
111.85, 2138.8,
110.94, 2089.4,
110.03 , 2042.4,
109.13 , 1998.1,
108.28, 1953.6,
107.38, 1906.6,
106.48, 1867.8,
105.6 , 1824.5,
104.72 , 1784.3,
103.91, 1745,
103.05, 1704.5,
102.2, 1668.7,
101.35, 1629 ,
100.51, 1590.4,
99.739, 1552.5,
98.913 , 1514.7,
98.103, 1476.4,
97.308, 1444.3,
96.513, 1411.4,
95.78 , 1378.5,
95.002, 1344.8,
94.239, 1307.8,
93.482, 1276.1,
92.776, 1243.5,
92.039, 1212.9,
91.314, 1178.7,
90.604 , 1148.4,
89.942, 1115.9,
89.244 , 1084.5,
88.559, 1051.5,
87.889, 1029.7,
87.226, 996.16,
86.569 , 965.86,
85.963, 937.72,
85.323, 907.87,
84.694, 877.58,
84.081 , 838.17,
83.473, 819.48,
82.876, 797.76,
82.287, 768.54,
81.811, 749.96,
81.178, 724.39,
80.614 , 697.24,
80.118, 674.67,
79.574, 649.49,
79.011, 629.83,
78.478, 614.6,
78.012, 591.87,
77.494 , 573.43,
76.927, 558.94,
76.512, 539.45,
75.962, 526.99,
75.472, 514.14,
75.014, 504.11,
74.566, 484.4,
74.123, 473.23,
73.608, 468.93,
73.183, 453.77,
72.774, 448.58,
72.369, 447.73,
71.897, 431.79,
71.503, 432.45,
71.116, 432.15,
70.741, 420.71,
70.3, 427.26,
69.935, 419.76,
69.572, 407.28,
69.148, 408.04,
68.796, 393.71,
68.448, 403.74,
68.114, 408.8,
67.717, 401.26,
67.374, 400.81,
67.037, 401.89,
66.741, 408.68,
66.416, 398.49,
66.015, 414.14,
65.373, 419.78,
64.769, 426.82,
64.109, 418.42,
63.44 , 446.32,
62.772, 451.55,
62.111, 473.27,
61.508, 499.69,
60.908, 523.66,
60.219, 551.47,
59.699, 593.53,
59.119, 608.69,
58.547, 658.08,
57.992, 712.27,
57.483, 769.4,
56.969, 826.48,
56.472, 896.05,
55.989, 957.57,
55.513, 1065.1,
55.088, 1114.1,
54.651, 1195,
54.237, 1271.5,
53.836, 1355.6,
53.318, 1483.2,
52.701, 1690,
52.08 , 2245.9,
51.431, 2470.4,
50.877, 2719.1,
50.298, 2957.5,
49.74 , 3155.2,
49.2 , 3279.4,
48.702, 3546.4,
48.182, 3741,
47.681, 4021,
47.213, 4015.1,
46.768, 4304.7,
46.368, 4127.9,
45.956, 4530.9,
45.55 , 4802.9,
45.157, 5047.4,
44.799, 4804.3,
44.43 , 5164.1,
44.078, 4781,
43.727, 5175.5,
43.384, 5708.6,
43.079, 5679.6,
42.899, 5161.8,
42.719, 5399.1,
42.547, 5483,
42.253, 4839.4,
41.962, 5360.7,
41.691, 5622,
40.602, 5772.3
},
Opt[@f]
};
结果(需尝试几次):
1.773989909927714e-004 7.12634775546666e-033 16.72488443285935 1.215887381574098e-003 3.043657279780005 104.376667977067
第2题:尚未获得正解
!!!using["luopt","math"];
f(p1,p2,p3,p4,p5,a1,a2,a3,a4:i,s,x1,x2,x3,x4,y:Array,max)=
{
s=0,i=0,(i<max).while{
x1=Array[i,0], x2=Array[i,1], x3=Array[i,2],
x4=Array[i,3], y=Array[i,4],
s=s+[(p1+p2*x1+p3*x2+p4*x3+p5*x4)/(1+a1*x1+a2*x2+a3*x3+a4*x4)-y]^2,
i++
},
sqrt[s/max]
};
init(::Array,max)=
{
max=18,
Array=new[reals,max,5].SetArray{
15100, 29000, 508.0, 180, 3.40,
20500, 43350, 453.7, 141, 3.00,
80000, 92610, 487.9, 132, 2.70 ,
91500, 142775, 572.3, 182, 3.37,
82500, 2123160, 455.7, 113, 6.89 ,
20000, 227800, 481.3, 170, 5.03 ,
17800, 140000, 541.3, 179, 3.55 ,
3900, 15980, 538.6, 186, 2.72 ,
17300, 223200, 460.6, 100, 4.05 ,
25700, 229400, 393.1, 133, 3.22 ,
49400, 424500, 373.9, 106, 2.65 ,
40700, 561700, 482.8, 107, 1.91 ,
77000, 563600, 482.1, 140, 3.00 ,
92900, 557600, 415.1, 121, 1.31 ,
63300, 528300, 536.7, 144, 2.33 ,
51600, 488940, 385.1, 154, 3.55 ,
60000, 480500, 412.2, 111, 3.37 ,
70000, 530500, 567.2, 139, 2.55
},
Opt[@f, optmax,500, optmode,100, optwaysimdeep, optwayconfra,
optdeep,50]
};
结果(目前最佳结果):
-1411069164.630981 -310891.2747442204 9067.337780840826 25274546.09482725 -44468616.56134673 -113162.8566426958 3541.156489262849 5789466.884427597 -8952208.112790817 0.4405527997777767
第3题:
!!!using["luopt"];
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}
};
Opt[@f];
结果(需尝试几次):
-101.0805795116041 -1258.521466815511 -170.1106261401753 0.8767278704475284
第4题:
!!!using["luopt","math"];
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{
x1=Array[i,0], x2=Array[i,1], x3=Array[i,2],
x4=Array[i,3], y=Array[i,4],
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(::Array,max)=
{
max=23,
Array=new[reals,max,5].SetArray{
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
},
Opt[@f, optwaysimdeep, optwayconfra]
};
结果(需求解几次):
674.6781937042127 227.7453915656436 2120.317418232974 1.643200016850861 -176.0515628702959 0.5725832815136416 5.556417489954765 3.344065962703589e-002 -0.5600170829989317 48.05714060993065
第5题:
!!!using["luopt","math"];
f(p1, p2, p3, p4, p5,p6,p7,p8:i,s,x,y,z:Array,max)=
{
s=0,i=0,(i<max).while{
x=Array[i,0], y=Array[i,1], z=Array[i,2],
s=s+[
p1+p2*x^p3+p4*y^p5+p6*x^p7*y^p8-z]^2,
i++
},
sqrt[s/max]
};
main(::Array,max)=
{
max=24,
Array=new[reals,max,3].SetArray{
500, 25, 1.5 ,
500, 50, 2.25 ,
500, 100 ,3.15 ,
500, 200, 4.0 ,
500, 300, 4.2 ,
500, 400, 4.3 ,
1000, 25 , 1.45 ,
1000, 50 , 2.35 ,
1000, 100, 3.95 ,
1000, 200, 6.95 ,
1000, 300, 8.15 ,
1000, 400, 8.4 ,
1500, 25 , 1.45 ,
1500, 50 , 2.45 ,
1500, 100, 4.15 ,
1500, 200, 7.45 ,
1500, 300, 10.65 ,
1500, 400, 11.85 ,
2000, 25 , 1.45 ,
2000, 50 , 2.5 ,
2000, 100, 4.2 ,
2000, 200, 7.75 ,
2000, 300, 11.45 ,
2000, 400, 14.3
},
Opt[@f, optmax,200, optwaysimdeep, optwayconfra, optdeep,50]
};
结果(需多次求解):
1.028492626137522 -2.750850635111363e-014 4.045587756019219 -1.367092297732806e-003 1.623222334047968 2.679931221480448e-003 0.2533017000609598 1.268069564889027 0.2703296912011674
第6题:
!!!using["luopt","math"];
f(a0, a1, a2, a3, k1,k2,k3 :i,s,x,y:Array,max)=
{
s=0,i=0,(i<max).while{
x=Array[i,0], y=Array[i,1],
s=s+[
a0+a1*x^k1+a2*x^k2+a3*x^k3-y]^2,
i++
},
sqrt[s/max]
};
main(::Array,max)=
{
max=10,
Array=new[reals,max,2].SetArray{
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
},
Opt[@f, optwaysimdeep, optwayconfra]
};
结果(需多次求解):
-2.435047968667117 -5.596012968756312e-004 1.746941301238457 8.888535605114285 4.021264991475747 0.8188562111431067 -1.1645140483289 2.147261368496635e-002
第7题:尚未获得正解
!!!using["luopt","math"];
f(p1, p2, p3, p4, p5,p6,p7:i,s,x,y,z:Array,max)=
{
s=0,i=0,(i<max).while{
x=Array[i,0], y=Array[i,1], z=Array[i,2],
s=s+[
(p1+p2*x+p3*y+p4*x*y)/(1+p5*x+p6*y+p7*x*y)-z]^2,
i++
},
sqrt[s/max]
};
main(::Array,max)=
{
max=21,
Array=new[reals,max,3].SetArray{
4332, 26.94 , 43.70 ,
4697, 23.64 , 44.50 ,
5062, 25.19 , 47.70 ,
5428, 28.60 , 52.30 ,
5793, 28.74 , 54.21 ,
6158, 29.33 , 55.58 ,
6523, 32.92 , 55.70 ,
6889, 31.87 , 57.70 ,
7254, 33.07 , 58.60 ,
7619 , 29.36 , 60.24 ,
7984, 27.96 , 59.13 ,
8350 , 30.18 , 57.00 ,
8715 , 37.84 , 57.30 ,
9080 , 38.86 , 59.00 ,
9445 , 35.18 , 60.20 ,
9811 , 28.81 , 61.80 ,
10176, 34.57 , 63.17 ,
10541, 37.49 , 66.23 ,
10906, 29.30 , 61.80 ,
11272, 32.47 , 62.03 ,
11637, 38.24 , 65.30
},
Opt[@f, optmax,200, optmode,100, optwaysimdeep, optwayconfra,
optdeep,50, optrange,-1e10,1e10,-1e10,1e10,-1e10,1e10,-1e10,1e10,-1e10,1e10,-1e10,1e10,-1e10,1e10]
};
结果(目前最佳结果):
66.31043984730621 -1.340393030339088e-002 -2.043205883266165 3.603167280100993e-004 -2.100647553429556e-004 -3.244665083648353e-002 5.781184347435274e-006 1.278491440472475
第8题:
!!!using["luopt","math"];
f(p1, p2, p3, p4, p5,p6:i,s,x1,x2,x3,y:Array,max)=
//目标函数定义
{
s=0,i=0,(i<max).while{
x1=Array[i,0], x2=Array[i,1], x3=Array[i,2],
y=Array[i,3],
s=s+[
p1/((p2+x1)*(1+p3*x2)*(x3-p4)^2)+p5*x3^p6-y]^2,
i++
},
sqrt[s/max]
};
main(::Array,max)=
{
max=27,
Array=new{reals,max,4, data:
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
},
Opt[@f, optwaysimdeep, optwayconfra]
};
结果(需多次求解):
178963.6676067503 3672.74944952677 0.530211167053818 27.80500822839966 195.3596009106615 -2.596554487779508 1.977698395027922e-002
第9题:
!!!using["luopt"];
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}
};
Opt[@f, optwaysimdeep, optwayconfra];
结果(需多次求解):
19.15817773649649 -0.3625927565554836 -29.81592272236692 2.297951055806539 1.15469090018263
4 求方程(组)的全部解
[返回页首] luopt::iFind(f, luopt::optmax,m, luopt::optrange,min,max, luopt::opteps,eps, luopt::optexact,exact, luopt::optpara,x1,x2,..., luopt::optthis,i, luopt::optmin0,min0, luopt::optsameeps,sameeps, luopt::optsameabs,sameabs, luopt::optstarter,starter, luopt::optarray,a, luopt::optarraybegin,&k, luopt::optout,out, luopt::optnum,num):求单变量方程的全部解
f:自定义n元函数句柄,不可缺省。格式如下:
f(x1,x2,...,xn)=
{
... ...
};
默认求方程f(x1,x2,...,xn)=0第一个自变量的全部解,而其他自变量赋值为0.0。可以用参数optthis指定求解的自变量,也可以用参数optpara给出其他自变量的值。
luopt::optmax,m:区间分割数目(大于等于10),区间分割数目越多精度越高。可以缺省该参数,缺省值为200。
luopt::optrange,min,max:指定求解区间。若缺省该参数,则min为-1e50,max为1e50。
luopt::opteps,eps:控制精度要求,eps>0。可以缺省该参数,缺省值为1e-6。
luopt::optexact,exact:控制精度的方式,exact非0将严格控制精度,否则只追求解的正确性,尽可能满足解的精度。可以缺省该参数,将严格控制解的精度。
luopt::optpara,x1,x2,...:给指定求解自变量之外的其他自变量赋值,参数x1,x2,...的个数比全部自变量个数少1。若缺省该参数,其他自变量缺省值均为0.0。
luopt::optthis,i:指定求解的自变量。0表示第一个自变量;1表示第二个自变量,以此类推。若缺省该参数,i为0。
luopt::optmin0,min0:解的可能的极小值。可以缺省该参数,缺省值为±1e-50。
luopt::optsameeps,sameeps:相对比较两组值是否相等的极小值。sameeps>0。可以缺省该参数,缺省值为1e-3。
luopt::optsameabs,sameabs:绝对比较两组值是否相等的极小值。sameeps>=0。可以缺省该参数,缺省值为0.0。
luopt::optstarter,starter:提供一个初值。可以缺省该参数。
luopt::optarray,a:提供一个数组,用于接受结果。一组结果包括所有的自变量参数及误差。默认从数组开始存放数据,也可用参数optarraybegin指定开始存放数据的位置。可以缺省该参数。
luopt::optarraybegin,&k:指定数组中开始存放数据的位置,k返回下一个存放位置。可以缺省该参数,默认从地址0开始存放。
luopt::optout,out:是否输出结果。out非0时输出。可以缺省该参数,默认输出结果。
luopt::optnum,num:设置最多求解的解的个数。可以缺省该参数,默认最多求解100个解。
返回值:解的个数。
运行错误:
1:指定的表达式不存在;
2:常量表达式;
3:自变量参数重新赋值,这是不允许的;
4:参数不匹配;
5:不可识别描述符;
6:参数不符合要求;
7:自定义函数返回了非法值。
例子1:求方程的全部解:f(x)=x^6-5*x^5+3*x^4+x^3-7*x^2+7*x-20;
f(x)=x^6-5*x^5+3*x^4+x^3-7*x^2+7*x-20;
luopt::iFind[@f];
例子2:求方程的全部解(x取-8~8,y取1):f(x,y)=(x^2+y^2)^3-36*(x^2-y^2)^2;
!!!using("luopt");
f(x,y)=(x^2+y^2)^3-36*(x^2-y^2)^2;
iFind[@f,optrange,-8.,8.,optpara,1.];
例子3:求方程的全部解(x取1,y取-8~8):f(x,y)=(x^2+y^2)^3-36*(x^2-y^2)^2;
!!!using("luopt");
f(x,y)=(x^2+y^2)^3-36*(x^2-y^2)^2;
iFind[@f, optrange,-8.,8., optthis,1, optpara,1.];
[返回页首] luopt::Find(f, luopt::optmax,m, luopt::optmode,mode, luopt::optdeep,deep, luopt::optrange,x1min,x1max,x2min,x2max,...,xnmin,xnmax, luopt::optautorange,autorange,luopt::opteps,eps, luopt::optmin0,min0, luopt::optsameeps,sameeps, luopt::optsameabs,sameabs, luopt::optstarter,&x1,&x2,...,&xn,&min, luopt::optarray,a, luopt::optarraybegin,&k, luopt::optexpand,expand, luopt::optcontract,contract, luopt::optdx,dx, luopt::optstep,step, luopt::optout,out, luopt::optnum,num):求方程组的全部解
f:自定义2*n元函数句柄,不可缺省,必须由二级函数HFor获得该句柄。格式如下:
f(x1,x2,...,xn,y1,y2,...,yn)=
{
y1= ...,
y2= ...,
... ...,
yn= ...
};
luopt::optmax,m:随机点的数目(大于等于10),点数越多精度越高。可以缺省该参数,缺省值为200。
luopt::optmode,mode:工作模式,取0、1、2、3、... ...。通常,工作模式取值越大,搜到的解越多,但耗时越长。若缺省该参数,工作模式取0。
luopt::optdeep,deep:搜索深度,取0、1、2、3、... ...。通常,搜索深度取值越大,搜到的解越多,但耗时越长。若缺省该参数,搜索深度取0。
luopt::optrange,x1min,x1max,x2min,x2max,...,xnmin,xnmax:指定求解区间。若缺省该参数,则所有变量区间均为[-1e50~1e50]。
luopt::optautorange,autorange:autorange!=0时将在指定搜索区间内自动调节合适的搜索区间,否则不进行调节。默认是不会自动调节搜索区间的。
luopt::opteps,eps:控制精度要求,eps>0。可以缺省该参数,缺省值为1e-6。满足sqrt[(y1*y1+y2*y2+...+yn*yn)/n]<eps。
luopt::optmin0,min0:解的可能的极小值。可以缺省该参数,缺省值为±1e-50。
luopt::optsameeps,sameeps:相对比较两组值是否相等的极小值。sameeps>0。可以缺省该参数,缺省值为1e-2。
luopt::optsameabs,sameabs:绝对比较两组值是否相等的极小值。sameeps>=0。可以缺省该参数,缺省值为1e-3。
luopt::optstarter,&x1,&x2,...,&xn,&min:前n个参数提供一组初值,并返回一组解;最后一个参数min返回该组解的误差。可以缺省该参数。
luopt::optarray,a:提供一个数组,用于接受结果。一组结果包括所有的自变量参数及误差。默认从数组开始存放数据,也可用参数optarraybegin指定开始存放数据的位置。可以缺省该参数。
luopt::optarraybegin,&k:指定数组中开始存放数据的位置,k返回下一个存放位置。可以缺省该参数,默认从地址0开始存放。
luopt::optexpand,expand:扩张系数。一般取1.2~2.0。可以缺省该参数,缺省值为1.6。
luopt::optcontract,contract:收缩系数。一般取0~1。可以缺省该参数,缺省值为0.5。
luopt::optdx,dx:搜索增量初值,dx>0。可以缺省该参数,缺省值为0.1。
luopt::optstep,step:搜索步长修正系数。step取0~1之间的数。可以缺省该参数,缺省值为0.1。
luopt::optout,out:是否输出结果。out非0时输出。可以缺省该参数,默认输出结果。
luopt::optnum,num:设置最多求解的解的个数。可以缺省该参数,默认最多求解10个解。
返回值:解的个数。
说明:需要多次运行该函数以获得需要的解。
运行错误:
1:指定的表达式不存在;
2:常量表达式或者参数不成对;
3:内存错误;
4:参数不匹配;
5:不可识别描述符;
6:参数不符合要求;
7:自定义函数返回了非法值。
例子1:解方程组:
(x-y)^2-3*(x-y) = 10
x^2+2*x*y+y^2 = 9
代码:
f(x,y,y1,y2)=
{
y1=(x-y)^2-3*(x-y)-10,
y2=x^2+2*x*y+y^2-9
};
luopt::Find[@f];
例子2:解方程组:
2*x1-x2^2-exp(-x1) = 0
-(x1^3)+x1*x2-exp(-x2) = 0
代码:
f(x1,x2,y1,y2)=
{
y1=2*x1-x2^2-exp(-x1),
y2=-(x1^3)+x1*x2-exp(-x2)
};
luopt::Find[@f];
例子3:解方程组:t取-7~7
-b*sin(a+6*t)+n-40.4945=0
-b*sin(a+7*t)+n-40.5696=0
-b*sin(a+8*t)+n-41.0443=0
-b*sin(a+9*t)+n-41.4190=0
代码:
!!!using["luopt"];
f(a,b,n,t,y1,y2,y3,y4)=
{
y1=-b*sin(a+6*t)+n-40.4945,
y2=-b*sin(a+7*t)+n-40.5696,
y3=-b*sin(a+8*t)+n-41.0443,
y4=-b*sin(a+9*t)+n-41.4190
};
Find[@f, optmode,5, optrange,-1e50,1e50,-1e50,1e50,-1e50,1e50,-7.,7.];
版权所有©
Lu程序设计
2011-2012,保留所有权利
E-mail: forcal@sina.com
QQ:630715621
最近更新:
2012年10月29日