1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
| function [lam,fval,exitflag,output]=fminsearchbnd(fonct,lam0,LB,UB,options,varargin)
% FMINSEARCHBND: FMINSEARCH, but with bound constraints by transformation
% usage: x=FMINSEARCHBND(fun,x0)
% usage: x=FMINSEARCHBND(fun,x0,LB)
% usage: x=FMINSEARCHBND(fun,x0,LB,UB)
% usage: x=FMINSEARCHBND(fun,x0,LB,UB,options)
% usage: x=FMINSEARCHBND(fun,x0,LB,UB,options,p1,p2,...)
% usage: [x,fval,exitflag,output]=FMINSEARCHBND(fun,x0,...)
%
% arguments:
% fun, x0, options - see the help for FMINSEARCH
%
% LB - lower bound vector or array, must be the same size as x0
%
% If no lower bounds exist for one of the variables, then
% supply -inf for that variable.
%
% If no lower bounds at all, then LB may be left empty.
%
% Variables may be fixed in value by setting the corresponding
% lower and upper bounds to exactly the same value.
%
% UB - upper bound vector or array, must be the same size as x0
%
% If no upper bounds exist for one of the variables, then
% supply +inf for that variable.
%
% If no upper bounds at all, then UB may be left empty.
%
% Variables may be fixed in value by setting the corresponding
% lower and upper bounds to exactly the same value.
%
% Notes:
%
% If options is supplied, then TolX will apply to the transformed
% variables. All other FMINSEARCH parameters should be unaffected.
%
% Variables which are constrained by both a lower and an upper
% bound will use a sin transformation. Those constrained by
% only a lower or an upper bound will use a quadratic
% transformation, and unconstrained variables will be left alone.
%
% Variables may be fixed by setting their respective bounds equal.
% In this case, the problem will be reduced in size for FMINSEARCH.
%
% The bounds are inclusive inequalities, which admit the
% boundary values themselves, but will not permit ANY function
% evaluations outside the bounds. These constraints are strictly
% followed.
%
% If your problem has an EXCLUSIVE (strict) constraint which will
% not admit evaluation at the bound itself, then you must provide
% a slightly offset bound. An example of this is a function which
% contains the log of one of its parameters. If you constrain the
% variable to have a lower bound of zero, then FMINSEARCHBND may
% try to evaluate the function exactly at zero.
%
%
% Example usage:
% rosen = @(x) (1-x(1)).^2 + 105*(x(2)-x(1).^2).^2;
%
% fminsearch(rosen,[3 3]) % unconstrained
% ans =
% 1.0000 1.0000
%
% fminsearchbnd(rosen,[3 3],[2 2],[]) % constrained
% ans =
% 2.0000 4.0000
%
% See test_main.m for other examples of use.
%
%
% See also: fminsearch, fminspleas
%
%
% Author: John D'Errico
% E-mail: woodchips@rochester.rr.com
% Release: 4
% Release date: 7/23/06
% size checks
lam0 = [0.01 0.05 0.05];
lamsize = size(lam0);
n=length(lam0);
if (nargin<3) || isempty(LB)
LB = repmat(-inf,n,1);
else
LB = LB(:);
end
if (nargin<4) || isempty(UB)
UB = repmat(inf,n,1);
else
UB = UB(:);
end
if (n~=length(LB)) || (n~=length(UB))
error 'lam0 is incompatible in size with either LB or UB.'
end
% set default options if necessary
if (nargin<5) || isempty(options)
options = optimset('fminsearch');
end
% stuff into a struct to pass around
params.args = varargin;
params.LB = LB;
params.UB = UB;
params.n = n;
% note that the number of parameters may actually vary if
% a user has chosen to fix one or more parameters
params.lamsize = lamsize;
params.OutputFcn = [];
% 0 --> unconstrained variable
% 1 --> lower bound only
% 2 --> upper bound only
% 3 --> dual finite bounds
% 4 --> fixed variable
params.BoundClass = zeros(n,1);
for i=1:n
k = isfinite(LB(i)) + 2*isfinite(UB(i));
params.BoundClass(i) = k;
if (k==3) && (LB(i)==UB(i))
params.BoundClass(i) = 4;
end
end
% transform starting values into their unconstrained
% surrogates. Check for infeasible starting guesses.
lam0u = lam0;
k=1;
for i = 1:n
switch params.BoundClass(i)
case 1
% lower bound only
if lam0(i)<=LB(i)
% infeasible starting value. Use bound.
lam0u(k) = 0;
else
lam0u(k) = sqrt(lam0(i) - LB(i));
end
% increment k
k=k+1;
case 2
% upper bound only
if lam0(i)>=UB(i)
% infeasible starting value. use bound.
lam0u(k) = 0;
else
lam0u(k) = sqrt(UB(i) - lam0(i));
end
% increment k
k=k+1;
case 3
% lower and upper bounds
if lam0(i)<=LB(i)
% infeasible starting value
lam0u(k) = -pi/2;
elseif lam0(i)>=UB(i)
% infeasible starting value
lam0u(k) = pi/2;
else
lam0u(k) = 2*(lam0(i) - LB(i))/(UB(i)-LB(i)) - 1;
% shift by 2*pi to avoid problems at zero in fminsearch
% otherwise, the initial simplex is vanishingly small
lam0u(k) = 2*pi+asin(max(-1,min(1,lam0u(k))));
end
% increment k
k=k+1;
case 0
% unconstrained variable. x0u(i) is set.
lam0u(k) = lam0(i);
% increment k
k=k+1;
case 4
% fixed variable. drop it before fminsearch sees it.
% k is not incremented for this variable.
end
end
% if any of the unknowns were fixed, then we need to shorten
% x0u now.
if k<=n
lam0u(k:n) = [];
end
% were all the variables fixed?
if isempty(lam0u)
% All variables were fixed. quit immediately, setting the
% appropriate parameters, then return.
% undo the variable transformations into the original space
lam = lamtransform(lam0u,params);
% final reshape
lam = reshape(lam,lamsize);
% stuff fval with the final value
fval = feval(lam,params.args{:});
% fminsearchbnd was not called
exitflag = 0;
output.iterations = 0;
output.funcount = 1;
output.algorithm = 'fminsearch';
output.message = 'All variables were held fixed by the applied bounds';
% return with no call at all to fminsearch
return
end
% Check for an outputfcn. If there is any, then substitute my
% own wrapper function.
if ~isempty(options.OutputFcn)
params.OutputFcn = options.OutputFcn;
options.OutputFcn = @outfonct_wrapper;
end
% now we can call fminsearch, but with our own
% intra-objective function.
[lamu,fval,exitflag,output] = fminsearch(@intrafonct,lam0u,options,params);
% undo the variable transformations into the original space
lam = lamtransform(lamu,params);
% final reshape to make sure the result has the proper shape
lam = reshape(lam,lamsize);
% Use a nested function as the OutputFcn wrapper
function stop = outfonct_wrapper(lam,varargin);
% we need to transform x first
lamtrans = lamtransform(lam,params);
% then call the user supplied OutputFcn
stop = params.OutputFcn(lamtrans,varargin{1:(end-1)});
end
end % mainline end
% ======================================
% ========= begin subfunctions =========
% ======================================
function fval = intrafonct(lam,params)
% transform variables, then call original function
% transform
lamtrans = lamtransform(lam,params);
% and call fun
fval = feval(reshape(lamtrans,params.lamsize),params.args{:});
end % sub function intrafun end
% ======================================
function lamtrans = lamtransform(lam,params)
% converts unconstrained variables into their original domains
lamtrans = zeros(params.lamsize);
% k allows some variables to be fixed, thus dropped from the
% optimization.
k=1;
for i = 1:params.n
switch params.BoundClass(i)
case 1
% lower bound only
lamtrans(i) = params.LB(i) + lam(k).^2;
k=k+1;
case 2
% upper bound only
lamtrans(i) = params.UB(i) - lam(k).^2;
k=k+1;
case 3
% lower and upper bounds
lamtrans(i) = (sin(lam(k))+1)/2;
lamtrans(i) = lamtrans(i)*(params.UB(i) - params.LB(i)) + params.LB(i);
% just in case of any floating point problems
lamtrans(i) = max(params.LB(i),min(params.UB(i),lamtrans(i)));
k=k+1;
case 4
% fixed variable, bounds are equal, set it at either bound
lamtrans(i) = params.LB(i);
case 0
% unconstrained variable.
lamtrans(i) = lam(k);
k=k+1;
end
end
end % sub function xtransform end |
minimiser l'erreur entre deux courbes expérimentales et numériques
Répondre avec citation
Envoyé par foufi86
Partager