From: <sla...@us...> - 2009-02-03 22:11:26
|
Revision: 5554 http://octave.svn.sourceforge.net/octave/?rev=5554&view=rev Author: slackydeb Date: 2009-02-03 22:02:50 +0000 (Tue, 03 Feb 2009) Log Message: ----------- Add linprog function. Modify INDEX to reflect change. Bump version. Modified Paths: -------------- trunk/octave-forge/main/optim/DESCRIPTION trunk/octave-forge/main/optim/INDEX Added Paths: ----------- trunk/octave-forge/main/optim/inst/linprog.m Modified: trunk/octave-forge/main/optim/DESCRIPTION =================================================================== --- trunk/octave-forge/main/optim/DESCRIPTION 2009-01-30 11:52:42 UTC (rev 5553) +++ trunk/octave-forge/main/optim/DESCRIPTION 2009-02-03 22:02:50 UTC (rev 5554) @@ -1,5 +1,5 @@ Name: Optim -Version: 1.0.4 +Version: 1.0.5 Date: 2008-08-23 Author: Various Authors Maintainer: The Octave Community Modified: trunk/octave-forge/main/optim/INDEX =================================================================== --- trunk/octave-forge/main/optim/INDEX 2009-01-30 11:52:42 UTC (rev 5553) +++ trunk/octave-forge/main/optim/INDEX 2009-02-03 22:02:50 UTC (rev 5554) @@ -21,7 +21,7 @@ fminunc optimset quadprog= try Yinyu Ye's <a href="http://dollar.biz.uiowa.edu/col/ye/matlab.html">code</a> - linprog= try <f>glpk</f> + linprog Numerical derivatives dfdp bs_gradient cdiff deriv leval numgradient numhessian Added: trunk/octave-forge/main/optim/inst/linprog.m =================================================================== --- trunk/octave-forge/main/optim/inst/linprog.m (rev 0) +++ trunk/octave-forge/main/optim/inst/linprog.m 2009-02-03 22:02:50 UTC (rev 5554) @@ -0,0 +1,101 @@ +## Copyright (C) 2009 Luca Favatella <sla...@gm...> +## +## This program is free software; you can redistribute it and/or modify +## it under the terms of the GNU General Public License as published by +## the Free Software Foundation; either version 2 of the License, or +## (at your option) any later version. +## +## This program is distributed in the hope that it will be useful, +## but WITHOUT ANY WARRANTY; without even the implied warranty of +## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +## GNU General Public License for more details. +## +## You should have received a copy of the GNU General Public License +## along with this program; If not, see <http://www.gnu.org/licenses/>. + +## -*- texinfo -*- +## @deftypefn{Function File} {@var{x} =} linprog (@var{f}, @var{A}, @var{b}) +## @deftypefnx{Function File} {@var{x} =} linprog (@var{f}, @var{A}, @var{b}, @var{Aeq}, @var{beq}) +## @deftypefnx{Function File} {@var{x} =} linprog (@var{f}, @var{A}, @var{b}, @var{Aeq}, @var{beq}, @var{LB}) +## @deftypefnx{Function File} {@var{x} =} linprog (@var{f}, @var{A}, @var{b}, @var{Aeq}, @var{beq}, @var{LB}, @var{UB}) +## @deftypefnx{Function File} {[@var{x}, @var{fval}] =} linprog (@dots{}) +## Solve a linear program. @code{linprog} solves the following LP: +## +## @example +## min f'*x +## @end example +## +## subject to +## +## @example +## @group +## A*x <= b +## Aeq*x = beq +## x >= LB +## x <= UB +## @end group +## @end example +## +## The default @var{Aeq} and @var{beq} are assumed to be empty matrices. +## +## The default lower bound @var{LB} is assumed to be minus infinite; the +## default upper bound @var{UB} is assumed to be infinite. +## +## @seealso{glpk} +## @end deftypefn + +## Author: Luca Favatella <sla...@gm...> +## Version: 0.3 + + # TODO + # write a test using Aeq and beq + +function [x fval] = linprog (f, A, b, + Aeq = [], beq = [], + LB = [], UB = []) + + if ((nargin < 3) || (nargin == 4) || (nargin > 7) || + (nargout > 2) || + (! isvector (f))) + print_usage (); + else + + l_f = length(f); + nr_A = rows (A); + nr_Aeq = rows (Aeq); + + if (isempty (LB)) + LB = - inf (1, l_f); + endif + if (isempty (UB)) + UB = inf (1, l_f); + endif + + ctype = [(repmat ("U", nr_A, 1)); + (repmat ("S", nr_Aeq, 1))]; + [x fval] = glpk (f(1:l_f), + [A(1:nr_A, 1:l_f); Aeq(1:nr_Aeq, 1:l_f)], + [b(1:nr_A, 1); beq(1:nr_Aeq, 1)], + LB(1:l_f), + UB(1:l_f), + ctype); + + endif + +endfunction + + +%!test +%! f = [21 25 31 34 23 19 32 36 27 25 19]; +%! A1 = [1 0 0 0 1 0 0 1 0 0 0; 0 1 0 0 0 1 0 0 1 0 0; 0 0 1 0 0 0 0 0 0 1 0; 0 0 0 1 0 0 1 0 0 0 1]; +%! A2 = [1 1 1 1 0 0 0 0 0 0 0; 0 0 0 0 1 1 1 0 0 0 0; 0 0 0 0 0 0 0 1 1 1 1]; +%! A = [-A1; A2]; +%! b1 = [40; 50; 50; 70]; +%! b2 = [100; 60; 50]; +%! b = [-b1; b2]; +%! Aeq = zeros (1, 11); +%! beq = 0; +%! LB = zeros (1, 11); +%! observed = linprog (f, A, b, Aeq, beq, LB); +%! expected = [40; 0; 50; 10; 0; 50; 10; 0; 0; 0; 50]; +%! assert (observed, expected); \ No newline at end of file This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <te...@us...> - 2009-03-24 17:14:54
|
Revision: 5635 http://octave.svn.sourceforge.net/octave/?rev=5635&view=rev Author: tealev Date: 2009-03-24 17:14:47 +0000 (Tue, 24 Mar 2009) Log Message: ----------- Non-linear conjugate gradient method and examples. Modified Paths: -------------- trunk/octave-forge/main/optim/INDEX Added Paths: ----------- trunk/octave-forge/main/optim/inst/__bracket_min.m trunk/octave-forge/main/optim/inst/__poly_2_extrema.m trunk/octave-forge/main/optim/inst/__semi_bracket.m trunk/octave-forge/main/optim/inst/brent_line_min.m trunk/octave-forge/main/optim/inst/cg_min.m trunk/octave-forge/main/optim/inst/cg_min_example_1.m trunk/octave-forge/main/optim/inst/cg_min_example_2.m trunk/octave-forge/main/optim/inst/cg_min_example_3.m Modified: trunk/octave-forge/main/optim/INDEX =================================================================== --- trunk/octave-forge/main/optim/INDEX 2009-03-24 09:42:13 UTC (rev 5634) +++ trunk/octave-forge/main/optim/INDEX 2009-03-24 17:14:47 UTC (rev 5635) @@ -9,6 +9,7 @@ fmins adsmax mdsmax nmsmax bfgsmin samin battery fminsearch + cg_min Data fitting expfit expdemo wpolyfit wpolyfitdemo @@ -34,3 +35,4 @@ bfgsmin_example rosenbrock samin_example + cg_min_test_1 cg_min_test_2 cg_min_test_3 Added: trunk/octave-forge/main/optim/inst/__bracket_min.m =================================================================== --- trunk/octave-forge/main/optim/inst/__bracket_min.m (rev 0) +++ trunk/octave-forge/main/optim/inst/__bracket_min.m 2009-03-24 17:14:47 UTC (rev 5635) @@ -0,0 +1,30 @@ +## [a, b, ga, gb, nev] = semi_bracket (f, dx, a, narg, args) +## +## Find an interval containing a local minimum of the function +## g : h in reals ---> f (x+h*dx) where x = args{narg} +## +## a < b. +## nev is the number of function evaluations + +## Author : Etienne Grossmann <et...@is...> +## Modified by: Levente Torok <Tor...@gm...> +## This software is distributed under the terms of the GPL + +function [a, b, ga, gb, n] = __bracket_min (f, dx, narg, args) + + [a,b, ga,gb, n] = __semi_bracket (f, dx, 0, narg, args); + + if a != 0, return; end + + [a2,b2, ga2,gb2, n2] = __semi_bracket (f, -dx, 0, narg, args); + + n += n2; + + if a2 == 0, + a = -b2; ga = gb2; + else + a = -b2; + b = -a2; + ga = gb2; + gb = ga2; +end Added: trunk/octave-forge/main/optim/inst/__poly_2_extrema.m =================================================================== --- trunk/octave-forge/main/optim/inst/__poly_2_extrema.m (rev 0) +++ trunk/octave-forge/main/optim/inst/__poly_2_extrema.m 2009-03-24 17:14:47 UTC (rev 5635) @@ -0,0 +1,39 @@ +## ex = poly_2_ex (l, f) - Extremum of a 1-var deg-2 polynomial +## +## l : 3 : variable values +## f : 3 : f(i) = value of polynomial at l(i) +## +## ex : 1 : Value at which f reaches an extremum +## +## Assuming that f(i) = a*l(i)^2 + b* l(i) + c = P(l(i)) for some a, b, c, +## ex is the extremum of the polynome P. +## +function ex = __poly_2_ex (l, f) + + +### This somewhat helps if solution is very close to one of the points. +[f,i] = sort (f); +l = l(i); + + +m = (l(2) - l(1))/(l(3) - l(1)); +d = (2*(f(1)*(m-1)+f(2)-f(3)*m)); +if abs (d) < eps, + printf ("poly_2_ex : divisor is small (solution at infinity)\n"); + printf ("%8.3e %8.3e %8.3e, %8.3e %8.3e\n",\ + f(1), diff (f), diff (sort (l))); + + ex = (2*(l(1)>l(2))-1)*inf; + ## keyboard +else + ex = ((l(3) - l(1))*((f(1)*(m^2-1) + f(2) - f(3)*m^2))) / d ; + +## Not an improvement +# n = ((l(2)+l(3))*(l(2)-l(3)) + 2*(l(3)-l(2))*l(1)) / (l(3)-l(1))^2 ; +# ex = ((l(3) - l(1))*((f(1)*n + f(2) - f(3)*m^2))) / \ +# (2*(f(1)*(m-1)+f(2)-f(3)*m)); +# if ex != ex0, +# ex - ex0 +# end + ex = l(1) + ex; +end \ No newline at end of file Added: trunk/octave-forge/main/optim/inst/__semi_bracket.m =================================================================== --- trunk/octave-forge/main/optim/inst/__semi_bracket.m (rev 0) +++ trunk/octave-forge/main/optim/inst/__semi_bracket.m 2009-03-24 17:14:47 UTC (rev 5635) @@ -0,0 +1,38 @@ +## [a, b, ga, gb, nev] = semi_bracket (f, dx, a, narg, args) +## +## Find an interval containing a local minimum of the function +## g : h in [a, inf[ ---> f (x+h*dx) where x = nth (args, narg) +## +## The local minimum may be in a. +## a < b. +## nev is the number of function evaluations. + +## Author : Etienne Grossmann <et...@is...> +## Modified by: Levente Torok <Tor...@gm...> +## This software is distributed under the terms of the GPL + +function [a,b,ga,gb,n] = __semi_bracket (f, dx, a, narg, args) + +step = 1; + +x = nth (args, narg); +args{narg} = x+a*dx; ga = feval (f, args ); +b = a + step; +args{narg} = x+b*dx; gb = feval (f, args ); +n = 2; + +if gb >= ga, return ; end + +while 1, + + c = b + step; + args{narg} = x+c*dx; gc = feval( f, args ); + n++; + + if gc >= gb, # ga >= gb <= gc + gb = gc; b = c; + return; + end + step *= 2; + a = b; b = c; ga = gb; gb = gc; +end Added: trunk/octave-forge/main/optim/inst/brent_line_min.m =================================================================== --- trunk/octave-forge/main/optim/inst/brent_line_min.m (rev 0) +++ trunk/octave-forge/main/optim/inst/brent_line_min.m 2009-03-24 17:14:47 UTC (rev 5635) @@ -0,0 +1,220 @@ +## -*- texinfo -*- +## @deftypefn {Function File} {[@var{s},@var{v},@var{n}]} brent_line_min ( @var{f},@var{df},@var{args},@var{ctl} ) +## Line minimization of f along df +## +## Finds minimum of f on line @math{ x0 + dx*w | a < w < b } by +## bracketing. a and b are passed through argument ctl. +## +## @subheading Arguments +## @itemize @bullet +## @item @var{f} : string : Name of function. Must return a real value +## @item @var{args} : cell : Arguments passed to f or RxC : f's only argument. x0 must be at @var{args}@{ @var{ctl}(2) @} +## @item @var{ctl} : 5 : (optional) Control variables, described below. +## @end itemize +## +## @subheading Returned values +## @itemize @bullet +## @item @var{s} : 1 : Minimum is at x0 + s*dx +## @item @var{v} : 1 : Value of f at x0 + s*dx +## @item @var{nev} : 1 : Number of function evaluations +## @end itemize +## +## @subheading Control Variables +## @itemize @bullet +## @item @var{ctl}(1) : Upper bound for error on s Default=sqrt(eps) +## @item @var{ctl}(2) : Position of minimized argument in args Default= 1 +## @item @var{ctl}(3) : Maximum number of function evaluations Default= inf +## @item @var{ctl}(4) : a Default=-inf +## @item @var{ctl}(5) : b Default= inf +## @end itemize +## +## Default values will be used if ctl is not passed or if nan values are +## given. +## @end deftypefn + + +function [s,gs,nev] = brent_line_min( f,dx,args,ctl ) + +verbose = 0; + +seps = sqrt (eps); + + # Default control variables +tol = 10*eps; # sqrt (eps); +narg = 1; +maxev = inf; +a = -inf; +b = inf; + +if nargin >= 4, # Read arguments + if !isnan (ctl (1)), tol = ctl(1); end + if length (ctl)>=2 && !isnan (ctl(2)), narg = ctl(2); end + if length (ctl)>=3 && !isnan (ctl(3)), maxev = ctl(3); end + if length (ctl)>=4 && !isnan (ctl(4)), a = ctl(4); end + if length (ctl)>=5 && !isnan (ctl(5)), b = ctl(5); end + +end # Otherwise, use defaults, def'd above + +if a>b, tmp=a; a=b; b=tmp; end + +if narg > length (args), + printf ("brent_line_min : narg==%i > length (args)==%i",\ + narg, length (args)); + keyboard +end + + +if ! iscell (args), + args = {args}; +endif + +x = args{ narg }; + +[R,C] = size (x); +N = R*C; # Size of argument + +gs0 = gs = feval (f, args); +nev = 1; + # Initial value +s = 0; + +if all (dx==0), return; end # Trivial case + + # If any of the bounds is infinite, find + # finite bounds that bracket minimum +if !isfinite (a) || !isfinite (b), + if !isfinite (a) && !isfinite (b), + [a,b, ga,gb, n] = __bracket_min (f, dx, narg, args); + elseif !isfinite (a), + [a,b, ga,gb, n] = __semi_bracket (f, -dx, -b, narg, args); + tmp = a; a = -b; b = -tmp; + tmp = ga; ga = gb; gb = tmp; + else + [a,b, ga,gb, n] = __semi_bracket (f, dx, a, narg, args); + end + nev += n; +else + args{narg} = x+a*dx; ga = feval( f, args ); + args{narg} = x+b*dx; gb = feval( f, args ); + nev += 2; +end # End of finding bracket for minimum + +if a > b, # Check assumptions + printf ("brent_line_min : a > b\n"); + keyboard +end + +s = 0.5*(a+b); +args{narg} = x+ s*dx; gs = feval( f, args ); +end +nev++; + +if verbose, + printf ("[a,s,b]=[%.3e,%.3e,%.3e], [ga,gs,gb]=[%.3e,%.3e,%.3e]\n",\ + a,s,b,ga,gs,gb); +end + +maxerr = 2*tol; + +while ( b-a > maxerr ) && nev < maxev, + + if gs > ga && gs > gb, # Check assumptions + printf ("brent_line_min : gs > ga && gs > gb\n"); + keyboard + end + + if ga == gb && gb == gs, break end + + # Don't trust poly_2_ex for glued points + # (see test_poly_2_ex). + + ## if min (b-s, s-a) > 10*seps, + + # If s is not glued to a or b and does not + # look linear + ## mydet = sum (l([2 3 1]).*f([3 1 2])-l([3 1 2]).*f([2 3 1])) + mydet = sum ([s b a].*[gb ga gs] - [b a s].*[gs gb ga]); + if min (b-s, s-a) > 10*seps && abs (mydet) > 10*seps && \ + (t = poly_2_ex ([a,s,b], [ga, gs, gb])) < b && t > a, + + # t has already been set + + ## if t>=b || t<=a, + ## printf ("brent_line_min : t is not in ]a,b[\n"); + ## keyboard + ## end + + # Otherwise, reduce the biggest of the + # intervals, but not too much + elseif s-a > b-s, + t = max (0.5*(a+s), s-100*seps); + else + t = min (0.5*(s+b), s+100*seps); + end + + if abs (t-s) < 0.51*maxerr, + #sayif (verbose, "ungluing t and s\n"); + t = s + (1 - 2*(s-a > b-s))*0.49*maxerr ; + end + + if a > s || s > b, # Check assumptions + printf ("brent_line_min : a > s || s > b\n"); + keyboard + end + + xt = args; + args{narg} = x+t*dx; + gt = feval( f, args ); + nev++; + + if verbose, + printf ("t = %.3e, gt = %.3e\n",t,gt); + end + + if t<s, # New point is in ]a,s[ + + if gt > ga + seps, # Check assumptions + printf ("brent_line_min : gt > ga\n"); + keyboard + end + + if gt < gs, + b = s; gb = gs; + s = t; gs = gt; + else + a = t; ga = gt; + end + else # New point is in ]s,b[ + if gt > gb + seps, # Check assumptions + printf ("brent_line_min : gt > gb\n"); + keyboard + end + + if gt < gs, + a = s; ga = gs; + s = t; gs = gt; + else + b = t; gb = gt; + end + end + + if verbose, + printf ("[a,s,b]=[%.3e,%.3e,%.3e], [ga,gs,gb]=[%.3e,%.3e,%.3e]\n",\ + a,s,b,ga,gs,gb); + end + ## keyboard + ## [b-a, maxerr] +end + +s2 = 0.5*(a+b); +args{narg} = x + s2*dx; gs2 = feval (f, args ); +nev++; + +if gs2 < gs, + s = s2; gs = gs2; +end + +if gs > gs0, + printf ("brent_line_min : goes uphill by %8.3e\n",gs-gs0); + keyboard +end \ No newline at end of file Added: trunk/octave-forge/main/optim/inst/cg_min.m =================================================================== --- trunk/octave-forge/main/optim/inst/cg_min.m (rev 0) +++ trunk/octave-forge/main/optim/inst/cg_min.m 2009-03-24 17:14:47 UTC (rev 5635) @@ -0,0 +1,202 @@ +## -*- texinfo -*- +## @deftypefn {Function File} {[@var{x0},@var{v},@var{nev}]} cg_min ( @var{f},@var{df},@var{args},@var{ctl} ) +## NonLinear Conjugate Gradient method to minimize function @var{f}. +## +## @subheading Arguments +## @itemize @bullet +## @item @var{f} : string : Name of function. Return a real value +## @item @var{df} : string : Name of f's derivative. Returns a (R*C) x 1 vector +## @item @var{args}: cell : Arguments passed to f.@* +## @item @var{ctl} : 5-vec : (Optional) Control variables, described below +## @end itemize +## +## @subheading Returned values +## @itemize @bullet +## @item @var{x0} : matrix : Local minimum of f +## @item @var{v} : real : Value of f in x0 +## @item @var{nev} : 1 x 2 : Number of evaluations of f and of df +## @end itemize +## +## @subheading Control Variables +## @itemize @bullet +## @item @var{ctl}(1) : 1 or 2 : Select stopping criterion amongst : +## @item @var{ctl}(1)==0 : Default value +## @item @var{ctl}(1)==1 : Stopping criterion : Stop search when value doesn't +## improve, as tested by @math{ ctl(2) > Deltaf/max(|f(x)|,1) } +## where Deltaf is the decrease in f observed in the last iteration +## (each iteration consists R*C line searches). +## @item @var{ctl}(1)==2 : Stopping criterion : Stop search when updates are small, +## as tested by @math{ ctl(2) > max { dx(i)/max(|x(i)|,1) | i in 1..N }} +## where dx is the change in the x that occured in the last iteration. +## @item @var{ctl}(2) : Threshold used in stopping tests. Default=10*eps +## @item @var{ctl}(2)==0 : Default value +## @item @var{ctl}(3) : Position of the minimized argument in args Default=1 +## @item @var{ctl}(3)==0 : Default value +## @item @var{ctl}(4) : Maximum number of function evaluations Default=inf +## @item @var{ctl}(4)==0 : Default value +## @item @var{ctl}(5) : Type of optimization: +## @item @var{ctl}(5)==1 : "Fletcher-Reves" method +## @item @var{ctl}(5)==2 : "Polak-Ribiere" (Default) +## @item @var{ctl}(5)==3 : "Hestenes-Stiefel" method +## @end itemize +## +## @var{ctl} may have length smaller than 4. Default values will be used if ctl is +## not passed or if nan values are given. +## @subheading Example: +## +## function r=df( l ) b=[1;0;-1]; r = -( 2*l@{1@} - 2*b + rand(size(l{1}))); endfunction @* +## function r=ff( l ) b=[1;0;-1]; r = (l@{1@}-b)' * (l@{1@}-b); endfunction @* +## ll = @{ [10; 2; 3] @}; @* +## ctl(5) = 3; @* +## [x0,v,nev]=cg_min( "ff", "df", ll, ctl ) @* +## +## Comment: In general, BFGS method seems to be better performin in many cases but requires more computation per iteration +## @seealso{ bfgsmin, http://en.wikipedia.org/wiki/Nonlinear_conjugate_gradient } +## @end deftypefn + +## Author : Etienne Grossmann <et...@is...> +## Modified by: Levente Torok <Tor...@gm...> +## This software is distributed under the terms of the GPL + +function [x,v,nev] = cg_min (f, dfn, args, ctl) + +verbose = 0; + +crit = 1; # Default control variables +tol = 10*eps; +narg = 1; +maxev = inf; +method = 2; + +if nargin >= 4, # Read arguments + if !isnan (ctl(1)) && ctl(1) ~= 0, crit = ctl(1); end + if length (ctl)>=2 && !isnan (ctl(2)) && ctl(2) ~= 0, tol = ctl(2); end + if length (ctl)>=3 && !isnan (ctl(3)) && ctl(3) ~= 0, narg = ctl(3); end + if length (ctl)>=4 && !isnan (ctl(4)) && ctl(4) ~= 0, maxev = ctl(4); end + if length (ctl)>=5 && !isnan (ctl(5)) && ctl(5) ~= 0, method= ctl(5); end +end + +if iscell (args), # List of arguments + x = args{narg}; +else # Single argument + x = args; + args = {args}; +end + +if narg > length (args), # Check + error ("cg_min : narg==%i, length (args)==%i\n", + narg, length (args)); +end + +[R, C] = size(x); +N = R*C; +x = reshape (x,N,1) ; + +nev = [0, 0]; + +v = feval (f, args); +nev(1)++; + +dxn = lxn = dxn_1 = -feval( dfn, args ); +nev(2)++; + +done = 0; + +## TEMP +## tb = ts = zeros (1,100); + + # Control params for line search +ctlb = [10*sqrt(eps), narg, maxev]; +if crit == 2, ctlb(1) = tol; end + +x0 = x; +v0 = v; + +nline = 0; +while nev(1) <= maxev , + ## xprev = x ; + ctlb(3) = maxev - nev(1); # Update # of evals + + + ## wiki alg 4. + [alpha, vnew, nev0] = brent_line_min (f, dxn, args, ctlb); + + nev += nev0; + ## wiki alg 5. + x = x + alpha * dxn; + + if nline >= N, + if crit == 1, + done = tol > (v0 - vnew) / max (1, abs (v0)); + else + done = tol > norm ((x-x0)(:)); + end + nline = 1; + x0 = x; + v0 = vnew; + else + nline++; + end + if done || nev(1) >= maxev, return end + + if vnew > v + eps , + printf("cg_min: step increased cost function\n"); + keyboard + end + + # if abs(1-(x-xprev)'*dxn/norm(dxn)/norm(x-xprev))>1000*eps, + # printf("cg_min: step is not in the right direction\n"); + # keyboard + # end + + # update x at the narg'th position of args cellarray + args{narg} = reshape (x, R, C); + + v = feval (f, args); + nev(1)++; + + if verbose, printf("cg_min : nev=%4i, v=%8.3g\n",nev(1),v) ; end + + ## wiki alg 1: + dxn = -feval (dfn, args); + nev(2)++; + + # wiki alg 2: + switch method + + case 1 # Fletcher-Reenves method + nu = dxn' * dxn; + de = dxn_1' * dxn_1; + + case 2 # Polak-Ribiere method + nu = (dxn-dxn_1)' * dxn; + de = dxn_1' * dxn_1; + + case 3 # Hestenes-Stiefel method + nu = (dxn-dxn_1)' * dxn; + de = (dxn-dxn_1)' * lxn; + + otherwise + error("No method like this"); + + endswitch + + if nu == 0, + return + endif + + if de == 0, + error("Numerical instability!"); + endif + beta = nu / de; + beta = max( 0, beta ); + ## wiki alg 3. update dxn, lxn, point + dxn_1 = dxn; + dxn = lxn = dxn_1 + beta*lxn ; + +end + +if verbose, printf ("cg_min: Too many evaluatiosn!\n"); end + +endfunction + Added: trunk/octave-forge/main/optim/inst/cg_min_example_1.m =================================================================== --- trunk/octave-forge/main/optim/inst/cg_min_example_1.m (rev 0) +++ trunk/octave-forge/main/optim/inst/cg_min_example_1.m 2009-03-24 17:14:47 UTC (rev 5635) @@ -0,0 +1,83 @@ +## ok = test_conjgrad_min - Test that conjgrad_min works +## +## Defines some simple functions and verifies that calling +## +## conjgrad_min on them returns the correct minimum. +## +## Sets 'ok' to 1 if success, 0 otherwise + +## The name of the optimizing function + + +optim_func = "cg_min"; + +ok = 1; + +if ! exist ("verbose"), verbose = 0; end + +if 0, + P = 10+floor(30*rand(1)) ; # Nparams + R = P+floor(30*rand(1)) ; # Nobses +else + P = 15; + R = 20; # must have R >= P +end + +noise = 0 ; +global obsmat ; +obsmat = randn(R,P) ; +global truep ; +truep = randn(P,1) ; +xinit = randn(P,1) ; + +global obses ; +obses = obsmat*truep ; +if noise, obses = adnois(obses,noise); end + +function s = msq(x) + try + s = mean(x(find(!isnan(x))).^2); + catch + s = nan; + end +endfunction + +function v = ff(x) + global obsmat; + global obses; + v = msq( obses - obsmat*x{1} ) + 1 ; +endfunction + + +function dv = dff(x) + global obsmat; + global obses; + er = -obses + obsmat*x{1} ; + dv = 2*er'*obsmat / rows(obses) ; + dv = dv'; + ## dv = 2*er'*obsmat ; +endfunction + +printf("gonna test : %s\n",optim_func); +if verbose, + printf ("Nparams = P = %i, Nobses = R = %i\n",P,R); +end + + +tic; +[xlev,vlev,nlev] = feval(optim_func, "ff", "dff", xinit) ; +toc; + + +if max (abs(xlev-truep)) > 100*sqrt (eps), + if verbose, + printf ("Error is too big : %8.3g\n", max (abs (xlev-truep))); + end + ok = 0; +end +if verbose, + printf (" Costs : init=%8.3g, final=%8.3g, best=%8.3g\n",\ + ff(xinit), vlev, ff(truep)); +end +if (ok) printf("All tests ok\n"); endif + Added: trunk/octave-forge/main/optim/inst/cg_min_example_2.m =================================================================== --- trunk/octave-forge/main/optim/inst/cg_min_example_2.m (rev 0) +++ trunk/octave-forge/main/optim/inst/cg_min_example_2.m 2009-03-24 17:14:47 UTC (rev 5635) @@ -0,0 +1,57 @@ + + +## +## Test conjgrad_min +optim_func = "cg_min"; +printf("gonna test : %s\n",optim_func); + + +N = 1+floor(30*rand(1)) ; +global truemin ; +truemin = randn(N,1) ; +global offset ; +offset = 100*randn(1) ; +global metric ; +metric = randn(2*N,N) ; +metric = metric'*metric ; + +if N>1, + [u,d,v] = svd(metric); + d = (0.1+[0:(1/(N-1)):1]).^2 ; + metric = u*diag(d)*u' ; +end + +function v = testfunc(x) + global offset ; + global truemin ; + global metric ; + v = sum((x{1}-truemin)'*metric*(x{1}-truemin)) + offset ; +end + +function df = dtestf(x) + global truemin ; + global metric ; + df = metric' * 2*(x{1}-truemin); +end + +xinit = 10*randn(N,1); + +[x,v,niter] = feval(optim_func, "testfunc","dtestf", xinit) ; +## [x,v,niter] = conjgrad_min("testfunc","dtestf",xinit) ; +printf("test_conjgrad_min\n"); + +if any(abs( x-truemin ) > 100*sqrt(eps) ) , + printf("NOT OK 1\n"); +else + printf("OK 1\n"); +end + +if v-offset > 1e-8 , + printf("NOT OK 2\n"); +else + printf("OK 2\n"); +end + +printf("nev=%d N=%d errx=%8.3g errv=%8.3g\n",... + niter(1),N,max(abs( x-truemin )),v-offset); + Added: trunk/octave-forge/main/optim/inst/cg_min_example_3.m =================================================================== --- trunk/octave-forge/main/optim/inst/cg_min_example_3.m (rev 0) +++ trunk/octave-forge/main/optim/inst/cg_min_example_3.m 2009-03-24 17:14:47 UTC (rev 5635) @@ -0,0 +1,110 @@ + +## ok = test_conjgrad_min - Test that conjgrad_min works with extra +## arguments +## +## Defines some simple functions and verifies that calling +## +## conjgrad_min on them returns the correct minimum. +## +## Sets 'ok' to 1 if success, 0 otherwise + +## The name of the optimizing function +optim_func = "cg_min"; + +ok = 1; +verbose = true; + +if ! exist ("verbose"), verbose = 0; end + +if 0, + P = 10+floor(30*rand(1)) ; # Nparams + R = P+floor(30*rand(1)) ; # Nobses +else + P = 2; + R = 3; +end + +noise = 0 ; +obsmat = randn(R,P) ; + +truep = randn(P,1) ; +xinit = randn(P,1) ; + +global obses ; +obses = obsmat*truep ; + +function [v,stddev] = addnoise(u,db) + + if ! isfinite (db), v = u; stddev = 0; return; end + + if prod(size(u)) == 0, + error("adnois called with void signal"); + end + n = randn(size(u)); + + dbn = 1; + + ## dbu = cov(u(:)); + dbu = msq( u(:) ) - mean( u(find(!isnan(u(:)))) )^2 ; + + stddev = 10^(-db/20)*sqrt(dbu) ; + + v = u+n*stddev; + % noislev(u,v) +endfunction + +if noise, obses = addnoise(obses,noise); end + +extra = list (obsmat, obses); + +function v = ff( xx ) + x = xx{1}; + obsmat = xx{2}; + obses = xx{3}; + v = msq( obses - obsmat*x ) + 1 ; +endfunction + + +function dv = dff( xx ) + x = xx{1}; + obsmat = xx{2}; + obses = xx{3}; + er = -obses + obsmat*x ; + dv = 2*er'*obsmat / rows(obses) ; + dv = dv'; + ## dv = 2*er'*obsmat ; +endfunction + + +printf( "gonna test : %s\n",optim_func); +if verbose, + printf ("Nparams = P = %i, Nobses = R = %i\n",P,R); +end + + +tic; +## [xlev,vlev,nlev] = feval (optim_func, "ff", "dff", xinit, "extra", extra) ; +x = {xinit, obsmat, obses}; +[xlev,vlev,nlev] = feval \ + (optim_func, "ff", "dff", x); +toc; + + +if max (abs(xlev-truep)) > 100*sqrt (eps), + if verbose, + printf ("Error is too big : %8.3g\n", max (abs (xlev-truep))); + end + ok = 0; +end + +if verbose, + xinit_ = {xinit,obsmat,obses}; + xtrue_ = {truep,obsmat,obses}; + printf (" Costs : init=%8.3g, final=%8.3g, best=%8.3g\n",\ + ff(xinit_), vlev, ff(xtrue_)); +end + +if (ok) + printf("All tests ok\n"); +endif + This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ad...@us...> - 2009-05-18 20:18:19
|
Revision: 5848 http://octave.svn.sourceforge.net/octave/?rev=5848&view=rev Author: adb014 Date: 2009-05-18 20:18:10 +0000 (Mon, 18 May 2009) Log Message: ----------- explicit inclusion of lo-ieee.h is needed in 3.1.x Modified Paths: -------------- trunk/octave-forge/main/optim/DESCRIPTION trunk/octave-forge/main/optim/src/__bfgsmin.cc Modified: trunk/octave-forge/main/optim/DESCRIPTION =================================================================== --- trunk/octave-forge/main/optim/DESCRIPTION 2009-05-18 20:13:16 UTC (rev 5847) +++ trunk/octave-forge/main/optim/DESCRIPTION 2009-05-18 20:18:10 UTC (rev 5848) @@ -1,6 +1,6 @@ Name: Optim -Version: 1.0.5 -Date: 2008-08-23 +Version: 1.0.6 +Date: 2009-05-18 Author: Various Authors Maintainer: The Octave Community Title: Optimzation. Modified: trunk/octave-forge/main/optim/src/__bfgsmin.cc =================================================================== --- trunk/octave-forge/main/optim/src/__bfgsmin.cc 2009-05-18 20:13:16 UTC (rev 5847) +++ trunk/octave-forge/main/optim/src/__bfgsmin.cc 2009-05-18 20:18:10 UTC (rev 5848) @@ -26,6 +26,7 @@ #include <oct.h> #include <octave/parse.h> #include <octave/Cell.h> +#include <octave/lo-ieee.h> #include <float.h> #include "error.h" This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <hi...@us...> - 2009-06-18 06:11:25
|
Revision: 5965 http://octave.svn.sourceforge.net/octave/?rev=5965&view=rev Author: highegg Date: 2009-06-18 06:11:14 +0000 (Thu, 18 Jun 2009) Log Message: ----------- update test Modified Paths: -------------- trunk/octave-forge/main/optim/inst/test_fminunc_1.m trunk/octave-forge/main/optim/src/__bfgsmin.cc Modified: trunk/octave-forge/main/optim/inst/test_fminunc_1.m =================================================================== --- trunk/octave-forge/main/optim/inst/test_fminunc_1.m 2009-06-18 06:08:52 UTC (rev 5964) +++ trunk/octave-forge/main/optim/inst/test_fminunc_1.m 2009-06-18 06:11:14 UTC (rev 5965) @@ -10,9 +10,9 @@ ## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ## for more details. -## test_fminunc_1 - Test that fminunc and optimset work +## test_fminunc_compat_1 - Test that fminunc_compat and optimset work ## -## A quadratic function is fminuncd. Various options are tested. Options +## A quadratic function is fminunc_compatd. Various options are tested. Options ## are passed incomplete (to see if properly completed) and ## case-insensitive. @@ -54,7 +54,7 @@ if verbose - prn ("\n Testing that fminunc() works as it should\n\n"); + prn ("\n Testing that fminunc_compat() works as it should\n\n"); prn (" Nparams = N = %i\n",N); fflush (stdout); end @@ -62,7 +62,7 @@ ## Plain run, just to make sure ###################################### ## Minimum wrt 'x' is y0 opt = optimset (); -[xlev,vlev] = fminunc ("ff",x0,opt,y0,1); +[xlev,vlev] = fminunc_compat ("ff",x0,opt,y0,1); cnt++; if max (abs (xlev-y0)) > 100*sqrt (eps) @@ -75,7 +75,7 @@ ## See what 'backend' gives in that last case ######################## opt = optimset ("backend","on"); -[method,ctl] = fminunc ("ff",x0, opt, y0,1); +[method,ctl] = fminunc_compat ("ff",x0, opt, y0,1); cnt++; if ! ischar (method) || ! strcmp (method,"nelder_mead_min") @@ -83,7 +83,7 @@ if ischar (method) prn ("Wrong method '%s' != 'nelder_mead_min' was chosen\n", method); else - prn ("fminunc pretends to use a method that isn't a string\n"); + prn ("fminunc_compat pretends to use a method that isn't a string\n"); end return end @@ -108,7 +108,7 @@ ## Minimum wrt 'x' is y0 opt = optimset ("GradO","on"); -[xlev,vlev,nlev] = fminunc ("d2ff",x0,opt,y0,1); +[xlev,vlev,nlev] = fminunc_compat ("d2ff",x0,opt,y0,1); cnt++; if max (abs (xlev-y0)) > 100*sqrt (eps) @@ -123,7 +123,7 @@ ## Use the 'hess' option, when f can return 2nd differential ######### ## Minimum wrt 'x' is y0 opt = optimset ("hessian","on"); -[xlev,vlev,nlev] = fminunc ("d2ff",x0,opt,y0,1); +[xlev,vlev,nlev] = fminunc_compat ("d2ff",x0,opt,y0,1); cnt++; if max (abs (xlev-y0)) > 100*sqrt (eps) Modified: trunk/octave-forge/main/optim/src/__bfgsmin.cc =================================================================== --- trunk/octave-forge/main/optim/src/__bfgsmin.cc 2009-06-18 06:08:52 UTC (rev 5964) +++ trunk/octave-forge/main/optim/src/__bfgsmin.cc 2009-06-18 06:11:14 UTC (rev 5965) @@ -29,7 +29,10 @@ #include <octave/lo-ieee.h> #include <float.h> #include "error.h" +#include "lo-ieee.h" +#include <iostream> + // the compares two octave_values (thanks to jwe) bool isequal (const octave_value& a, const octave_value& b, bool nans_compare_equal = false) @@ -79,7 +82,9 @@ int success = 1; f_args_new = f_args; f_args_new(minarg - 1) = theta; + std::cerr << "here\n"; f_return = _feval(f, f_args_new); + std::cerr << "here\n"; obj = f_return(0).double_value(); // bullet-proof the objective function if (error_state) { @@ -305,6 +310,7 @@ Matrix H, H1, H2; ColumnVector thetain, d, g, g_new, p, q, sig, gam; + return f_return; // controls Cell control (args(2).cell_value()); max_iters = control(0).int_value(); @@ -323,7 +329,7 @@ // copy cell contents over to octave_value_list to use _feval() k = f_args_cell.length(); - if (k) f_args(k-1); // resize only once + f_args(k); // resize only once for (i = 0; i<k; i++) f_args(i) = f_args_cell(i); // get the minimization argument @@ -343,6 +349,8 @@ thetain = theta; H = identity_matrix(k,k); + std::cerr << "here\n"; + return f_return; // Initial obj_value __bfgsmin_obj(obj_in, f, f_args, theta, minarg); if (warnings) printf("initial obj_value %g\n", obj_in); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <sla...@us...> - 2009-07-22 14:18:35
|
Revision: 6039 http://octave.svn.sourceforge.net/octave/?rev=6039&view=rev Author: slackydeb Date: 2009-07-22 14:18:32 +0000 (Wed, 22 Jul 2009) Log Message: ----------- Bump package version. linprog.m * API break: don't let nargin == 6 * API break: f, lb, ub and x must be column vectors * clean doc * add comments * improve the feeback given to users if arguments have wrong dimensions * improve tests readibility * test both output values (and not only the first one) * bump version Modified Paths: -------------- trunk/octave-forge/main/optim/DESCRIPTION trunk/octave-forge/main/optim/inst/linprog.m Modified: trunk/octave-forge/main/optim/DESCRIPTION =================================================================== --- trunk/octave-forge/main/optim/DESCRIPTION 2009-07-22 10:43:16 UTC (rev 6038) +++ trunk/octave-forge/main/optim/DESCRIPTION 2009-07-22 14:18:32 UTC (rev 6039) @@ -1,6 +1,6 @@ Name: Optim -Version: 1.0.6 -Date: 2009-05-18 +Version: 1.0.7 +Date: 2009-07-22 Author: Various Authors Maintainer: The Octave Community Title: Optimzation. Modified: trunk/octave-forge/main/optim/inst/linprog.m =================================================================== --- trunk/octave-forge/main/optim/inst/linprog.m 2009-07-22 10:43:16 UTC (rev 6038) +++ trunk/octave-forge/main/optim/inst/linprog.m 2009-07-22 14:18:32 UTC (rev 6039) @@ -16,92 +16,131 @@ ## -*- texinfo -*- ## @deftypefn{Function File} {@var{x} =} linprog (@var{f}, @var{A}, @var{b}) ## @deftypefnx{Function File} {@var{x} =} linprog (@var{f}, @var{A}, @var{b}, @var{Aeq}, @var{beq}) -## @deftypefnx{Function File} {@var{x} =} linprog (@var{f}, @var{A}, @var{b}, @var{Aeq}, @var{beq}, @var{LB}) -## @deftypefnx{Function File} {@var{x} =} linprog (@var{f}, @var{A}, @var{b}, @var{Aeq}, @var{beq}, @var{LB}, @var{UB}) +## @deftypefnx{Function File} {@var{x} =} linprog (@var{f}, @var{A}, @var{b}, @var{Aeq}, @var{beq}, @var{lb}, @var{ub}) ## @deftypefnx{Function File} {[@var{x}, @var{fval}] =} linprog (@dots{}) -## Solve a linear problem. @code{linprog} solves the following LP: +## Solve a linear problem. ## +## Finds +## ## @example -## min f'*x +## min (f' * x) ## @end example ## -## subject to +## (both f and x are column vectors) subject to ## ## @example ## @group -## A*x <= b -## Aeq*x = beq -## x >= LB -## x <= UB +## A * x <= b +## Aeq * x = beq +## lb <= x <= ub ## @end group ## @end example ## -## The default @var{Aeq} and @var{beq} are assumed to be empty matrices. +## If not specified, @var{Aeq} and @var{beq} default to empty matrices. ## -## The default lower bound @var{LB} is assumed to be minus infinite; the -## default upper bound @var{UB} is assumed to be infinite. +## If not specified, the lower bound @var{lb} defaults to minus infinite +## and the upper bound @var{ub} defaults to infinite. ## ## @seealso{glpk} ## @end deftypefn ## Author: Luca Favatella <sla...@gm...> -## Version: 0.3.1 +## Version: 0.4 # TODO: write a test using not null and # not zero Aeq and beq function [x fval] = linprog (f, A, b, Aeq = [], beq = [], - LB = [], UB = []) + lb = [], ub = []) - if ((nargin < 3) || (nargin == 4) || (nargin > 7) || - (nargout > 2) || - (! isvector (f))) + nr_f = rows(f); + nr_A = rows (A); + + if (((nargin != 3) && (nargin != 5) && (nargin != 7)) || + (nargout > 2)) print_usage (); + elseif (columns (f) != 1) + error ("f must be a column vector"); + elseif (columns (A) != nr_f) + error ("columns (A) != rows (f)"); + elseif (size (b) != [nr_A 1]) + error ("size (b) != [(rows (A)) 1]"); else - l_f = length(f); - nr_A = rows (A); - nr_Aeq = rows (Aeq); - + ## Sanitize Aeq if (isempty (Aeq)) - Aeq = zeros (0, l_f); + Aeq = zeros (0, nr_f); endif + if (columns (Aeq) != nr_f) + error ("columns (Aeq) != rows (f)"); + endif + + ## Sanitize beq if (isempty (beq)) beq = zeros (0, 1); endif + nr_Aeq = rows (Aeq); + if (size (beq) != [nr_Aeq 1]) + error ("size (beq) != [(rows (Aeq)) 1]"); + endif - if (isempty (LB)) - LB = - inf (1, l_f); + ## Sanitize lb + if (isempty (lb)) + LB = - Inf (nr_f, 1); endif - if (isempty (UB)) - UB = inf (1, l_f); + if (size (lb) != [nr_f 1]) + error ("size (lb) != [(rows (f)) 1]"); endif + ## Sanitize ub + if (isempty (ub)) + UB = Inf (nr_f, 1); + endif + if (size (ub) != [nr_f 1]) + error ("size (ub) != [(rows (f)) 1]"); + endif + + + ## Call glpk ctype = [(repmat ("U", nr_A, 1)); (repmat ("S", nr_Aeq, 1))]; - [x fval] = glpk (f(1:l_f), - [A(1:nr_A, 1:l_f); Aeq(1:nr_Aeq, 1:l_f)], - [b(1:nr_A, 1); beq(1:nr_Aeq, 1)], - LB(1:l_f), - UB(1:l_f), - ctype); + [x(1:nr_f, 1) fval(1, 1)] = glpk (f, [A; Aeq], [b; beq], lb, ub, ctype); endif endfunction -%!shared f, A, b, LB, expected -%! f = [21 25 31 34 23 19 32 36 27 25 19]; -%! A1 = [1 0 0 0 1 0 0 1 0 0 0; 0 1 0 0 0 1 0 0 1 0 0; 0 0 1 0 0 0 0 0 0 1 0; 0 0 0 1 0 0 1 0 0 0 1]; -%! A2 = [1 1 1 1 0 0 0 0 0 0 0; 0 0 0 0 1 1 1 0 0 0 0; 0 0 0 0 0 0 0 1 1 1 1]; -%! A = [-A1; A2]; +%!shared f, A, b, lb, ub, x_exp, fval_exp +%! f = [21 25 31 34 23 19 32 36 27 25 19]'; +%! +%! A1 = [ 1 0 0 0 1 0 0 1 0 0 0; +%! 0 1 0 0 0 1 0 0 1 0 0; +%! 0 0 1 0 0 0 0 0 0 1 0; +%! 0 0 0 1 0 0 1 0 0 0 1]; +%! A2 = [ 1 1 1 1 0 0 0 0 0 0 0; +%! 0 0 0 0 1 1 1 0 0 0 0; +%! 0 0 0 0 0 0 0 1 1 1 1]; +%! A = [-A1; A2]; +%! %! b1 = [40; 50; 50; 70]; %! b2 = [100; 60; 50]; -%! b = [-b1; b2]; -%! LB = zeros (1, 11); -%! expected = [40; 0; 50; 10; 0; 50; 10; 0; 0; 0; 50]; +%! b = [-b1; b2]; %! -%!assert (linprog (f, A, b, [], [], LB), expected); -%!assert (linprog (f, A, b, zeros (1, 11), 0, LB), expected); \ No newline at end of file +%! lb = zeros (rows (f), 1); +%! ub = Inf (rows (f), 1); +%! +%! x_exp = [40 0 50 10 0 50 10 0 0 0 50]'; +%! fval_exp = f' * x_exp; +%! +%!test +%! Aeq = []; +%! beq = []; +%! [x_obs fval_obs] = linprog (f, A, b, Aeq, beq, lb, ub); +%! assert ([x_obs; fval_obs], [x_exp; fval_exp]); +%! +%!test +%! Aeq = zeros (1, rows (f)); +%! beq = 0; +%! assert(linprog (f, A, b, Aeq, beq, lb, ub), x_exp); \ No newline at end of file This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <sla...@us...> - 2009-09-21 14:57:22
|
Revision: 6256 http://octave.svn.sourceforge.net/octave/?rev=6256&view=rev Author: slackydeb Date: 2009-09-21 14:57:12 +0000 (Mon, 21 Sep 2009) Log Message: ----------- linprog.m: compatibility fix (thanks to Adrian Burlacu for the report) * let empty A and/or b of whatever dimensions as user input, sanitizing them inside the function * add a test case for the above fix See also http://sourceforge.net/mailarchive/forum.php?thread_name=684314.52352.qm%40web110015.mail.gq1.yahoo.com&forum_name=octave-dev Bump package version. Modified Paths: -------------- trunk/octave-forge/main/optim/DESCRIPTION trunk/octave-forge/main/optim/inst/linprog.m Modified: trunk/octave-forge/main/optim/DESCRIPTION =================================================================== --- trunk/octave-forge/main/optim/DESCRIPTION 2009-09-20 12:04:30 UTC (rev 6255) +++ trunk/octave-forge/main/optim/DESCRIPTION 2009-09-21 14:57:12 UTC (rev 6256) @@ -1,6 +1,6 @@ Name: Optim -Version: 1.0.7 -Date: 2009-07-22 +Version: 1.0.8 +Date: 2009-09-21 Author: Various Authors Maintainer: The Octave Community Title: Optimzation. Modified: trunk/octave-forge/main/optim/inst/linprog.m =================================================================== --- trunk/octave-forge/main/optim/inst/linprog.m 2009-09-20 12:04:30 UTC (rev 6255) +++ trunk/octave-forge/main/optim/inst/linprog.m 2009-09-21 14:57:12 UTC (rev 6256) @@ -45,22 +45,28 @@ ## @end deftypefn ## Author: Luca Favatella <sla...@gm...> -## Version: 0.4 +## Version: 0.5 - # TODO: write a test using not null and - # not zero Aeq and beq - function [x fval] = linprog (f, A, b, Aeq = [], beq = [], lb = [], ub = []) + if (((nargin != 3) && (nargin != 5) && (nargin != 7)) || + (nargout > 2)) + print_usage (); + endif + nr_f = rows(f); + + # Sanitize A and b + if (isempty (A) && isempty (b)) + A = zeros (0, nr_f); + b = zeros (rows (A), 1); + endif + nr_A = rows (A); - if (((nargin != 3) && (nargin != 5) && (nargin != 7)) || - (nargout > 2)) - print_usage (); - elseif (columns (f) != 1) + if (columns (f) != 1) error ("f must be a column vector"); elseif (columns (A) != nr_f) error ("columns (A) != rows (f)"); @@ -112,6 +118,18 @@ endfunction +%!test +%! f = [1; -1]; +%! A = []; +%! b = []; +%! Aeq = [1, 0]; +%! beq = [2]; +%! lb = [0; Inf]; +%! ub = [-Inf; 0]; +%! x_exp = [2; 0]; +%! assert (linprog (f, A, b, Aeq, beq, lb, ub), x_exp); + + %!shared f, A, b, lb, ub, x_exp, fval_exp %! f = [21 25 31 34 23 19 32 36 27 25 19]'; %! @@ -143,4 +161,4 @@ %!test %! Aeq = zeros (1, rows (f)); %! beq = 0; -%! assert(linprog (f, A, b, Aeq, beq, lb, ub), x_exp); \ No newline at end of file +%! assert (linprog (f, A, b, Aeq, beq, lb, ub), x_exp); \ No newline at end of file This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <sf...@us...> - 2009-09-22 19:16:43
|
Revision: 6261 http://octave.svn.sourceforge.net/octave/?rev=6261&view=rev Author: sffisch Date: 2009-09-22 19:16:33 +0000 (Tue, 22 Sep 2009) Log Message: ----------- de_min added Modified Paths: -------------- trunk/octave-forge/main/optim/INDEX Added Paths: ----------- trunk/octave-forge/main/optim/inst/de_min.m Modified: trunk/octave-forge/main/optim/INDEX =================================================================== --- trunk/octave-forge/main/optim/INDEX 2009-09-22 16:32:33 UTC (rev 6260) +++ trunk/octave-forge/main/optim/INDEX 2009-09-22 19:16:33 UTC (rev 6261) @@ -10,6 +10,7 @@ bfgsmin samin battery fminsearch cg_min + de_min Data fitting expfit expdemo wpolyfit wpolyfitdemo Added: trunk/octave-forge/main/optim/inst/de_min.m =================================================================== --- trunk/octave-forge/main/optim/inst/de_min.m (rev 0) +++ trunk/octave-forge/main/optim/inst/de_min.m 2009-09-22 19:16:33 UTC (rev 6261) @@ -0,0 +1,468 @@ +## Copyright (C) 2009 Christian Fischer <fi...@it...> +## Copyright (C) 1996, 1997 R. Storn +## +## This program is free software; you can redistribute it and/or modify +## it under the terms of the GNU General Public License as published by +## the Free Software Foundation; either version 3 of the License, or +## (at your option) any later version. +## +## This program is distributed in the hope that it will be useful, +## but WITHOUT ANY WARRANTY; without even the implied warranty of +## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +## GNU General Public License for more details. +## +## You should have received a copy of the GNU General Public +## License along with Octave; see the file COPYING. If not, +## see <http://www.gnu.org/licenses/>. +## +## Changelog: +## + +## de_min: global optimisation using differential evolution +## +## Usage: [x, obj_value, nfeval, convergence] = de_min(fcn, control) +## +## minimization of a user-supplied function with respect to x(1:D), +## using the differential evolution (DE) method based on an algorithm +## by Rainer Storn (http://www.icsi.berkeley.edu/~storn/code.html) +## +## +## Arguments: +## --------------- +## fcn string : Name of function. Must return a real value +## control vector : (Optional) Control variables, described below +## or struct +## +## Returned values: +## ---------------- +## x vector : parameter vector of best solution +## obj_value scalar : objective function value of best solution +## nfeval scalar : number of function evaluations +## convergence : 1 = best below value to reach (VTR) +## 0 = population has reached defined quality (tol) +## -1 = some values are close to constraints/boundaries +## -2 = max number of iterations reached (maxiter) +## -3 = max number of functions evaluations reached (maxnfe) +## +## Control variable: (optional) may be named arguments (i.e. "name",value +## ---------------- pairs), a struct, or a vector, where +## NaN's are ignored. +## +## XVmin : vector of lower bounds of initial population +## *** note: by default these are no constraints *** +## XVmax : vector of upper bounds of initial population +## constr : 1 -> enforce the bounds not just for the initial population +## const : data vector (remains fixed during the minimization) +## NP : number of population members +## F : difference factor from interval [0, 2] +## CR : crossover probability constant from interval [0, 1] +## strategy : 1 --> DE/best/1/exp 7 --> DE/best/1/bin +## 2 --> DE/rand/1/exp 8 --> DE/rand/1/bin +## 3 --> DE/target-to-best/1/exp 9 --> DE/target-to-best/1/bin +## 4 --> DE/best/2/exp 10--> DE/best/2/bin +## 5 --> DE/rand/2/exp 11--> DE/rand/2/bin +## 6 --> DEGL/SAW/exp else DEGL/SAW/bin +## refresh : intermediate output will be produced after "refresh" +## iterations. No intermediate output will be produced +## if refresh is < 1 +## VTR : Stopping criterion: "Value To Reach" +## de_min will stop when obj_value <= VTR. +## Use this if you know which value you expect. +## tol : Stopping criterion: "tolerance" +## stops if (best-worst)/max(1,worst) < tol +## This stops basically if the whole population is "good". +## maxnfe : maximum number of function evaluations +## maxiter : maximum number of iterations (generations) +## +## The algorithm seems to work well only if [XVmin,XVmax] covers the +## region where the global minimum is expected. +## DE is also somewhat sensitive to the choice of the +## difference factor F. A good initial guess is to choose F from +## interval [0.5, 1], e.g. 0.8. +## CR, the crossover probability constant from interval [0, 1] +## helps to maintain the diversity of the population and is +## rather uncritical but affects strongly the convergence speed. +## If the parameters are correlated, high values of CR work better. +## The reverse is true for no correlation. +## Experiments suggest that /bin likes to have a slightly +## larger CR than /exp. +## The number of population members NP is also not very critical. A +## good initial guess is 10*D. Depending on the difficulty of the +## problem NP can be lower than 10*D or must be higher than 10*D +## to achieve convergence. +## +## Default Values: +## --------------- +## XVmin = [-2]; +## XVmax = [ 2]; +## constr= 0; +## const = []; +## NP = 10 *D +## F = 0.8; +## CR = 0.9; +## strategy = 12; +## refresh = 0; +## VTR = -Inf; +## tol = 1.e-3; +## maxnfe = 1e6; +## maxiter = 1000; +## +## +## Example to find the minimum of the Rosenbrock saddle: +## ---------------------------------------------------- +## Define f as: +## function result = f(x); +## result = 100 * (x(2) - x(1)^2)^2 + (1 - x(1))^2; +## end +## Then type: +## +## ctl.XVmin = [-2 -2]; +## ctl.XVmax = [ 2 2]; +## [x, obj_value, nfeval, convergence] = de_min (@f, ctl); +## +## Author : Christian Fischer <fi...@it...> +## Keywords: global-optimisation optimisation minimisation + +function [bestmem, bestval, nfeval, convergence] = de_min(fcn, varargin) + +## Default options +XVmin = [-2 ]; +XVmax = [ 2 ]; +constr= 0; +const = []; +NP = 0; # NP will be set later +F = 0.8; +CR = 0.9; +strategy = 12; +refresh = 0; +VTR = -Inf; +tol = 1.e-3; +maxnfe = 1e6; +maxiter = 1000; + +## ------------ Check input variables (ctl) -------------------------------- +if nargin >= 2, # Read control arguments + va_arg_cnt = 1; + if nargin > 2, + ctl = struct (varargin{:}); + else + ctl = nth (varargin, va_arg_cnt++); + end + if isnumeric (ctl) + if length (ctl)>=1 && !isnan (ctl(1)), XVmin = ctl(1); end + if length (ctl)>=2 && !isnan (ctl(2)), XVmax = ctl(2); end + if length (ctl)>=3 && !isnan (ctl(3)), constr = ctl(3); end + if length (ctl)>=4 && !isnan (ctl(4)), const = ctl(4); end + if length (ctl)>=5 && !isnan (ctl(5)), NP = ctl(5); end + if length (ctl)>=6 && !isnan (ctl(6)), F = ctl(6); end + if length (ctl)>=7 && !isnan (ctl(7)), CR = ctl(7); end + if length (ctl)>=8 && !isnan (ctl(8)), strategy = ctl(8); end + if length (ctl)>=9 && !isnan (ctl(9)), refresh = ctl(9); end + if length (ctl)>=10&& !isnan (ctl(10)), VTR = ctl(10); end + if length (ctl)>=11&& !isnan (ctl(11)), tol = ctl(11); end + if length (ctl)>=12&& !isnan (ctl(12)), maxnfe = ctl(12); end + if length (ctl)>=13&& !isnan (ctl(13)), maxiter = ctl(13); end + else + if isfield (ctl,"XVmin") && !isnan (ctl.XVmin), XVmin=ctl.XVmin; end + if isfield (ctl,"XVmax") && !isnan (ctl.XVmax), XVmax=ctl.XVmax; end + if isfield (ctl,"constr")&& !isnan (ctl.constr), constr=ctl.constr; end + if isfield (ctl,"const") && !isnan (ctl.const), const=ctl.const; end + if isfield (ctl, "NP" ) && ! isnan (ctl.NP ), NP = ctl.NP ; end + if isfield (ctl, "F" ) && ! isnan (ctl.F ), F = ctl.F ; end + if isfield (ctl, "CR" ) && ! isnan (ctl.CR ), CR = ctl.CR ; end + if isfield (ctl, "strategy") && ! isnan (ctl.strategy), + strategy = ctl.strategy ; end + if isfield (ctl, "refresh") && ! isnan (ctl.refresh), + refresh = ctl.refresh ; end + if isfield (ctl, "VTR") && ! isnan (ctl.VTR ), VTR = ctl.VTR ; end + if isfield (ctl, "tol") && ! isnan (ctl.tol ), tol = ctl.tol ; end + if isfield (ctl, "maxnfe") && ! isnan (ctl.maxnfe) + maxnfe = ctl.maxnfe; + end + if isfield (ctl, "maxiter") && ! isnan (ctl.maxiter) + maxiter = ctl.maxiter; + end + end +end + +## set dimension D and population size NP +D = length (XVmin); +if (NP == 0); + NP = 10 * D; +end + +## -------- do a few sanity checks -------------------------------- +if (length (XVmin) != length (XVmax)) + error("Length of upper and lower bounds does not match.") +end +if (NP < 5) + error("Population size NP must be bigger than 5.") +end +if ((F <= 0) | (F > 2)) + error("Difference Factor F out of range (0,2].") +end +if ((CR < 0) | (CR > 1)) + error("CR value out of range [0,1].") +end +if (maxiter <= 0) + error("maxiter must be positive.") +end +if (maxnfe <= 0) + error("maxiter must be positive.") +end +refresh = floor(abs(refresh)); + +## ----- Initialize population and some arrays -------------------------- + +pop = zeros(NP,D); # initialize pop + +## pop is a matrix of size NPxD. It will be initialized with +## random values between the min and max values of the parameters +for i = 1:NP + pop(i,:) = XVmin + rand (1,D) .* (XVmax - XVmin); +end + +## initialise the weighting factors between 0.0 and 1.0 +w = rand (NP,1); +wi = w; + +popold = zeros (size (pop)); # toggle population +val = zeros (1, NP); # create and reset the "cost array" +bestmem = zeros (1, D); # best population member ever +bestmemit = zeros (1 ,D); # best population member in iteration +nfeval = 0; # number of function evaluations + +## ------ Evaluate the best member after initialization ------------------ + +ibest = 1; # start with first population member +val(1) = feval (fcn, [pop(ibest,:) const]); +bestval = val(1); # best objective function value so far +bestw = w(1); # weighting of best design so far +for i = 2:NP # check the remaining members + val(i) = feval (fcn, [pop(i,:) const]); + if (val(i) < bestval) # if member is better + ibest = i; # save its location + bestval = val(i); + bestw = w(i); + end +end +nfeval = nfeval + NP; +bestmemit = pop(ibest,:); # best member of current iteration +bestvalit = bestval; # best value of current iteration + +bestmem = bestmemit; # best member ever + +## ------ DE - Minimization --------------------------------------- +## popold is the population which has to compete. It is static +## through one iteration. pop is the newly emerging population. + +pm1 = zeros (NP, D); # initialize population matrix 1 +pm2 = zeros (NP, D); # initialize population matrix 2 +pm3 = zeros (NP, D); # initialize population matrix 3 +pm4 = zeros (NP, D); # initialize population matrix 4 +pm5 = zeros (NP, D); # initialize population matrix 5 +bm = zeros (NP, D); # initialize bestmember matrix +bm_n= zeros (NP, D); # initialize bestmember matrix in neighbourh. +ui = zeros (NP, D); # intermediate population of perturbed vectors +mui = zeros (NP, D); # mask for intermediate population +mpo = zeros (NP, D); # mask for old population +rot = 0:1:NP-1; # rotating index array (size NP) +rotd= 0:1:D-1; # rotating index array (size D) +rt = zeros (NP); # another rotating index array +rtd = zeros (D); # rotating index array for exponential crossover +a1 = zeros (NP); # index array +a2 = zeros (NP); # index array +a3 = zeros (NP); # index array +a4 = zeros (NP); # index array +a5 = zeros (NP); # index array +ind = zeros (4); + +iter = 1; +while ((iter < maxiter) & (nfeval < maxnfe) & (bestval > VTR) & ... + ((abs (max (val) - bestval) / max (1, abs (max (val))) > tol))) + popold = pop; # save the old population + wold = w; # save the old weighting factors + + ind = randperm (4); # index pointer array + + a1 = randperm (NP); # shuffle locations of vectors + rt = rem (rot + ind(1), NP); # rotate indices by ind(1) positions + a2 = a1(rt+1); # rotate vector locations + rt = rem (rot + ind(2), NP); + a3 = a2(rt+1); + rt = rem (rot +ind(3), NP); + a4 = a3(rt+1); + rt = rem (rot + ind(4), NP); + a5 = a4(rt+1); + + pm1 = popold(a1,:); # shuffled population 1 + pm2 = popold(a2,:); # shuffled population 2 + pm3 = popold(a3,:); # shuffled population 3 + pm4 = popold(a4,:); # shuffled population 4 + pm5 = popold(a5,:); # shuffled population 5 + w1 = wold(a4); # shuffled weightings 1 + w2 = wold(a5); # shuffled weightings 2 + + bm = repmat (bestmemit, NP, 1); # population filled with the best member + # of the last iteration + bw = repmat(bestw, NP, 1); # the same for the weighting of the best + + mui = rand (NP, D) < CR; # all random numbers < CR are 1, 0 otherwise + + if (strategy > 6) + st = strategy - 6; # binomial crossover + else + st = strategy; # exponential crossover + mui = sort (mui'); # transpose, collect 1's in each column + for i = 1:NP + n = floor (rand * D); + if (n > 0) + rtd = rem (rotd + n, D); + mui(:,i) = mui(rtd+1,i); #rotate column i by n + endif + endfor + mui = mui'; # transpose back + endif + mpo = mui < 0.5; # inverse mask to mui + + if (st == 1) # DE/best/1 + ui = bm + F*(pm1 - pm2); # differential variation + elseif (st == 2) # DE/rand/1 + ui = pm3 + F*(pm1 - pm2); # differential variation + elseif (st == 3) # DE/target-to-best/1 + ui = popold + F*(bm-popold) + F*(pm1 - pm2); + elseif (st == 4) # DE/best/2 + ui = bm + F*(pm1 - pm2 + pm3 - pm4); # differential variation + elseif (st == 5) # DE/rand/2 + ui = pm5 + F*(pm1 - pm2 + pm3 - pm4); # differential variation + else # DEGL/SAW + ## The DEGL/SAW method is more complicated. + ## We have to generate a neighbourhood first. + ## The neighbourhood size is 10% of NP and at least 3. + nr = max (1, floor ((0.1*NP -1)/2)); # neighbourhood radius + ## FIXME: I don't know how to vectorise this. - if possible + for i = 1:NP + neigh_ind = i-nr:i+nr; # index range of neighbourhood + neigh_ind = neigh_ind + ((neigh_ind <= 0)-(neigh_ind > NP))*NP; + # do wrap around + [x, ix] = min (val(neigh_ind)); # find the local best and its index + bm_n(i,:) = popold(neigh_ind(ix),:); # copy the data from the local best + neigh_ind(ix) = []; # remove "i" + pq = neigh_ind(randperm (length (neigh_ind))); + # permutation of the remaining ind. + pm4(i,:) = popold(pq(1),:); # use the pm4/5 matrix for the random + pm5(i,:) = popold(pq(2),:); # point p,q + endfor + ## calculate the new weihting factors + wi = wold + F*(bw - wold) + F*(w1 - w2); # use DE/target-to-best/1/nocross + # for optimisation of weightings + ## fix bounds for weightings + o = ones (NP, 1); + wi = sort ([0.05*o, wi, 0.95*o],2)(:,2); # sort and take the second column + ## fill weighting matrix + wm = repmat (wi, 1, D); + li = popold + F*(bm_n- popold) + F*(pm4 - pm5); + gi = popold + F*(bm - popold) + F*(pm1 - pm2); + ui = wm.*gi + (1-wm).*li; # combine global and local part + endif + ## crossover + ui = popold.*mpo + ui.*mui; + + ## enforce initial bounds/constraints if specified + if (constr == 1) + for i = 1:NP + ui(i,:) = max (ui(i,:), XVmin); + ui(i,:) = min (ui(i,:), XVmax); + end + end + + ## ----- Select which vectors are allowed to enter the new population ------ + for i = 1:NP + tempval = feval (fcn, [ui(i,:) const]); # check cost of competitor + if (tempval <= val(i)) # if competitor is better + pop(i,:) = ui(i,:); # replace old vector with new one + val(i) = tempval; # save value in "cost array" + w(i) = wi(i); # save the weighting factor + + ## we update bestval only in case of success to save time + if (tempval < bestval) # if competitor better than the best one ever + bestval = tempval; # new best value + bestmem = ui(i,:); # new best parameter vector ever + bestw = wi(i); # save best weighting + end + end + endfor #---end for i = 1:NP + + nfeval = nfeval + NP; # increase number of function evaluations + + bestmemit = bestmem; # freeze the best member of this iteration for the + # coming iteration. This is needed for some of the + # strategies. + + ## ---- Output section ---------------------------------------------------- + + if (refresh > 0) + if (rem (iter, refresh) == 0) + printf ('Iteration: %d, Best: %8.4e, Worst: %8.4e\n', ... + iter, bestval, max(val)); + for n = 1:D + printf ('x(%d) = %e\n', n, bestmem(n)); + end + end + end + + iter = iter + 1; +endwhile #---end while ((iter < maxiter) ... + +## check that all variables are well within bounds/constraints +boundsOK = 1; +for i = 1:NP + range = XVmax - XVmin; + if (ui(i,:) < XVmin + 0.01*range) + boundsOK = 0; + end + if (ui(i,:) > XVmax - 0.01*range) + boundsOK = 0; + end +end + +## create the convergence output +if (bestval <= VTR) + convergence = 1; +elseif (abs (max (val) - bestval) / max (1, abs (max (val))) <= tol) + convergence = 0; +elseif (boundsOK == 0) + convergence = -1; +elseif (iter >= maxiter) + convergence = -2; +elseif (nfeval >= maxnfe) + convergence = -3; +end + +endfunction + +%!function result = f(x); +%! result = 100 * (x(2) - x(1)^2)^2 + (1 - x(1))^2; +%!test +%! tol = 1.0e-4; +%! ctl.tol = 0.0; +%! ctl.VTR = 1.0e-6; +%! ctl.XVmin = [-2 -2]; +%! ctl.XVmax = [ 2 2]; +%! rand("state", 11) +%! [x, obj_value, nfeval, convergence] = de_min (@f, ctl); +%! assert (convergence == 1); +%! assert (f(x) == obj_value); +%! assert (obj_value < ctl.VTR); + +%!demo +%! ## define a simple example function +%! f = @(x) peaks(x(1), x(2)); +%! ## plot the function to see where the minimum might be +%! peaks() +%! ## first we set the region where we expect the minimum +%! ctl.XVmin = [-3 -3]; +%! ctl.XVmax = [ 3 3]; +%! ## and solve it with de_min +%! [x, obj_value, nfeval, convergence] = de_min (f, ctl) + This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <i7...@us...> - 2010-02-17 14:27:14
|
Revision: 6913 http://octave.svn.sourceforge.net/octave/?rev=6913&view=rev Author: i7tiol Date: 2010-02-17 14:27:06 +0000 (Wed, 17 Feb 2010) Log Message: ----------- optim: some helptext corrections Modified Paths: -------------- trunk/octave-forge/main/optim/DESCRIPTION trunk/octave-forge/main/optim/INDEX trunk/octave-forge/main/optim/inst/__poly_2_extrema.m trunk/octave-forge/main/optim/inst/cg_min.m trunk/octave-forge/main/optim/inst/cg_min_example_1.m trunk/octave-forge/main/optim/inst/fmin.m Modified: trunk/octave-forge/main/optim/DESCRIPTION =================================================================== --- trunk/octave-forge/main/optim/DESCRIPTION 2010-02-17 13:17:01 UTC (rev 6912) +++ trunk/octave-forge/main/optim/DESCRIPTION 2010-02-17 14:27:06 UTC (rev 6913) @@ -1,5 +1,5 @@ Name: Optim -Version: 1.0.9 +Version: 1.0.10 Date: 2009-09-21 Author: Various Authors Maintainer: The Octave Community Modified: trunk/octave-forge/main/optim/INDEX =================================================================== --- trunk/octave-forge/main/optim/INDEX 2010-02-17 13:17:01 UTC (rev 6912) +++ trunk/octave-forge/main/optim/INDEX 2010-02-17 14:27:06 UTC (rev 6913) @@ -16,16 +16,13 @@ wpolyfit wpolyfitdemo leasqr leasqrdemo LinearRegression -Root finding - fzero - fsolve fsolve_options Compatibility - fminunc + fminunc_compat optimset quadprog= try Yinyu Ye's <a href="http://dollar.biz.uiowa.edu/col/ye/matlab.html">code</a> linprog Numerical derivatives - dfdp bs_gradient cdiff deriv leval + dfdp cdiff deriv leval numgradient numhessian Tests test_min_1 test_min_2 test_min_3 test_min_4 @@ -36,4 +33,4 @@ bfgsmin_example rosenbrock samin_example - cg_min_test_1 cg_min_test_2 cg_min_test_3 + cg_min_example_1 cg_min_example_2 cg_min_example_3 Modified: trunk/octave-forge/main/optim/inst/__poly_2_extrema.m =================================================================== --- trunk/octave-forge/main/optim/inst/__poly_2_extrema.m 2010-02-17 13:17:01 UTC (rev 6912) +++ trunk/octave-forge/main/optim/inst/__poly_2_extrema.m 2010-02-17 14:27:06 UTC (rev 6913) @@ -8,7 +8,7 @@ ## Assuming that f(i) = a*l(i)^2 + b* l(i) + c = P(l(i)) for some a, b, c, ## ex is the extremum of the polynome P. ## -function ex = __poly_2_ex (l, f) +function ex = __poly_2_extrema (l, f) ### This somewhat helps if solution is very close to one of the points. Modified: trunk/octave-forge/main/optim/inst/cg_min.m =================================================================== --- trunk/octave-forge/main/optim/inst/cg_min.m 2010-02-17 13:17:01 UTC (rev 6912) +++ trunk/octave-forge/main/optim/inst/cg_min.m 2010-02-17 14:27:06 UTC (rev 6913) @@ -26,7 +26,7 @@ ## where Deltaf is the decrease in f observed in the last iteration ## (each iteration consists R*C line searches). ## @item @var{ctl}(1)==2 : Stopping criterion : Stop search when updates are small, -## as tested by @math{ ctl(2) > max { dx(i)/max(|x(i)|,1) | i in 1..N }} +## as tested by @math{ ctl(2) > max @{ dx(i)/max(|x(i)|,1) | i in 1..N @}} ## where dx is the change in the x that occured in the last iteration. ## @item @var{ctl}(2) : Threshold used in stopping tests. Default=10*eps ## @item @var{ctl}(2)==0 : Default value @@ -44,7 +44,7 @@ ## not passed or if nan values are given. ## @subheading Example: ## -## function r=df( l ) b=[1;0;-1]; r = -( 2*l@{1@} - 2*b + rand(size(l{1}))); endfunction @* +## function r=df( l ) b=[1;0;-1]; r = -( 2*l@{1@} - 2*b + rand(size(l@{1@}))); endfunction @* ## function r=ff( l ) b=[1;0;-1]; r = (l@{1@}-b)' * (l@{1@}-b); endfunction @* ## ll = @{ [10; 2; 3] @}; @* ## ctl(5) = 3; @* Modified: trunk/octave-forge/main/optim/inst/cg_min_example_1.m =================================================================== --- trunk/octave-forge/main/optim/inst/cg_min_example_1.m 2010-02-17 13:17:01 UTC (rev 6912) +++ trunk/octave-forge/main/optim/inst/cg_min_example_1.m 2010-02-17 14:27:06 UTC (rev 6913) @@ -1,3 +1,4 @@ +## ## ok = test_conjgrad_min - Test that conjgrad_min works ## ## Defines some simple functions and verifies that calling Modified: trunk/octave-forge/main/optim/inst/fmin.m =================================================================== --- trunk/octave-forge/main/optim/inst/fmin.m 2010-02-17 13:17:01 UTC (rev 6912) +++ trunk/octave-forge/main/optim/inst/fmin.m 2010-02-17 14:27:06 UTC (rev 6913) @@ -15,6 +15,8 @@ function ret=fmin(varargin) + ## alias for fminbnd + ret = fminbnd(varargin{:}); endfunction This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <i7...@us...> - 2010-03-14 13:32:31
|
Revision: 7061 http://octave.svn.sourceforge.net/octave/?rev=7061&view=rev Author: i7tiol Date: 2010-03-14 13:31:54 +0000 (Sun, 14 Mar 2010) Log Message: ----------- Changed version number and index file, include a constraints example into leasqr.m Modified Paths: -------------- trunk/octave-forge/main/optim/DESCRIPTION trunk/octave-forge/main/optim/INDEX trunk/octave-forge/main/optim/inst/leasqr.m Modified: trunk/octave-forge/main/optim/DESCRIPTION =================================================================== --- trunk/octave-forge/main/optim/DESCRIPTION 2010-03-13 07:52:23 UTC (rev 7060) +++ trunk/octave-forge/main/optim/DESCRIPTION 2010-03-14 13:31:54 UTC (rev 7061) @@ -1,10 +1,10 @@ Name: Optim -Version: 1.0.11 +Version: 1.0.13 Date: 2009-09-21 Author: Various Authors Maintainer: The Octave Community Title: Optimzation. -Description: Unconstrained Non-linear Optimization toolkit. +Description: Non-linear optimization toolkit. Depends: octave (>= 2.9.7), miscellaneous (>= 1.0.0) Autoload: yes License: GPL version 2 or later and GFDL Modified: trunk/octave-forge/main/optim/INDEX =================================================================== --- trunk/octave-forge/main/optim/INDEX 2010-03-13 07:52:23 UTC (rev 7060) +++ trunk/octave-forge/main/optim/INDEX 2010-03-14 13:31:54 UTC (rev 7061) @@ -12,9 +12,9 @@ cg_min de_min Data fitting - expfit expdemo - wpolyfit wpolyfitdemo - leasqr leasqrdemo + expfit + wpolyfit + leasqr LinearRegression Compatibility fminunc_compat @@ -33,4 +33,3 @@ bfgsmin_example rosenbrock samin_example - cg_min_example_1 cg_min_example_2 cg_min_example_3 Modified: trunk/octave-forge/main/optim/inst/leasqr.m =================================================================== --- trunk/octave-forge/main/optim/inst/leasqr.m 2010-03-13 07:52:23 UTC (rev 7060) +++ trunk/octave-forge/main/optim/inst/leasqr.m 2010-03-14 13:31:54 UTC (rev 7061) @@ -596,3 +596,28 @@ %! [f1, p1, kvg1, iter1, corp1, covp1, covr1, stdresid1, Z1, r21] = ... %! leasqr (t, data, pin, F, stol, niter, wt1, dp, dFdp, options); +%!demo +%! %% Example for linear inequality constraints. +%! %% model function: +%! F = @ (x, p) p(1) * exp (p(2) * x); +%! %% independents and dependents: +%! x = 1:5; +%! y = [1, 2, 4, 7, 14]; +%! %% initial values: +%! init = [.25; .25]; +%! %% other configuration (default values): +%! tolerance = .0001; +%! max_iterations = 20; +%! weights = ones (5, 1); +%! dp = [.001; .001]; % bidirectional numeric gradient stepsize +%! dFdp = 'dfdp'; % function for gradient (numerical) +%! +%! %% linear constraints, A.' * parametervector + B >= 0 +%! A = [1; -1]; B = 0; % p(1) >= p(2); +%! options.inequc = {A, B}; +%! +%! %% start leasqr, be sure that 'verbose' is not set +%! global verbose; verbose = false; +%! [f, p, cvg, iter] = ... +%! leasqr (x, y, init, F, tolerance, max_iterations, ... +%! weights, dp, dFdp, options) This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ha...@us...> - 2010-03-21 18:40:48
|
Revision: 7095 http://octave.svn.sourceforge.net/octave/?rev=7095&view=rev Author: hauberg Date: 2010-03-21 18:40:41 +0000 (Sun, 21 Mar 2010) Log Message: ----------- Remove 'fminbnd' as it is in Octave core Modified Paths: -------------- trunk/octave-forge/main/optim/INDEX Removed Paths: ------------- trunk/octave-forge/main/optim/inst/fminbnd.m Modified: trunk/octave-forge/main/optim/INDEX =================================================================== --- trunk/octave-forge/main/optim/INDEX 2010-03-21 09:14:41 UTC (rev 7094) +++ trunk/octave-forge/main/optim/INDEX 2010-03-21 18:40:41 UTC (rev 7095) @@ -4,7 +4,7 @@ nelder_mead_min d2_min nrm - fmin fminbnd + fmin line_min fmins adsmax mdsmax nmsmax bfgsmin samin battery Deleted: trunk/octave-forge/main/optim/inst/fminbnd.m =================================================================== --- trunk/octave-forge/main/optim/inst/fminbnd.m 2010-03-21 09:14:41 UTC (rev 7094) +++ trunk/octave-forge/main/optim/inst/fminbnd.m 2010-03-21 18:40:41 UTC (rev 7095) @@ -1,72 +0,0 @@ -## Copyright (C) 2000 Ben Sapp. All rights reserved. -## Modification by Andreas Helms -## This program is free software; you can redistribute it and/or modify it -## under the terms of the GNU General Public License as published by the -## Free Software Foundation; either version 2, or (at your option) any -## later version. -## -## This is distributed in the hope that it will be useful, but WITHOUT -## ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -## for more details. - -## -*- texinfo -*- -## @deftypefn {Function File} {[@var{x},@var{v}] =} fminbnd(@var{f},@var{lb},@var{ub},@var{[options]},@var{P1},@var{P2}, ...) -## -## Find the minimizer @var{x} of a scalar function and the corresponding -## value @var{v} with the Golden Search method. -## -## @strong{Inputs} -## @table @var -## @item f -## A string contining the name of the function to minimiz -## @item lb -## Value to use as an initial lower bound on @var{x}. -## @item ub -## Value to use as an initial upper bound on @var{x}. -## @item options -## Vector with control parameters (For compatibily with MATLAB, not used -## here) -## @item P1,P2, ... -## Optional parameter for function @var{f} -## -## @end table -## @end deftypefn - -## 2001-09-24 Andreas Helms <he...@as...> -## * modified for use with functions of more than one parameter -## 2007-08-09 Marco Caliari <mca...@ma...> -## * modified in order to get optionally the value of the function -## 2008-06-16 Florent Angly <flo...@gm...> -## * modified to accept an initial lower bound equal to the initial upper bound -## (like in Matlab) -function [min,val] = fminbnd(_func,lb,ub, options, varargin) - - delta = 1e-17; - gr = (sqrt(5)-1)/2; - width = (ub-lb); - out = linspace(lb, ub, 4); - out(2) = out(4)-gr*width; - out(3) = out(1)+gr*width; - upper = feval(_func,out(3), varargin{:}); - lower = feval(_func,out(2), varargin{:}); - while((out(3)-out(2)) > delta) #this will not work for symmetric funcs - if(upper > lower) - out(4) = out(3); - out(3) = out(2); - width = out(4)-out(1); - out(2) = out(4)-gr*width; - upper = lower; - lower = feval(_func,out(2), varargin{:}); - else - out(1) = out(2); - out(2) = out(3); - width = out(4)-out(1); - out(3) = out(1)+width*gr; - lower = upper; - upper = feval(_func,out(3), varargin{:}); - endif - endwhile - min = out(2); - val = feval(_func,out(2), varargin{:}); -endfunction This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <i7...@us...> - 2010-04-13 12:52:01
|
Revision: 7178 http://octave.svn.sourceforge.net/octave/?rev=7178&view=rev Author: i7tiol Date: 2010-04-13 12:51:54 +0000 (Tue, 13 Apr 2010) Log Message: ----------- - leasqr.m: -- Added general inequality constraints (Reference: Bard, Y., 'An eclectic approach to nonlinear programming', Proc. ANU Sem. Optimization, Canberra, Austral. Nat. Univ.). Differences from the reference: adaption to svd-based algorithm, linesearch or stepwidth adaptions to ensure decrease in objective function omitted to rather start a new overall cycle with a new epsL, some performance gains from linear constraints even if general constraints are specified. -- Made complementary pivot algorithm configurable (but no alternative supplied). - private/__dfdp__.m: Moved code from dfdp.m to here for more common use. - dfdp.m: Is now an interface to private/__dfdp__.m, functionally unchanged. - dcdp.m: New file. Interface to private/__dfdp__.m for passed functions only of parameters. - cpiv.m: Renamed to cpiv_bard.m. Modified Paths: -------------- trunk/octave-forge/main/optim/INDEX trunk/octave-forge/main/optim/inst/dfdp.m trunk/octave-forge/main/optim/inst/leasqr.m Added Paths: ----------- trunk/octave-forge/main/optim/inst/cpiv_bard.m trunk/octave-forge/main/optim/inst/dcdp.m trunk/octave-forge/main/optim/inst/private/ trunk/octave-forge/main/optim/inst/private/__dfdp__.m Removed Paths: ------------- trunk/octave-forge/main/optim/inst/cpiv.m Modified: trunk/octave-forge/main/optim/INDEX =================================================================== --- trunk/octave-forge/main/optim/INDEX 2010-04-12 12:14:09 UTC (rev 7177) +++ trunk/octave-forge/main/optim/INDEX 2010-04-13 12:51:54 UTC (rev 7178) @@ -22,8 +22,11 @@ quadprog= try Yinyu Ye's <a href="http://dollar.biz.uiowa.edu/col/ye/matlab.html">code</a> linprog Numerical derivatives - dfdp cdiff deriv leval + dfdp dcdp cdiff deriv leval numgradient numhessian +Pivoting + cpiv_bard.m + gjp.m Tests test_min_1 test_min_2 test_min_3 test_min_4 test_d2_min_1 test_d2_min_2 test_d2_min_3 Deleted: trunk/octave-forge/main/optim/inst/cpiv.m =================================================================== --- trunk/octave-forge/main/optim/inst/cpiv.m 2010-04-12 12:14:09 UTC (rev 7177) +++ trunk/octave-forge/main/optim/inst/cpiv.m 2010-04-13 12:51:54 UTC (rev 7178) @@ -1,59 +0,0 @@ -%% Copyright (C) 2010 Olaf Till -%% -%% This program is free software; you can redistribute it and/or modify -%% it under the terms of the GNU General Public License as published by -%% the Free Software Foundation; either version 2 of the License, or (at -%% your option) any later version. -%% -%% This program is distributed in the hope that it will be useful, but -%% WITHOUT ANY WARRANTY; without even the implied warranty of -%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -%% General Public License for more details. -%% -%% You should have received a copy of the GNU General Public License -%% along with this program; if not, write to the Free Software -%% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307USA - -function [lb, idx] = cpiv (v, m) - - %% [lb, idx] = cpiv (v, m) - %% - %% v: column vector; m: matrix. length (v) must equal rows (m). m must - %% be positive definit, which is not be explicitely checked. Finds - %% column vectors w and l with w == v + m * l, w >= 0, l >= 0, l.' * w - %% == 0. lb: column vector of components of l for which the - %% corresponding components of w are zero; idx: logical index of these - %% components in l. This is called solving the 'complementary pivot - %% problem' (Cottle, R. W. and Dantzig, G. B., 'Complementary pivot - %% theory of mathematical programming', Linear Algebra and Appl. 1, - %% 102--125. References for the current algorithm: Bard, Y.: Nonlinear - %% Parameter Estimation, p. 147--149, Academic Press, New York and - %% London 1974; Bard, Y., 'An eclectic approach to nonlinear - %% programming', Proc. ANU Sem. Optimization, Canberra, Austral. Nat. - %% Univ.). - - n = length (v); - if (n > size (v, 1)) - error ('first argument is no column vector'); % the most typical mistake - end - m = cat (2, m, v); - id = ones (n, 1); - nz = -eps; % This is arbitrary; components of w and -l are regarded as - % non-negative if >= nz. - nl = 100 * n; % maximum number of loop repeats, after that give up - ready = false; - while (~ ready && nl > 0) - [vm, idm] = min (id .* m(:, end)); - if (vm >= nz) - ready = true; - else - id(idm) = -id(idm); - m = gjp (m, idm); - nl = nl - 1; - end - end - if (~ ready) - error ('not successful'); - end - idx = id < 0; - lb = -m(idx, end); Copied: trunk/octave-forge/main/optim/inst/cpiv_bard.m (from rev 7177, trunk/octave-forge/main/optim/inst/cpiv.m) =================================================================== --- trunk/octave-forge/main/optim/inst/cpiv_bard.m (rev 0) +++ trunk/octave-forge/main/optim/inst/cpiv_bard.m 2010-04-13 12:51:54 UTC (rev 7178) @@ -0,0 +1,75 @@ +%% Copyright (C) 2010 Olaf Till +%% +%% This program is free software; you can redistribute it and/or modify +%% it under the terms of the GNU General Public License as published by +%% the Free Software Foundation; either version 2 of the License, or (at +%% your option) any later version. +%% +%% This program is distributed in the hope that it will be useful, but +%% WITHOUT ANY WARRANTY; without even the implied warranty of +%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +%% General Public License for more details. +%% +%% You should have received a copy of the GNU General Public License +%% along with this program; if not, write to the Free Software +%% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307USA + +function [lb, idx, ridx, m] = cpiv_bard (v, m, incl) + + %% [lb, idx, ridx, mv] = cpiv_bard (v, m[, incl]) + %% + %% v: column vector; m: matrix; incl (optional): index. length (v) + %% must equal rows (m). Finds column vectors w and l with w == v + m * + %% l, w >= 0, l >= 0, l.' * w == 0. Chooses idx, w, and l so that + %% l(~idx) == 0, l(idx) == -inv (m(idx, idx)) * v(idx), w(idx) roughly + %% == 0, and w(~idx) == v(~idx) + m(idx, ~idx).' * l(idx). idx indexes + %% at least everything indexed by incl. lb: l(idx) (column vector); + %% idx: logical index, defined above; ridx: ~idx & w roughly == 0; mv: + %% [m, v] after performing a Gauss-Jordan 'sweep' (with gjp.m) on each + %% diagonal element indexed by idx. This is called solving the + %% 'complementary pivot problem' (Cottle, R. W. and Dantzig, G. B., + %% 'Complementary pivot theory of mathematical programming', Linear + %% Algebra and Appl. 1, 102--125. References for the current + %% algorithm: Bard, Y.: Nonlinear Parameter Estimation, p. 147--149, + %% Academic Press, New York and London 1974; Bard, Y., 'An eclectic + %% approach to nonlinear programming', Proc. ANU Sem. Optimization, + %% Canberra, Austral. Nat. Univ.). + + n = length (v); + if (n > size (v, 1)) + error ('first argument is no column vector'); % the most typical mistake + end + if (nargin < 3) + incl = []; + elseif (islogical (incl)) + incl = find (incl); + end + nincl = 1:n; + nincl(incl) = []; + m = cat (2, m, v); + sgn = ones (n, 1); + for id = incl + sgn(id) = -sgn(id); + m = gjp (m, id); + end + nz = eps; % This is arbitrary; components of w and -l are regarded as + % non-negative if >= -nz. + nl = 100 * n; % maximum number of loop repeats, after that give up + ready = false; + while (~ready && nl > 0) + [vm, idm] = min (sgn(nincl) .* m(nincl, end)); + if (vm >= -nz) + ready = true; + else + idm = nincl(idm); + sgn(idm) = -sgn(idm); + m = gjp (m, idm); + nl = nl - 1; + end + end + if (~ready || any (m(incl, end) > nz)) + error ('not successful'); + end + idx = sgn < 0; + lb = -m(idx, end); + ridx = ~idx & abs (m(:, end)) <= nz; Property changes on: trunk/octave-forge/main/optim/inst/cpiv_bard.m ___________________________________________________________________ Added: svn:mergeinfo + Added: trunk/octave-forge/main/optim/inst/dcdp.m =================================================================== --- trunk/octave-forge/main/optim/inst/dcdp.m (rev 0) +++ trunk/octave-forge/main/optim/inst/dcdp.m 2010-04-13 12:51:54 UTC (rev 7178) @@ -0,0 +1,28 @@ +%% Copyright (C) 2010 Olaf Till <ola...@un...> +%% +%% This program is free software; you can redistribute it and/or modify +%% it under the terms of the GNU General Public License as published by +%% the Free Software Foundation; either version 2 of the License, or +%% (at your option) any later version. +%% +%% This program is distributed in the hope that it will be useful, +%% but WITHOUT ANY WARRANTY; without even the implied warranty of +%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +%% GNU General Public License for more details. +%% +%% You should have received a copy of the GNU General Public License +%% along with this program; If not, see <http://www.gnu.org/licenses/>. + +function prt = dcdp (varargin) + + %% function prt = dcdp (f, p, dp, func[, bounds]) + %% + %% This is an interface to __dfdp__.m, similar to dfdp.m, but for + %% functions only of parameters 'p', not of independents 'x'. See + %% dfdp.m. + + if (ischar (varargin{4})) + varargin{4} = str2func (varargin{4}); + end + + prt = __dfdp__ (varargin{:}); Modified: trunk/octave-forge/main/optim/inst/dfdp.m =================================================================== --- trunk/octave-forge/main/optim/inst/dfdp.m 2010-04-12 12:14:09 UTC (rev 7177) +++ trunk/octave-forge/main/optim/inst/dfdp.m 2010-04-13 12:51:54 UTC (rev 7178) @@ -1,89 +1,50 @@ -% Copyright (C) 1992-1994 Richard Shrager -% Copyright (C) 1992-1994 Arthur Jutan -% Copyright (C) 1992-1994 Ray Muzic -% -% This program is free software; you can redistribute it and/or modify -% it under the terms of the GNU General Public License as published by -% the Free Software Foundation; either version 2 of the License, or -% (at your option) any later version. -% -% This program is distributed in the hope that it will be useful, -% but WITHOUT ANY WARRANTY; without even the implied warranty of -% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -% GNU General Public License for more details. -% -% You should have received a copy of the GNU General Public License -% along with this program; If not, see <http://www.gnu.org/licenses/>. +%% Copyright (C) 1992-1994 Richard Shrager +%% Copyright (C) 1992-1994 Arthur Jutan +%% Copyright (C) 1992-1994 Ray Muzic +%% Copyright (C) 2010 Olaf Till <ola...@un...> +%% +%% This program is free software; you can redistribute it and/or modify +%% it under the terms of the GNU General Public License as published by +%% the Free Software Foundation; either version 2 of the License, or +%% (at your option) any later version. +%% +%% This program is distributed in the hope that it will be useful, +%% but WITHOUT ANY WARRANTY; without even the implied warranty of +%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +%% GNU General Public License for more details. +%% +%% You should have received a copy of the GNU General Public License +%% along with this program; If not, see <http://www.gnu.org/licenses/>. -function prt=dfdp(x,f,p,dp,func,bounds) -% function prt = dfdp (x, f, p, dp, func[, bounds]) -% numerical partial derivatives (Jacobian) df/dp for use with leasqr -% --------INPUT VARIABLES--------- -% x=vec or matrix of indep var(used as arg to func) x=[x0 x1 ....] -% f=func(x,p) vector initialsed by user before each call to dfdp -% p= vec of current parameter values -% dp= fractional increment of p for numerical derivatives -% dp(j)>0 central differences calculated -% dp(j)<0 one sided differences calculated -% dp(j)=0 sets corresponding partials to zero; i.e. holds p(j) fixed -% func=string naming the function (.m) file -% e.g. to calc Jacobian for function expsum prt=dfdp(x,f,p,dp,'expsum') -% bounds=two-column-matrix of lower and upper bounds for parameters -% If no 'bounds' options is specified to leasqr, it will call -% dfdp without the 'bounds' argument. -%----------OUTPUT VARIABLES------- -% prt= Jacobian Matrix prt(i,j)=df(i)/dp(j) -%================================ +function prt = dfdp (varargin) -m=size(x,1); if (m==1), m=size(x,2); end %# PAK: in case #cols > #rows -n=length(p); %dimensions -if (nargin < 6) - bounds = ones (n, 2); - bounds(:, 1) = -Inf; - bounds(:, 2) = Inf; -end -prt=zeros(m,n); % initialise Jacobian to Zero -del = dp .* p; %cal delx=fract(dp)*param value(p) -idx = p == 0; -del(idx) = dp(idx); %if param=0 delx=fraction -idx = dp > 0; -del(idx) = abs (del(idx)); % not for one-sided intervals, changed - % direction of intervals could change - % behavior of optimization without bounds -min_del = min (abs (del), bounds(:, 2) - bounds(:, 1)); - for j=1:n - ps = p; - if (dp(j)~=0) - if (dp(j) < 0) - ps(j) = p(j) + del(j); - if (ps(j) < bounds(j, 1) || ps(j) > bounds(j, 2)) - t_del1 = max (bounds(j, 1) - p(j), - abs (del(j))); % - %non-positive - t_del2 = min (bounds(j, 2) - p(j), abs (del(j))); % - %non-negative - if (- t_del1 > t_del2) - del(j) = t_del1; - else - del(j) = t_del2; - end - ps(j) = p(j) + del(j); - end - prt(:, j) = (feval (func, x, ps) - f) / del(j); - else - if (p(j) - del(j) < bounds(j, 1)) - tp = bounds(j, 1); - ps(j) = tp + min_del(j); - elseif (p(j) + del(j) > bounds(j, 2)) - ps(j) = bounds(j, 2); - tp = ps(j) - min_del(j); - else - ps(j) = p(j) + del(j); - tp = p(j) - del(j); - min_del(j) = 2 * del(j); - end - f1 = feval (func, x, ps); - ps(j) = tp; - prt(:, j) = (f1 - feval (func, x, ps)) / min_del(j); - end - end + %% function prt = dfdp (x, f, p, dp, func[, bounds]) + %% numerical partial derivatives (Jacobian) df/dp for use with leasqr + %% --------INPUT VARIABLES--------- + %% x=vec or matrix of indep var(used as arg to func) x=[x0 x1 ....] + %% f=func(x,p) vector initialsed by user before each call to dfdp + %% p= vec of current parameter values + %% dp= fractional increment of p for numerical derivatives + %% dp(j)>0 central differences calculated + %% dp(j)<0 one sided differences calculated + %% dp(j)=0 sets corresponding partials to zero; i.e. holds p(j) fixed + %% func=function (string or handle) to calculate the Jacobian for, + %% e.g. to calc Jacobian for function expsum prt=dfdp(x,f,p,dp,'expsum') + %% bounds=two-column-matrix of lower and upper bounds for parameters + %% If no 'bounds' options is specified to leasqr, it will call + %% dfdp without the 'bounds' argument. + %%----------OUTPUT VARIABLES------- + %% prt= Jacobian Matrix prt(i,j)=df(i)/dp(j) + %%================================ + + %% This is just an interface. The original code has been moved to + %% __dfdp__.m, which is used with two different interfaces by + %% leasqr.m. + + if (ischar (varargin{5})) + varargin{5} = @ (p) str2func (varargin{5}) (varargin{1}, p); + else + varargin{5} = @ (p) varargin{5} (varargin{1}, p); end + + prt = __dfdp__ (varargin{2:end}); Modified: trunk/octave-forge/main/optim/inst/leasqr.m =================================================================== --- trunk/octave-forge/main/optim/inst/leasqr.m 2010-04-12 12:14:09 UTC (rev 7177) +++ trunk/octave-forge/main/optim/inst/leasqr.m 2010-04-13 12:51:54 UTC (rev 7178) @@ -72,14 +72,48 @@ %% [ie. abs(chg(i))=abs(min([chg(i) %% options.max_fract_change(i)*current param estimate])).], default = %% Inf*ones(). - %% Field 'options.inequc': cell-array containing a matrix (say m) - %% and a column vector (say v), specifying linear inequality - %% constraints of the form `m.' * parameters + v >= 0'. If the - %% constraints are just bounds, it is suggested to specify them in - %% 'options.bounds' instead, since then some sanity tests are - %% performed, and since the function 'dfdp.m' is guarantied not to - %% violate constraints during determination of the numeric gradient - %% only for those constraints specified as 'bounds'. + %% Field 'options.inequc': cell-array containing up to four entries, + %% two entries for linear inequality constraints and/or one or two + %% entries for general inequality constraints. Either linear or + %% general constraints may be the first entries, but the two entries + %% for linear constraints must be adjacent and, if two entries are + %% given for general constraints, they also must be adjacent. The + %% two entries for linear constraints are a matrix (say m) and a + %% vector (say v), specifying linear inequality constraints of the + %% form `m.' * parameters + v >= 0'. If the constraints are just + %% bounds, it is suggested to specify them in 'options.bounds' + %% instead, since then some sanity tests are performed, and since + %% the function 'dfdp.m' is guarantied not to violate constraints + %% during determination of the numeric gradient only for those + %% constraints specified as 'bounds'. The first entry for general + %% constraints must be a differentiable vector valued function (say + %% h), specifying general inequality constraints of the form `h (p[, + %% idx]) >= 0'; p is the column vector of optimized paraters and the + %% optional argument idx is a logical index. h has to return the + %% values of all constraints if idx is not given, and has to return + %% only the indexed constraints if idx is given (so computation of + %% the other constraints can be spared). If a second entry for + %% general constraints is given, it must be a function (say dh) + %% which returnes a matrix whos rows contain the gradients of the + %% constraint function h with respect to the optimized parameters. + %% It has the form jac_h = dh (vh, p, dp, h, idx[, bounds]); p is + %% the column vector of optimized parameters, and idx is a logical + %% index --- only the rows indexed by idx must be returned (so + %% computation of the others can be spared). The other arguments of + %% dh are for the case that dh computes numerical gradients: vh is + %% the column vector of the current values of the constraint + %% function h, with idx already applied. h is a function h (p) to + %% compute the values of the constraints for parameters p, it will + %% return only the values indexed by idx. dp is a suggestion for + %% relative step width, having the same value as the argument 'dp' + %% of leasqr above. If bounds were specified to leasqr, they are + %% provided in the argument bounds of dh, to enable their + %% consideration in determination of numerical gradients. If dh is + %% not specified to leasqr, numerical gradients are computed in the + %% same way as with 'dfdp.m' (see above). If some constraints are + %% linear, they should be specified as linear constraints (or + %% bounds, if applicable) for reasons of performance, even if + %% general constraints are also specified. %% Field 'options.bounds': two-column-matrix, one row for each %% parameter in 'pin'. Each row contains a minimal and maximal value %% for each parameter. Default: [-Inf, Inf] in each row. If this @@ -88,6 +122,9 @@ %% _Warning_: If constraints (or bounds) are set, returned guesses %% of corp, covp, and Z are generally invalid, even if no constraints %% are active for the final parameters. + %% Field 'options.cpiv': Function for complementary pivot algorithm + %% for inequality constraints, default: @ cpiv_bard. No different + %% function is supplied. %% %% OUTPUT VARIABLES %% f = column vector of values computed: f = F(x,p). @@ -161,13 +198,26 @@ %% Modified by Francesco Potort\xEC %% for use in Octave %% Added linear inequality constraints with quadratic programming to - %% this file and special case bounds to this file and to dfdp.m, Olaf - %% Till 24-Feb-2010 + %% this file and special case bounds to this file and to dfdp.m + %% (24-Feb-2010) and later also general inequality constraints + %% (12-Apr-2010) (Reference: Bard, Y., 'An eclectic approach to + %% nonlinear programming', Proc. ANU Sem. Optimization, Canberra, + %% Austral. Nat. Univ.). Differences from the reference: adaption to + %% svd-based algorithm, linesearch or stepwidth adaptions to ensure + %% decrease in objective function omitted to rather start a new + %% overall cycle with a new epsL, some performance gains from linear + %% constraints even if general constraints are specified. Olaf Till + %% %% References: %% Bard, Nonlinear Parameter Estimation, Academic Press, 1974. %% Draper and Smith, Applied Regression Analysis, John Wiley and Sons, 1981. + %% needed for some anonymous functions + if (exist ('ifelse') ~= 5) + ifelse = @ scalar_ifelse; + end + %% argument processing %% @@ -188,11 +238,16 @@ verbose=0; %This will not tell them the results end - if (nargin <= 8) dFdp='dfdp'; end + if (nargin <= 8) + dFdp = @ dfdp; + elseif (ischar (dFdp)) + dFdp = str2func (dFdp); + end if (nargin <= 7) dp=.001*(pin*0+1); end %DT if (nargin <= 6) wt=ones(length(y),1); end % SMB modification if (nargin <= 5) niter=20; end if (nargin == 4) stol=.0001; end + if (ischar (F)) F = str2func (F); end %% y=y(:); wt=wt(:); pin=pin(:); dp=dp(:); %change all vectors to columns @@ -206,10 +261,13 @@ %% processing of 'options' pprec = zeros (n, 1); maxstep = Inf * ones (n, 1); + have_gencstr = false; % no general constraints + n_gencstr = 0; mc = zeros (n, 0); - vc = zeros (0, 1); + vc = zeros (0, 1); rv = 0; bounds = cat (2, -Inf * ones (n, 1), Inf * ones (n, 1)); - dfdp_cmd = 'feval(dFdp,x,fbest,p,dp,F);'; % will possibly be redefined + dfdp_bounds = {}; + cpiv = @ cpiv_bard; if (nargin > 9) if (ismatrix (options)) % backwards compatibility tp = options; @@ -218,6 +276,16 @@ options.max_fract_change = tp(:, 2); end end + if (isfield (options, 'cpiv') && ~isempty (options.cpiv)) + %% As yet there is only one cpiv function distributed with leasqr, + %% but this may change; cpiv_bard is said to be relatively fast, + %% but may have disadvantages. + if (ischar (options.cpiv)) + cpiv = str2func (options.cpiv); + else + cpiv = options.cpiv; + end + end if (isfield (options, 'fract_prec')) pprec = options.fract_prec; if (rows (pprec) ~= n || columns (pprec) ~= 1) @@ -231,19 +299,59 @@ end end if (isfield (options, 'inequc')) - mc = options.inequc{1}; - vc = options.inequc{2}; + inequc = options.inequc; + if (ismatrix (inequc{1})) + mc = inequc{1}; + vc = inequc{2}; + if (length (inequc) > 2) + have_gencstr = true; + f_gencstr = inequc{3}; + if (length (inequc) > 3) + df_gencstr = inequc{4}; + else + df_gencstr = @ dcdp; + end + end + else + lid = 0; % no linear constraints + have_gencstr = true; + f_gencstr = inequc{1}; + if (length (inequc) > 1) + if (ismatrix (inequc{2})) + lid = 2; + df_gencstr = @ dcdp; + else + df_gencstr = inequc{2}; + if (length (inequc) > 2) + lid = 3; + end + end + else + df_gencstr = @ dcdp; + end + if (lid) + mc = inequc{lid}; + vc = inequc{lid + 1}; + end + end + if (have_gencstr) + if (ischar (f_gencstr)) f_gencstr = str2func (f_gencstr); end + if (ischar (df_gencstr)) df_gencstr = str2func (df_gencstr); end + end [rm, cm] = size (mc); [rv, cv] = size (vc); if (rm ~= n || cm ~= rv || cv ~= 1) - error ('inequality constraints: wrong dimensions'); + error ('linear inequality constraints: wrong dimensions'); end - if (any (mc.' * pin + vc < 0)) + if (have_gencstr) + tp = f_gencstr (pin); + n_gencstr = length (tp); + end + if (any (mc.' * pin + vc < 0) || (have_gencstr && any (tp < 0))) error ('initial parameters violate inequality constraints'); end end if (isfield (options, 'bounds')) - dfdp_cmd = 'feval(dFdp,x,fbest,p,dp,F,bounds);'; bounds = options.bounds; if (rows (bounds) ~= n || columns (bounds) ~= 2) error ('bounds: wrong dimensions'); @@ -268,12 +376,44 @@ pin(idx) = bounds(idx, 2); end tp = eye (n); - lidx = ~ isinf (bounds(:, 1)); - uidx = ~ isinf (bounds(:, 2)); + lidx = ~isinf (bounds(:, 1)); + uidx = ~isinf (bounds(:, 2)); mc = cat (2, mc, tp(:, lidx), - tp(:, uidx)); vc = cat (1, vc, - bounds(lidx, 1), bounds(uidx, 2)); + [rm, cm] = size (mc); + [rv, cv] = size (vc); + dfdp_bounds = {bounds}; end end + nidxl = 1:rv; + nidxh = rv+1:rv+n_gencstr; + if (have_gencstr) + f_cstr = @ (p, idx) ... + cat (1, mc(:, idx(nidxl)).' * p + vc(idx(nidxl), 1), ... + tf_gencstr (p, idx(nidxh), f_gencstr)); + if (strcmp (func2str (df_gencstr), 'dcdp')) + df_cstr = @ (f, p, idx) ... + cat (1, mc(:, idx(nidxl)).', ... + df_gencstr (f(nidxh(idx(nidxh))), p, dp, ... + @ (tp) tf_gencstr (tp, idx(nidxh), ... + f_gencstr), ... + dfdp_bounds{:})); + else + df_cstr = @ (f, p, idx) ... + cat (1, mc(:, idx(nidxl)).', ... + df_gencstr (f(nidxh(idx(nidxh))), p, dp, ... + @ (tp) tf_gencstr (tp, idx(nidxh), ... + f_gencstr), ... + idx(nidxh), ... + dfdp_bounds{:})); + end + if (any (~isinf (maxstep))) + warning ('setting both a maximum fractional step change of parameters and general constraints may result in inefficiency and failure'); + end + else + f_cstr = @ (p, idx) mc(:, idx).' * p + vc(idx, 1); + df_cstr = @ (f, p, idx) mc(:, idx).'; + end if (all (dp == 0)) error ('no free parameters'); @@ -282,7 +422,7 @@ %% set up for iterations %% p = pin; - f=feval(F,x,p); fbest=f; pbest=p; + f = F (x, p); fbest=f; pbest=p; r=wt.*(y-f); if (~isreal (r)) error ('weighted residuals are not real'); end ss = r.' * r; @@ -291,25 +431,43 @@ cvg=0; epsLlast=1; epstab=[.1, 1, 1e2, 1e4, 1e6]; + ac_idx = true (rv + n_gencstr, 1); % all constraints + nc_idx = false (rv + n_gencstr, 1); % non of all constraints + gc_idx = cat (1, false (rv, 1), true (n_gencstr, 1)); % gen. constr. + lc_idx = ~gc_idx; %% for testing %% new_s = false; %% if (isfield (options, 'new_s')) %% new_s = options.new_s; %% end + %% if (isfield (options, 'testing') && options.testing) + %% testing = true; + %% else + %% testing = false; + %% end - nz = eps; % This is arbitrary. Constraint fuction will be regarded as - % <= zero if less than nz. + nz = 20 * eps; % This is arbitrary. Constraint function will be + % regarded as <= zero if less than nz. %% do iterations %% for iter=1:niter - c_act = mc.' * p + vc < nz; % index of active constraints - mca = mc(:, c_act); - vca = vc(c_act); - mcat = mca.'; + %% deb_printf (testing, '\nstart outer iteration\n'); + v_cstr = f_cstr (p, ac_idx); + c_act = v_cstr < nz; % index of active constraints + if (any (c_act)) + if (have_gencstr) + dct = df_cstr (v_cstr, p, ac_idx); + dc = dct.'; + dcat = dct(c_act, :); + else + dcat = df_cstr (v_cstr, p, c_act); + end + dca = dcat.'; + end nrm = zeros (1, n); pprev=pbest; - prt = eval (dfdp_cmd); + prt = dFdp (x, fbest, p, dp, F, dfdp_bounds{:}); r=wt.*(y-fbest); if (~isreal (r)) error ('weighted residuals are not real'); end sprev=sbest; @@ -325,6 +483,7 @@ s=diag(s); g = prt.' * r; for jjj=1:length(epstab) + %% deb_printf (testing, '\nstart inner iteration\n'); epsL = max(epsLlast*epstab(jjj),1e-7); %% printf ('epsL: %e\n', epsL); % for testing @@ -347,48 +506,184 @@ %% end tp1 = (v * (g .* ser)) .* nrm; if (any (c_act)) + %% deb_printf (testing, 'constraints are active:\n'); + %% deb_printf (testing, '%i\n', c_act); %% calculate chg by 'quadratic programming' - idx = ones (1, size (mca, 2)); - nrme = nrm(:, idx); - ser2 = ser .* ser; - tp2 = nrme .* (v * (ser2(:, idx) .* (v.' * (nrme .* mca)))); - [lb, idx] = cpiv (mcat * tp1, mcat * tp2); - chg = tp1 + tp2(:, idx) * lb; - %% collect inactive constraints - mcit = mc(:, ~ c_act).'; - vci = vc(~ c_act); + nrme= diag (nrm); + ser2 = diag (ser .* ser); + mfc1 = nrme * v * ser2 * v.' * nrme; + tp2 = mfc1 * dca; + [lb, bidx, ridx, tbl] = cpiv (dcat * tp1, dcat * tp2); + chg = tp1 + tp2(:, bidx) * lb; + %% indices for different types of constraints + c_inact = ~c_act; % inactive constraints + c_binding = nc_idx; + c_binding(c_act) = bidx; % constraints selected binding + c_unbinding = nc_idx; + c_unbinding(c_act) = ridx; % constraints unselected binding + c_nonbinding = c_act & ~(c_binding | c_unbinding); % constraints + % selected non-binding else %% chg is the Levenberg/Marquardt step chg = tp1; - %% inactive constraints consist of all constraints - mcit = mc.'; - vci = vc; + %% indices for different types of constraints + c_inact = ac_idx; % inactive constraints consist of all + % constraints + c_binding = nc_idx; + c_unbinding = nc_idx; + c_nonbinding = nc_idx; end - %% apply inactive constraints (since this is a Levenberg/Marquardt - %% algorithm, no line-search is performed here) + %% apply constraints to step width (since this is a + %% Levenberg/Marquardt algorithm, no line-search is performed + %% here) + k = 1; + c_tp = c_inact(1:rv); + mcit = mc(:, c_tp).'; + vci = vc(c_tp); hstep = mcit * chg; idx = hstep < 0; if (any (idx)) k = min (1, min (- (vci(idx) + mcit(idx, :) * pprev) ./ ... hstep(idx))); - chg = k * chg; + %% deb_printf (testing, 'stepwidth: linear constraints\n'); end - %% check the maximal stepwidth and apply as necessary - ochg=chg; - idx = ~isinf(maxstep); - limit = abs(maxstep(idx).*pprev(idx)); - chg(idx) = min(max(chg(idx),-limit),limit); - if (verbose && any(ochg ~= chg)) - disp(['Change in parameter(s): ', ... - sprintf('%d ',find(ochg ~= chg)), 'maximal fractional stepwidth enforced']); + if (have_gencstr) + c_tp = gc_idx & (c_nonbinding | c_inact); + if (any (c_tp) && any (f_cstr (pprev + k * chg, c_tp) < 0)) + [k, fval, info] = ... + fzero (@ (x) min (cat (1, ... + f_cstr (pprev + x * chg, c_tp), ... + k - x, ... + ifelse (x < 0, -Inf, Inf))), ... + 0); + if (info ~= 1 || abs (fval) >= nz) + error ('could not find stepwidth to satisfy inactive and non-binding general inequality constraints'); + end + %% deb_printf (testing, 'general constraints limit stepwidth\n'); + end end + chg = k * chg; + + if (any (gc_idx & c_binding)) % none selected binding => + % none unselected binding + %% deb_printf (testing, 'general binding constraints must be regained:\n'); + %% regain binding constraints and one of the possibly active + %% previously inactive or non-binding constraints + ptp1 = pprev + chg; + + tp = true; + nt_nosuc = true; + lim = 20; + while (nt_nosuc && lim >= 0) + %% deb_printf (testing, 'starting from new value of p in regaining:\n'); + %% deb_printf (testing, '%e\n', ptp1); + %% we keep dp.' * inv (mfc1) * dp minimal in each step of the + %% inner loop; this is both sensible (this metric considers a + %% guess of curvature of sum of squared residuals) and + %% convenient (we have useful matrices available for it) + c_tp0 = c_inact | c_nonbinding; + c_tp1 = c_inact | (gc_idx & c_nonbinding); + btbl = tbl(bidx, bidx); + c_tp2 = c_binding; + if (any (tp)) % if none before, does not get true again + tp = f_cstr (ptp1, c_tp1) < nz; + if (any (tp)) % could be less clumsy, but ml-compatibility.. + %% keep only the first true entry in tp + tp(tp) = logical (cat (1, 1, zeros (sum (tp) - 1, 1))); + %% supplement binding index with one (the first) getting + %% binding in c_tp1 + c_tp2(c_tp1) = tp; + %% gradient of this added constraint + caddt = dct(c_tp2 & ~c_binding, :); + cadd = caddt.'; + C = dct(c_binding, :) * mfc1 * cadd; + Ct = C.'; + G = [btbl, btbl * C; ... + -Ct * btbl, caddt * mfc1 * cadd - Ct * btbl * C]; + btbl = gjp (G, size (G, 1)); + end + end + dcbt = dct(c_tp2, :); + mfc = - mfc1 * dcbt.' * btbl; + %% deb_printf (testing, 'constraints to regain:\n'); + %% deb_printf (testing, '%i\n', c_tp2); + + ptp2 = ptp1; + nt_niter = 100; + while (nt_nosuc && nt_niter >= 0) + hv = f_cstr (ptp2, c_tp2); + if (all (hv < nz)) + nt_nosuc = false; + chg = ptp2 - pprev; + else + ptp2 = ptp2 + mfc * hv; + end + nt_niter = nt_niter - 1; + end + if (nt_nosuc || ... + any (abs (chg) > abs (pprev .* maxstep)) || ... + any (f_cstr (ptp2, c_tp0) < -nz)) + nt_nosuc = true; + ptp1 = (pprev + ptp1) / 2; + if (nt_nosuc) + %% deb_printf (testing, 'regaining did not converge\n'); + else + %% deb_printf (testing, 'regaining violated type 3 and 4\n'); + end + end + if (~nt_nosuc) + tp = f_cstr (ptp2, c_unbinding); + if (any (tp) < 0) % again ml-compatibility clumsyness.. + [discarded, id] = min(tp); + tid = find (ridx); + id = tid(id); + if (abs (tbl(id, id)) < nz) % Bard: not absolute value + [discarded, idm] = max (abs (tbl(bidx, id))); + tid = find (bidx); + idm = tid(idm); + tbl = gjp (tbl, idm); + bidx(idm) = false; + ridx(idm) = true; + end + tbl = gjp (tbl, id); + bidx(id) = true; + ridx(id) = false; + c_binding = nc_idx; + c_binding(c_act) = bidx; + c_unbinding = nc_idx; + c_unbinding(c_act) = ridx; + nt_nosuc = true; + %% deb_printf (testing, 'regaining violated type 2\n'); + end + end + if (~nt_nosuc) + %% deb_printf (testing, 'regaining successful, converged with %i iterations:\n', ... + %% 100 - nt_niter); + %% deb_printf (testing, '%e\n', ptp2); + end + lim = lim - 1; + end + if (nt_nosuc) + error ('could not regain binding constraints'); + end + else + %% check the maximal stepwidth and apply as necessary + ochg=chg; + idx = ~isinf(maxstep); + limit = abs(maxstep(idx).*pprev(idx)); + chg(idx) = min(max(chg(idx),-limit),limit); + if (verbose && any(ochg ~= chg)) + disp(['Change in parameter(s): ', ... + sprintf('%d ',find(ochg ~= chg)), 'maximal fractional stepwidth enforced']); + end + end aprec=abs(pprec.*pbest); %--- %% ss=scalar sum of squares=sum((wt.*(y-f))^2). if (any(abs(chg) > 0.1*aprec))%--- % only worth evaluating % function if there is some non-miniscule % change p=chg+pprev; - f=feval(F,x,p); + f = F (x, p); r=wt.*(y-f); if (~isreal (r)) error ('weighted residuals are not real'); @@ -440,7 +735,7 @@ %% CALC VARIANCE COV MATRIX AND CORRELATION MATRIX OF PARAMETERS %% re-evaluate the Jacobian at optimal values - jac = eval (dfdp_cmd); + jac = dFdp (x, fbest, p, dp, F, dfdp_bounds{:}); msk = dp ~= 0; n = sum(msk); % reduce n to equal number of estimated parameters jac = jac(:, msk); % use only fitted parameters @@ -534,7 +829,7 @@ disp(covr) disp(' Correlation Coefficient R^2') disp(r2) - sprintf(' 95%% conf region: F(0.05)(%.0f,%.0f)>= delta_pvec.''*Z*delta_pvec',n,m-n) + sprintf(' 95%% conf region: F(0.05)(%.0f,%.0f)>= delta_pvec.%s*Z*delta_pvec', n, m - n, char (39)) % works with ' and ' Z %% runs test according to Bard. p 201. n1 = sum (resid > 0); @@ -553,6 +848,34 @@ end end +function ret = tf_gencstr (p, idx, f) + + %% necessary since user function f_gencstr might return [] + + ret = f (p, idx); + if (isempty (ret)) + ret = zeros (0, 1); + elseif (size (ret, 2) > 1) + ret = ret(:); + end + +function fval = scalar_ifelse (cond, tval, fval) + + %% needed for some anonymous functions, builtin ifelse only available + %% in Octave > 3.2; we need only the scalar case here + + if (cond) + fval = tval; + end + +function deb_printf (do_printf, varargin) + + %% for testing + + if (do_printf) + printf (varargin{:}) + end + %!demo %! % Define functions %! leasqrfunc = @(x, p) p(1) * exp (-p(2) * x); Added: trunk/octave-forge/main/optim/inst/private/__dfdp__.m =================================================================== --- trunk/octave-forge/main/optim/inst/private/__dfdp__.m (rev 0) +++ trunk/octave-forge/main/optim/inst/private/__dfdp__.m 2010-04-13 12:51:54 UTC (rev 7178) @@ -0,0 +1,74 @@ +%% Copyright (C) 1992-1994 Richard Shrager +%% Copyright (C) 1992-1994 Arthur Jutan +%% Copyright (C) 1992-1994 Ray Muzic +%% Copyright (C) 2010 Olaf Till <ola...@un...> +%% +%% This program is free software; you can redistribute it and/or modify +%% it under the terms of the GNU General Public License as published by +%% the Free Software Foundation; either version 2 of the License, or +%% (at your option) any later version. +%% +%% This program is distributed in the hope that it will be useful, +%% but WITHOUT ANY WARRANTY; without even the implied warranty of +%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +%% GNU General Public License for more details. +%% +%% You should have received a copy of the GNU General Public License +%% along with this program; If not, see <http://www.gnu.org/licenses/>. + +function prt = __dfdp__ (f, p, dp, func, bounds) + + %% Meant to be called by interfaces 'dfdp.m' and 'dcdp.m', see there. + + m = length (f); + n=length(p); %dimensions + if (nargin < 6) + bounds = ones (n, 2); + bounds(:, 1) = -Inf; + bounds(:, 2) = Inf; + end + prt=zeros(m,n); % initialise Jacobian to Zero + del = dp .* p; %cal delx=fract(dp)*param value(p) + idx = p == 0; + del(idx) = dp(idx); %if param=0 delx=fraction + idx = dp > 0; + del(idx) = abs (del(idx)); % not for one-sided intervals, changed + % direction of intervals could change + % behavior of optimization without bounds + min_del = min (abs (del), bounds(:, 2) - bounds(:, 1)); + for j=1:n + ps = p; + if (dp(j)~=0) + if (dp(j) < 0) + ps(j) = p(j) + del(j); + if (ps(j) < bounds(j, 1) || ps(j) > bounds(j, 2)) + t_del1 = max (bounds(j, 1) - p(j), - abs (del(j))); % + %non-positive + t_del2 = min (bounds(j, 2) - p(j), abs (del(j))); % + %non-negative + if (- t_del1 > t_del2) + del(j) = t_del1; + else + del(j) = t_del2; + end + ps(j) = p(j) + del(j); + end + prt(:, j) = (func (ps) - f) / del(j); + else + if (p(j) - del(j) < bounds(j, 1)) + tp = bounds(j, 1); + ps(j) = tp + min_del(j); + elseif (p(j) + del(j) > bounds(j, 2)) + ps(j) = bounds(j, 2); + tp = ps(j) - min_del(j); + else + ps(j) = p(j) + del(j); + tp = p(j) - del(j); + min_del(j) = 2 * del(j); + end + f1 = func (ps); + ps(j) = tp; + prt(:, j) = (f1 - func (ps)) / min_del(j); + end + end + end This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <sch...@us...> - 2010-05-25 13:50:25
|
Revision: 7342 http://octave.svn.sourceforge.net/octave/?rev=7342&view=rev Author: schloegl Date: 2010-05-25 13:50:16 +0000 (Tue, 25 May 2010) Log Message: ----------- simplify arg-list, remove obsolete leval.oct Modified Paths: -------------- trunk/octave-forge/main/optim/inst/d2_min.m trunk/octave-forge/main/optim/inst/line_min.m trunk/octave-forge/main/optim/inst/nelder_mead_min.m Removed Paths: ------------- trunk/octave-forge/main/optim/src/leval.cc Modified: trunk/octave-forge/main/optim/inst/d2_min.m =================================================================== --- trunk/octave-forge/main/optim/inst/d2_min.m 2010-05-25 12:59:43 UTC (rev 7341) +++ trunk/octave-forge/main/optim/inst/d2_min.m 2010-05-25 13:50:16 UTC (rev 7342) @@ -178,7 +178,7 @@ niter += 1; if nev(1) < maxev, break; end; - [v,d,h] = feval (d2f, {args{1:narg-1},reshape(x,sz),args{narg+1:end}}{:}); + [v,d,h] = feval (d2f, args{1:narg-1},reshape(x,sz),args{narg+1:end}); nev(2)++; if prudent && niter <= 1 && \ @@ -192,7 +192,7 @@ d = d(:); if prudent - v2 = feval (f, {args{1:narg-1},reshape(x,sz),args{narg+1:end}}{:}); + v2 = feval (f, args{1:narg-1},reshape(x,sz),args{narg+1:end}); nev(1)++; if abs(v2-v) > 0.001 * sqrt(eps) * max (abs(v2), 1) printf ("d2_min : f and d2f disagree %8.3g\n",abs(v2-v)); @@ -246,7 +246,7 @@ printf ("d2_min : Whoa!! any(isnan(xnew)) (1)\n"); end - vnew = feval (f, {args{1:narg-1},reshape(xnew,sz),args{narg+1:end}}{:}); + vnew = feval (f, args{1:narg-1},reshape(xnew,sz),args{narg+1:end}); nev(1)++; if vnew<vbest # Stash best values @@ -285,7 +285,7 @@ if any(isnan(xnew)), printf ("d2_min : Whoa!! any(isnan(xnew)) (2)\n"); end - vnew = feval (f, {args{1:narg-1},reshape(xnew,sz),args{narg+1:end}}{:}); + vnew = feval (f, args{1:narg-1},reshape(xnew,sz),args{narg+1:end}); nev(1)++; while vnew < vbest, @@ -294,7 +294,7 @@ xbest = xnew; wn = wn*ocoeff ; xnew = x+wn*dbest; - vnew = feval (f, {args{1:narg-1},reshape(xnew,sz),args{narg+1:length(args)}}{:}); + vnew = feval (f, args{1:narg-1},reshape(xnew,sz),args{narg+1:length(args)}); if verbose printf ( "Looking farther : v = %8.3g\n",vnew); end @@ -319,7 +319,7 @@ if vbest < vold ## "improvement found" if prudent - tmpv = feval (f, {args{1:narg-1},reshape(xbest,sz),args{2:end}}{:}); + tmpv = feval (f, args{1:narg-1},reshape(xbest,sz),args{2:end}); nev(1)++; if abs (tmpv-vbest) > eps @@ -342,7 +342,7 @@ abest = args; # Check whether eval (code) changes value if prudent - tmpv = feval (f, {args{1:narg-1},reshape(x,sz),args{2:end}}{:}); + tmpv = feval (f, args{1:narg-1},reshape(x,sz),args{2:end}); nev(1)++; if abs (tmpv-vbest) > max (min (100*eps,0.00001*abs(vbest)), eps) , printf ("d2_min : Whoa! Value changes by %g after eval (code)\n",\ @@ -386,7 +386,7 @@ # One last check if prudent - err = feval (f, {args{1:narg-1},reshape(xbest,sz),args{2:end}}{:}); + err = feval (f, args{1:narg-1},reshape(xbest,sz),args{2:end}); nev(1)++; if abs (err-vbest) > eps, Modified: trunk/octave-forge/main/optim/inst/line_min.m =================================================================== --- trunk/octave-forge/main/optim/inst/line_min.m 2010-05-25 12:59:43 UTC (rev 7341) +++ trunk/octave-forge/main/optim/inst/line_min.m 2010-05-25 13:50:16 UTC (rev 7342) @@ -51,12 +51,9 @@ a = 0; # was 1e-4 while (abs (velocity) > 0.000001) - arglist = {args{1:narg-1}, x+a*dx, args{narg+1:end}}; - fx = feval (f,arglist{:}); - arglist = {args{1:narg-1}, x+(a+h)*dx, args{narg+1:end}}; - fxph = feval (f,arglist{:}); - arglist = {args{1:narg-1}, x+(a-h)*dx, args{narg+1:end}}; - fxmh = feval (f,arglist{:}); + fx = feval (f,args{1:narg-1}, x+a*dx, args{narg+1:end}); + fxph = feval (f,args{1:narg-1}, x+(a+h)*dx, args{narg+1:end}); + fxmh = feval (f,args{1:narg-1}, x+(a-h)*dx, args{narg+1:end}); velocity = (fxph - fxmh)/(2*h); acceleration = (fxph - 2*fx + fxmh)/(h^2); Modified: trunk/octave-forge/main/optim/inst/nelder_mead_min.m =================================================================== --- trunk/octave-forge/main/optim/inst/nelder_mead_min.m 2010-05-25 12:59:43 UTC (rev 7341) +++ trunk/octave-forge/main/optim/inst/nelder_mead_min.m 2010-05-25 13:50:16 UTC (rev 7342) @@ -219,7 +219,7 @@ u += jumplen * randn (size (u)); for i = 1:N+1, y(i) = \ - feval (f, {args{1:narg-1},reshape(u(i,:),R,C),args{narg+1:length(args)}}{:}); + feval (f, args{1:narg-1},reshape(u(i,:),R,C),args{narg+1:length(args)}); end nev += N+1; [ymin,imin] = min(y); [ymax,imax] = max(y); @@ -251,7 +251,7 @@ ## f2 = f1 - (-1) = 2/N + 1 = (N+2)/N xnew = (2*xsum - (N+2)*u(imax,:)) / N; ## xnew = (2*xsum - N*u(imax,:)) / N; - ynew = feval (f, {args{1:narg-1},reshape(xnew,R,C),args{narg+1:length(args)}}{:}); + ynew = feval (f, args{1:narg-1},reshape(xnew,R,C),args{narg+1:length(args)}); nev++; if ynew <= ymin , # Reflection is good @@ -268,7 +268,7 @@ ## f1 = (1-2)/N = -1/N ## f2 = f1 - 2 = -1/N - 2 = -(2*N+1)/N xnew = ( -xsum + (2*N+1)*u(imax,:) ) / N; - ynew = feval (f, {args{1:narg-1},reshape(xnew,R,C),args{narg+1:length(args)}}{:}); + ynew = feval (f, args{1:narg-1},reshape(xnew,R,C),args{narg+1:length(args)}); nev++; if ynew <= ymin , # expansion improves @@ -299,7 +299,7 @@ ## f1 = (1-0.5)/N = 0.5/N ## f2 = f1 - 0.5 = 0.5*(1 - N)/N xnew = 0.5*(xsum + (N-1)*u(imax,:)) / N; - ynew = feval (f, {args{1:narg-1},reshape(xnew,R,C),args{narg+1:length(args)}}{:}); + ynew = feval (f, args{1:narg-1},reshape(xnew,R,C),args{narg+1:length(args)}); nev++; if ynew >= ymax , # New point is even worse. Contract whole @@ -316,7 +316,7 @@ else ii = [1:imin-1,imin+1:N+1]; end for i = ii y(i) = \ - ynew = feval (f, {args{1:narg-1},reshape(u(i,:),R,C),args{narg+1:length(args)}}{:}); + ynew = feval (f, args{1:narg-1},reshape(u(i,:),R,C),args{narg+1:length(args)}); end ## 'contraction' tra += 16 ; Deleted: trunk/octave-forge/main/optim/src/leval.cc =================================================================== --- trunk/octave-forge/main/optim/src/leval.cc 2010-05-25 12:59:43 UTC (rev 7341) +++ trunk/octave-forge/main/optim/src/leval.cc 2010-05-25 13:50:16 UTC (rev 7342) @@ -1,63 +0,0 @@ -// Copyright (C) 2002 Etienne Grossmann. All rights reserved. -// -// This program is free software; you can redistribute it and/or modify it -// under the terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) any -// later version. -// -// This is distributed in the hope that it will be useful, but WITHOUT -// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -// for more details. - - -#include "config.h" -#include <oct.h> -#include <octave/parse.h> - - -DEFUN_DLD (leval, args, nargout, - "-*- texinfo -*-\n\ -@deftypefn {Built-in Function} {} leval (@var{name}, @var{list})\n\ -Evaluate the function named @var{name}. All the elements in @var{list}\n\ -are passed on to the named function. For example,\n\ -\n\ -@example\n\ -leval (\"acos\", list (-1))\n\ - @result{} 3.1416\n\ -@end example\n\ -\n\ -@noindent\n\ -calls the function @code{acos} with the argument @samp{-1}.\n\ -\n\ -The function @code{leval} provides provides more flexibility than\n\ -@code{feval} since arguments need not be hard-wired in the calling \n\ -code. @seealso{feval and eval}\n\ -@end deftypefn") -{ - octave_value_list retval; - - int nargin = args.length (); - - if (nargin == 2) - { - std::string name = args(0).string_value (); - if (error_state) - error ("leval: first argument must be a string"); - - octave_value_list lst = args(1).list_value (); - if (error_state) - error ("leval: second argument must be a list"); - - retval = feval (name, lst, nargout); - - } - else - print_usage (); - - return retval; -} - -/* -%!assert(leval("acos", list(-1)), pi, 100*eps); - */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <i7...@us...> - 2010-06-12 11:39:43
|
Revision: 7426 http://octave.svn.sourceforge.net/octave/?rev=7426&view=rev Author: i7tiol Date: 2010-06-12 11:39:37 +0000 (Sat, 12 Jun 2010) Log Message: ----------- - INDEX: added optim_problems, - optim_problems.m: added schittkowski 327, general constraint and bounds, - leasqr.m: fixed typo in passing bounds to df_gencstr, - optim_problems_p_r_y.data: added file (forgotten in previous commit). Modified Paths: -------------- trunk/octave-forge/main/optim/INDEX trunk/octave-forge/main/optim/inst/leasqr.m trunk/octave-forge/main/optim/inst/optim_problems.m Added Paths: ----------- trunk/octave-forge/main/optim/inst/private/optim_problems_p_r_y.data Modified: trunk/octave-forge/main/optim/INDEX =================================================================== --- trunk/octave-forge/main/optim/INDEX 2010-06-12 10:48:17 UTC (rev 7425) +++ trunk/octave-forge/main/optim/INDEX 2010-06-12 11:39:37 UTC (rev 7426) @@ -32,6 +32,7 @@ test_d2_min_1 test_d2_min_2 test_d2_min_3 test_nelder_mead_min_1 test_nelder_mead_min_2 poly_2_ex test_minimize_1 + optim_problems Examples bfgsmin_example rosenbrock Modified: trunk/octave-forge/main/optim/inst/leasqr.m =================================================================== --- trunk/octave-forge/main/optim/inst/leasqr.m 2010-06-12 10:48:17 UTC (rev 7425) +++ trunk/octave-forge/main/optim/inst/leasqr.m 2010-06-12 11:39:37 UTC (rev 7426) @@ -506,7 +506,7 @@ df_gencstr (f(nidxh(idx(nidxh))), p, dp, ... @ (tp) f_gencstr (tp, idx(nidxh)), ... idx(nidxh), ... - dfdp_bounds)); + dfdp_bounds{:})); if (any (~isinf (maxstep))) warning ('setting both a maximum fractional step change of parameters and general constraints may result in inefficiency and failure'); end Modified: trunk/octave-forge/main/optim/inst/optim_problems.m =================================================================== --- trunk/octave-forge/main/optim/inst/optim_problems.m 2010-06-12 10:48:17 UTC (rev 7425) +++ trunk/octave-forge/main/optim/inst/optim_problems.m 2010-06-12 11:39:37 UTC (rev 7426) @@ -92,7 +92,10 @@ %% parameters + v >|>=|== 0; .general: handle of internally defined %% function h with h (p) >|>=|== 0; possibly .general_dcdp: handle of %% internally defined function (argument: parameters) returning the - %% jacobian of the constraints given in .general. + %% jacobian of the constraints given in .general. For the sake of + %% optimizers which can exploit this, the function in subfield + %% .general may accept a logical index vector as an optional second + %% argument, returning only the indexed constraint values. %% Please keep the following list of problems current. @@ -113,7 +116,18 @@ %% dynamic modeling. To assess optimizers, .init_p_f should be used %% with 1:64. There should be two groups of results, indicating the %% presence of two local minima. Olaf Till <ola...@un...> - + %% + %% .....schittkowski_...: Klaus Schittkowski: 'More test examples for + %% nonlinear programming codes.' Lecture Notes in Economics and + %% Mathematical Systems 282, Berlin 1987. The published problems are + %% numbered from 201 to 395 and may appear here under the fields + %% .curve, .general, or .zero. + %% + %% .curve.schittkowski_327: Two parameters, one general inequality + %% constraint, two bounds. The best solution given in the publication + %% seems not very good (it probably has been achieved with general + %% minimization, not curve fitting) and has been replaced here by a + %% better. if (~exist ('OCTAVE_VERSION')) NA = NaN; end @@ -351,6 +365,47 @@ -5.0039950796246986e+00, -7.9749636293721071e+00]; ret.curve.p_r.f = @ (x, p) f_r (x, p, hook); + ret.curve.schittkowski_327.dfdp = ... + @ (x, p) [1 + exp(-p(2) * (x - 8)), ... + (p(1) + .49) * (8 - x) .* exp (-p(2) * (x - 8))]; + ret.curve.schittkowski_327.init_p = [.42; 5]; + ret.curve.schittkowski_327.data.x = ... + [8; 8; 10; 10; 10; 10; 12; 12; 12; 12; 14; 14; 14; 16; 16; 16; ... + 18; 18; 20; 20; 20; 22; 22; 22; 24; 24; 24; 26; 26; 26; 28; ... + 28; 30; 30; 30; 32; 32; 34; 36; 36; 38; 38; 40; 42]; + ret.curve.schittkowski_327.data.y= ... + [.49; .49; .48; .47; .48; .47; .46; .46; .45; .43; .45; .43; \ + .43; .44; .43; .43; .46; .45; .42; .42; .43; .41; .41; .40; \ + .42; .40; .40; .41; .40; .41; .41; .40; .40; .40; .38; .41; \ + .40; .40; .41; .38; .40; .40; .39; .39]; + ret.curve.schittkowski_327.data.wt = []; + ret.curve.schittkowski_327.data.cov = []; + %% This result was given by Schittkowski. No constraint is active + %% here. The second parameter is unchanged from initial value. + %% + %% ret.curve.schittkowski_327.result.p = [.4219; 5]; + %% ret.curve.schittkowski_327.result.obj = .0307986; + %% + %% This is the result of leasqr of Octave Forge. The general + %% constraint is active here. Both parameters are different from + %% initial value. The value of the objective function is better. + %% + ret.curve.schittkowski_327.result.p = [.4199227; 1.2842958]; + ret.curve.schittkowski_327.result.obj = .0284597; + ret.curve.schittkowski_327.strict_inequc.bounds = []; + ret.curve.schittkowski_327.strict_inequc.linear = []; + ret.curve.schittkowski_327.strict_inequc.general = []; + ret.curve.schittkowski_327.non_strict_inequc.bounds = [.4, Inf; ... + .4, Inf]; + ret.curve.schittkowski_327.non_strict_inequc.linear = []; + ret.curve.schittkowski_327.non_strict_inequc.general = ... + @ (p, varargin) apply_idx_if_given ... + (-.09 - p(1) * p(2) + .49 * p(2), varargin{:}); + ret.curve.schittkowski_327.equc.linear = []; + ret.curve.schittkowski_327.equc.general = []; + ret.curve.schittkowski_327.f = ... + @ (x, p) p(1) + (.49 - p(1)) * exp (-p(2) * (x - 8)); + function ret = f_1 (x, p) ret = p(1) + x(:, 1) ./ (p(2) * x(:, 2) + p(3) * x(:, 3)); @@ -833,6 +888,12 @@ (y(:, idx + 1) - y(:, idx)) ./ ... repmat (x(idx + 1) - x(idx), m, 1); + function ret = apply_idx_if_given (ret, idx) + + if (nargin > 1) + ret = ret(idx); + end + %!demo %! p_t = optim_problems ().curve.p_1; %! global verbose; Added: trunk/octave-forge/main/optim/inst/private/optim_problems_p_r_y.data =================================================================== --- trunk/octave-forge/main/optim/inst/private/optim_problems_p_r_y.data (rev 0) +++ trunk/octave-forge/main/optim/inst/private/optim_problems_p_r_y.data 2010-06-12 11:39:37 UTC (rev 7426) @@ -0,0 +1,675 @@ + 0.74474 + 0.704907943019318 + 0.6783600455187353 + 0.6638710199213019 + 0.6493922050536766 + 0.644562529854532 + 0.6373129116909114 + 0.6409377207727217 + 0.6312783703744327 + 0.6312783703744327 + 0.6300735042570986 + 0.6252438290579542 + 0.6228340968232858 + 0.6204141538588096 + 0.6192092877414755 + 0.6143796125423311 + 0.6095601480729944 + 0.6107650141903287 + 0.6047304728738501 + 0.603515396026708 + 0.5999007976747056 + 0.5950711224755612 + 0.5950711224755612 + 0.5902414472764167 + 0.5914463133937508 + 0.5793772307607936 + 0.5769674985261253 + 0.5733426894443149 + 0.5673081481278364 + 0.5600687406940237 + 0.5552390654948792 + 0.5516142564130688 + 0.5455797150965902 + 0.5407500398974457 + 0.533510632463633 + 0.5274760911471544 + 0.5214415498306758 + 0.5117821994323869 + 0.5057476581159083 + 0.4973033845647614 + 0.4912688432482828 + 0.4852343019318041 + 0.4743700854161811 + 0.4695404102170366 + 0.4586761937014135 + 0.4514367862676008 + 0.442982301986646 + 0.432118085471023 + 0.4248786780372102 + 0.4152193276389213 + 0.4055701879704403 + 0.3959108375721513 + 0.3862514871738624 + 0.3765921367755734 + 0.3669429971070924 + 0.3560787805914694 + 0.3452145640758463 + 0.3355552136775573 + 0.3234861310446001 + 0.3126219145289771 + 0.301757698013354 + 0.2908934814977309 + 0.2788243988647737 + 0.2703801253136268 + 0.2595159087980037 + 0.2486516922823807 + 0.2389923418840917 + 0.2281281253684687 + 0.2136493105008432 + 0.2063996923372225 + 0.1943306097042653 + 0.1858863361531184 + 0.1738172535201612 + 0.1641579031218723 + 0.1557034188409175 + 0.1448494130551023 + 0.1351900626568134 + 0.1255307122585245 + 0.1158713618602355 + 0.1062222221917545 + 0.1001876808752759 + 0.08811859824231871 + 0.08207384619603218 + 0.07242470652755117 + 0.74474 + 0.71282 + 0.65963 + 0.61589 + 0.57451 + 0.54614 + 0.52723 + 0.51186 + 0.5024 + 0.49058 + 0.47994 + 0.4764 + 0.47403 + 0.46931 + 0.46458 + 0.46103 + 0.45867 + 0.45394 + 0.45039 + 0.45039 + 0.44921 + 0.4433 + 0.44093 + 0.43739 + 0.43266 + 0.43029 + 0.43148 + 0.42675 + 0.42202 + 0.41966 + 0.41611 + 0.41138 + 0.40665 + 0.40192 + 0.39838 + 0.39483 + 0.38892 + 0.38419 + 0.38183 + 0.37473 + 0.37001 + 0.3641 + 0.35819 + 0.35346 + 0.34873 + 0.33927 + 0.33218 + 0.32509 + 0.31799 + 0.31326 + 0.30617 + 0.29908 + 0.28962 + 0.28135 + 0.27189 + 0.26598 + 0.25889 + 0.24943 + 0.24234 + 0.2317 + 0.22106 + 0.21278 + 0.20333 + 0.19505 + 0.18796 + 0.1785 + 0.17023 + 0.15841 + 0.14895 + 0.14422 + 0.13476 + 0.12412 + 0.11703 + 0.10994 + 0.09693 + 0.08984 + 0.08037999999999999 + 0.07328999999999999 + 0.06738 + 0.05674 + 0.0532 + 0.04492 + 0.04137 + 0.03428 + 0.74474 + 0.711827416514371 + 0.6594168081630392 + 0.6106665905189123 + 0.5643497593730962 + 0.5314371758874674 + 0.5046183696073544 + 0.4863370379908068 + 0.474149483579775 + 0.4619619291687433 + 0.4534244545051779 + 0.4448972908013512 + 0.4424535933433017 + 0.4351431228886304 + 0.4314827321814254 + 0.4290493456831145 + 0.4253889549759095 + 0.4205118710195492 + 0.4168617912720828 + 0.4180784845212382 + 0.4132014005648778 + 0.4107680140665669 + 0.4095513208174115 + 0.407107623359362 + 0.4022305394030015 + 0.403447232652157 + 0.3973534554466411 + 0.3961367621974857 + 0.3924866824500193 + 0.3900429849919698 + 0.3888262917428144 + 0.3839492077864539 + 0.3778554305809381 + 0.3766387373317826 + 0.3741950398737331 + 0.3681012626682172 + 0.3668845694190618 + 0.3620074854627014 + 0.357130401506341 + 0.3522636285097192 + 0.3473865445533587 + 0.3437261538461538 + 0.3376323766406379 + 0.3327552926842775 + 0.3303219061859666 + 0.3254448222296062 + 0.3181343517749349 + 0.3108135703605249 + 0.3059364864041645 + 0.2974093227003378 + 0.2925322387439774 + 0.285221768289306 + 0.2791279910837902 + 0.2718072096693803 + 0.2608466594672426 + 0.258402962009193 + 0.2486487940964723 + 0.2437820210998504 + 0.235244546436285 + 0.2291507692307692 + 0.2181799080688929 + 0.2096527443650661 + 0.2011152697015008 + 0.192588105997674 + 0.1828339380849532 + 0.1779568541285927 + 0.1682026862158719 + 0.1608922157612006 + 0.1511380478484798 + 0.1450442706429639 + 0.1365171069391372 + 0.1267629390264163 + 0.1170087711136955 + 0.1084816074098687 + 0.1011711369551974 + 0.09141696904247659 + 0.08410649858780528 + 0.07556902392423989 + 0.06582516697125766 + 0.06216477626405272 + 0.05485430580938139 + 0.04753352439497147 + 0.04265644043861105 + 0.03169589023647339 + 0.02559180207121891 + 0.74474 + 0.724082753053198 + 0.6706308419236873 + 0.6171686535568895 + 0.5637167424273788 + 0.5175513925343269 + 0.482321023114607 + 0.4543772149313461 + 0.4325072539846822 + 0.4154984262747533 + 0.4021277405644104 + 0.3924157513282274 + 0.3802680568550335 + 0.3754069236182985 + 0.3693330763817015 + 0.3644719431449665 + 0.3583980959083695 + 0.3571853819085076 + 0.3535369626716345 + 0.3498885434347616 + 0.3462504014351755 + 0.3438146961981646 + 0.3413892681984406 + 0.3401765541985786 + 0.3365281349617056 + 0.3328797157248327 + 0.3304542877251087 + 0.3292415737252467 + 0.3243804404885117 + 0.3219447352515007 + 0.3207320212516387 + 0.3207320212516387 + 0.3170938792520527 + 0.3134454600151797 + 0.3110097547781688 + 0.3025104795418478 + 0.3025104795418478 + 0.3012977655419857 + 0.2988620603049748 + 0.2927882130683778 + 0.2915754990685158 + 0.2830762238321949 + 0.2782150905954598 + 0.2794278045953219 + 0.2733539573587249 + 0.2697055381218519 + 0.263631690885255 + 0.25877055764852 + 0.253909424411785 + 0.249058568412337 + 0.244197435175602 + 0.239336301938867 + 0.2332624547022701 + 0.2247529022286621 + 0.2186790549920651 + 0.2186790549920651 + 0.2113924937556061 + 0.2041059325191472 + 0.1955963800455392 + 0.1907352468088042 + 0.1834486855723453 + 0.1761621243358863 + 0.1700882770992893 + 0.1640144298626923 + 0.1555048773890844 + 0.1494310301524874 + 0.1457928881529014 + 0.1336349164424205 + 0.1287840604429725 + 0.1202745079693645 + 0.1142006607327675 + 0.1044783942592976 + 0.09840454702270061 + 0.09111798578624163 + 0.08383142454978265 + 0.07532187207617469 + 0.07046073883943972 + 0.06438689160284275 + 0.05588761636652177 + 0.04860105513006278 + 0.04373992189332781 + 0.03523036941971986 + 0.03159222742013386 + 0.02673109418339888 + 0.0218699609466639 + 0.01822154170979093 + 0.74474 + 0.7339284058287399 + 0.6894829989630519 + 0.6306289073841619 + 0.5693665941712601 + 0.5069052507777111 + 0.4528472799214102 + 0.407202842875075 + 0.3663646878240462 + 0.3387361873055722 + 0.3099086566064509 + 0.2918927200785897 + 0.272667592097364 + 0.258258907384162 + 0.2486463433935491 + 0.2390337794029362 + 0.2306304068656879 + 0.2246250946897342 + 0.2198188126944278 + 0.2150125306991213 + 0.2090072185231676 + 0.2053999667085084 + 0.2042009365278611 + 0.1993946545325547 + 0.1957975639906129 + 0.1921903121759537 + 0.1909912819953064 + 0.1885830603612945 + 0.1849859698193527 + 0.1825777481853408 + 0.1801796878240463 + 0.1717661540140807 + 0.1777816274627517 + 0.1741743756480926 + 0.1705671238334334 + 0.1681690634721388 + 0.1669700332914915 + 0.1657608418381269 + 0.1621637512961851 + 0.1609647211155378 + 0.1573574693008787 + 0.1525511873055722 + 0.1525511873055722 + 0.148943935490913 + 0.1477449053102658 + 0.1429386233149593 + 0.1405405629536648 + 0.1393415327730175 + 0.1345352507777111 + 0.1297289687824046 + 0.1261217169677454 + 0.1249226867870982 + 0.1201164047917917 + 0.1153101227964853 + 0.1117130322545435 + 0.106906750259237 + 0.1032994984445779 + 0.09729418626862413 + 0.09489612590732958 + 0.09008984391202314 + 0.0852835619167167 + 0.08047727992141025 + 0.07688018937946843 + 0.07327293756480925 + 0.06966568575015007 + 0.06486956502756099 + 0.06006328303225454 + 0.05405797085630082 + 0.05164974922228893 + 0.04444540686568793 + 0.04083815505102876 + 0.03724106450908694 + 0.03243478251378049 + 0.02882753069912132 + 0.02642947033782677 + 0.02042415816187305 + 0.01561787616656661 + 0.01081159417126016 + 0.00961256399061289 + 0.007204342356600993 + 0 + -0.004806281995306445 + -0.003607251814659171 + -0.01320965453255471 + 0.74474 + 0.7375021906482698 + 0.7061757284822601 + 0.6519431288326764 + 0.5928989150788435 + 0.5278197954993429 + 0.4675726782194481 + 0.4073153668418747 + 0.3591074789202803 + 0.3157315932982917 + 0.2819891299824792 + 0.2518553772448532 + 0.2289594338589575 + 0.2096823951489269 + 0.1964300681668857 + 0.183167547087166 + 0.1735341247809899 + 0.1626876048510731 + 0.1542468919732808 + 0.1482221802452913 + 0.143400372043364 + 0.1397916614651774 + 0.1361727567893123 + 0.131350948587385 + 0.1289451415352606 + 0.1253262368593955 + 0.1217175262812089 + 0.1168957180792816 + 0.1168957180792816 + 0.1144797169294788 + 0.1120739098773544 + 0.1120739098773544 + 0.1096579087275515 + 0.1072521016754271 + 0.1060491981493649 + 0.1024302934734998 + 0.1024302934734998 + 0.09881138879763469 + 0.0976084852715725 + 0.0976084852715725 + 0.0964055817455103 + 0.0927866770696452 + 0.09038087001752081 + 0.09038087001752081 + 0.08555906181559352 + 0.08676196534165571 + 0.08435615828953132 + 0.07953435008760404 + 0.07712854303547963 + 0.07591544541173893 + 0.07350963835961453 + 0.07110383130749015 + 0.06868783015768724 + 0.06386602195575997 + 0.06507911957950065 + 0.06146021490363557 + 0.05904421375383268 + 0.05423259964958388 + 0.05301950202584318 + 0.04941079144765659 + 0.0457918867717915 + 0.04097007856986421 + 0.03736136799167761 + 0.03494536684187472 + 0.03133665626368813 + 0.03253955978975032 + 0.02771775158782304 + 0.02651484806176084 + 0.02409884691195795 + 0.01927703871003066 + 0.01566832813184407 + 0.01325232698204117 + 0.01084651992991678 + 0.009643616403854577 + 0.007227615254051686 + 0.001202903526062199 + 0.002405807052124398 + -0.002405807052124398 + -0.001202903526062199 + -0.00361890467586509 + -0.00361890467586509 + -0.004821808201927289 + -0.006024711727989488 + -0.006024711727989488 + 0.74474 + 0.7374888614235295 + 0.7229763569947404 + 0.6842967997363325 + 0.6347251936994465 + 0.5754785847100344 + 0.5089910644200003 + 0.4473308183303808 + 0.3844637536906576 + 0.3300546461775086 + 0.2768625844903116 + 0.2357591628558481 + 0.1982761968716956 + 0.1680545967398618 + 0.1438670893585465 + 0.1257341292794463 + 0.1100148063005534 + 0.09430571059750889 + 0.08342388909487909 + 0.07374888614235295 + 0.07011820321619357 + 0.06407388318982683 + 0.05923638171356377 + 0.05440910751314904 + 0.04957160603688598 + 0.04473410456062291 + 0.0459409231107266 + 0.04352728601051923 + 0.04231024018456721 + 0.03989660308435986 + 0.03748296598415249 + 0.03748296598415249 + 0.03626592015820047 + 0.03264546450788942 + 0.0338522830579931 + 0.03264546450788942 + 0.03264546450788942 + 0.03143864595778574 + 0.03022160013183373 + 0.02780796303162636 + 0.02660114448152268 + 0.02660114448152268 + 0.02660114448152268 + 0.02538409865557066 + 0.0229704615553633 + 0.02417728010546698 + 0.02055682445515594 + 0.02055682445515594 + 0.01933977862920392 + 0.02176364300525961 + 0.01692614152899655 + 0.01692614152899655 + 0.01571932297889287 + 0.01451250442878919 + 0.01208864005273349 + 0.01208864005273349 + 0.008457957126574107 + 0.009675002952526126 + 0.009675002952526126 + 0.008457957126574107 + 0.007251138576470427 + 0.004837501476263063 + 0.002413637100207363 + 0 + 0.001206818550103682 + 0 + 0 + -0.001206818550103682 + -0.003630682926159381 + -0.008457957126574107 + -0.002413637100207363 + -0.004837501476263063 + -0.004837501476263063 + -0.006044320026366745 + -0.004837501476263063 + -0.007251138576470427 + -0.007251138576470427 + -0.007251138576470427 + -0.008457957126574107 + -0.008457957126574107 + -0.008457957126574107 + -0.008457957126574107 + -0.009675002952526126 + -0.007251138576470427 + 0.74474 + 0.745952713999862 + 0.73501773352653 + 0.7143604865797281 + 0.6730562699234113 + 0.6244552147933484 + 0.5685778756641137 + 0.5054036980611329 + 0.4397938152211412 + 0.3814807708548955 + 0.3170938792520527 + 0.2672801101221279 + 0.2186790549920651 + 0.1773748383357483 + 0.1409317549161664 + 0.1117752327330435 + 0.08990527178637962 + 0.07046073883943972 + 0.05467490236665976 + 0.04373992189332781 + 0.03280494141999585 + 0.02794380818326088 + 0.0218699609466639 + 0.01822154170979093 + 0.01458339971020492 + 0.01093498047333195 + 0.009722266473469951 + 0.008499275236320982 + 0.006073847236596978 + 0.004861133236734975 + 0.003648419236872973 + 0.002425427999724004 + 0.002425427999724004 + 0.002425427999724004 + 0.003648419236872973 + 0 + 0.001212713999862002 + -0.001212713999862002 + 0.002425427999724004 + -0.001212713999862002 + -0.001212713999862002 + -0.001212713999862002 + -0.001212713999862002 + -0.002425427999724004 + -0.002425427999724004 + -0.002425427999724004 + -0.004861133236734975 + -0.004861133236734975 + -0.002425427999724004 + -0.004861133236734975 + -0.003648419236872973 + -0.003648419236872973 + -0.006073847236596978 + -0.004861133236734975 + -0.004861133236734975 + -0.00728656123645898 + -0.004861133236734975 + -0.006073847236596978 + -0.006073847236596978 + -0.00728656123645898 + -0.00728656123645898 + -0.006073847236596978 + -0.00728656123645898 + -0.009722266473469951 + -0.008499275236320982 + -0.00728656123645898 + -0.00728656123645898 + -0.008499275236320982 + -0.008499275236320982 + -0.008499275236320982 + -0.00728656123645898 + -0.01093498047333195 + -0.00728656123645898 + -0.009722266473469951 + -0.00728656123645898 + -0.00728656123645898 + -0.008499275236320982 + -0.008499275236320982 + -0.01093498047333195 + -0.008499275236320982 + -0.009722266473469951 + -0.008499275236320982 + -0.009722266473469951 + -0.00728656123645898 This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <car...@us...> - 2012-03-30 11:56:35
|
Revision: 10111 http://octave.svn.sourceforge.net/octave/?rev=10111&view=rev Author: carandraug Date: 2012-03-30 11:56:24 +0000 (Fri, 30 Mar 2012) Log Message: ----------- optim: mention deprecated functions on NEWS and make warning appear only once per session Modified Paths: -------------- trunk/octave-forge/main/optim/NEWS trunk/octave-forge/main/optim/inst/fminunc_compat.m trunk/octave-forge/main/optim/inst/optimset_compat.m Modified: trunk/octave-forge/main/optim/NEWS =================================================================== --- trunk/octave-forge/main/optim/NEWS 2012-03-30 11:10:16 UTC (rev 10110) +++ trunk/octave-forge/main/optim/NEWS 2012-03-30 11:56:24 UTC (rev 10111) @@ -1,6 +1,9 @@ -Summary of important user-visible changes for optim 1.0.18: +Summary of important user-visible changes for optim 1.1.0: ------------------------------------------------------------------- - ** The package makefile has been adapted for compatibility with Octave 3.6.0. + ** The following functions have been deprecated since they have been + implemented in Octave core: - ** There is now a 'NEWS' file. + fminunc_compat optimset_compat + + ** The package Makefile has been adapted for compatibility with Octave 3.6.0. Modified: trunk/octave-forge/main/optim/inst/fminunc_compat.m =================================================================== --- trunk/octave-forge/main/optim/inst/fminunc_compat.m 2012-03-30 11:10:16 UTC (rev 10110) +++ trunk/octave-forge/main/optim/inst/fminunc_compat.m 2012-03-30 11:56:24 UTC (rev 10111) @@ -42,9 +42,15 @@ ## the 'backend' option of minimize(). ## ## This function is a front-end to minimize(). + function [x,fval,flag,out,df,d2f] = fminunc_compat (fun,x0,opt,varargin) - warning ("'fminunc_compat' has been deprecated in favor of 'fminunc', which is now part of core Octave. This function will possibly be removed from future versions of the 'optim' package."); + persistent warned = false; + if (! warned) + warned = true; + warning ("Octave:deprecated-function", + "`fminunc_compat' has been deprecated, and will be removed in the future. Use `fminunc' from Octave core instead."); + endif if nargin < 3, opt = struct (); end if nargin > 3, Modified: trunk/octave-forge/main/optim/inst/optimset_compat.m =================================================================== --- trunk/octave-forge/main/optim/inst/optimset_compat.m 2012-03-30 11:10:16 UTC (rev 10110) +++ trunk/octave-forge/main/optim/inst/optimset_compat.m 2012-03-30 11:56:24 UTC (rev 10111) @@ -41,7 +41,12 @@ ## Display , ["off","iter","notify","final"] ## : N/A - warning ("'optimset_compat' has been deprecated in favor of 'optimset', which is now part of core Octave. This function will possibly be removed from future versions of the 'optim' package."); + persistent warned = false; + if (! warned) + warned = true; + warning ("Octave:deprecated-function", + "`optimset_compat' has been deprecated, and will be removed in the future. Use `optimset' from Octave core instead."); + endif args = varargin; This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <car...@us...> - 2012-03-30 15:15:02
|
Revision: 10116 http://octave.svn.sourceforge.net/octave/?rev=10116&view=rev Author: carandraug Date: 2012-03-30 15:14:48 +0000 (Fri, 30 Mar 2012) Log Message: ----------- optim: upgrade license to GPLv3+ and mention on DESCRIPTION the other package licenses Modified Paths: -------------- trunk/octave-forge/main/optim/COPYING trunk/octave-forge/main/optim/DESCRIPTION trunk/octave-forge/main/optim/inst/LinearRegression.m trunk/octave-forge/main/optim/inst/__bracket_min.m trunk/octave-forge/main/optim/inst/__poly_2_extrema.m trunk/octave-forge/main/optim/inst/__semi_bracket.m trunk/octave-forge/main/optim/inst/adsmax.m trunk/octave-forge/main/optim/inst/battery.m trunk/octave-forge/main/optim/inst/bfgsmin.m trunk/octave-forge/main/optim/inst/bfgsmin_example.m trunk/octave-forge/main/optim/inst/brent_line_min.m trunk/octave-forge/main/optim/inst/cdiff.m trunk/octave-forge/main/optim/inst/cg_min.m trunk/octave-forge/main/optim/inst/cpiv_bard.m trunk/octave-forge/main/optim/inst/curvefit_stat.m trunk/octave-forge/main/optim/inst/d2_min.m trunk/octave-forge/main/optim/inst/dcdp.m trunk/octave-forge/main/optim/inst/de_min.m trunk/octave-forge/main/optim/inst/deriv.m trunk/octave-forge/main/optim/inst/dfdp.m trunk/octave-forge/main/optim/inst/dfpdp.m trunk/octave-forge/main/optim/inst/dfxpdp.m trunk/octave-forge/main/optim/inst/expfit.m trunk/octave-forge/main/optim/inst/fmin.m trunk/octave-forge/main/optim/inst/fmins.m trunk/octave-forge/main/optim/inst/fminsearch.m trunk/octave-forge/main/optim/inst/fminunc_compat.m trunk/octave-forge/main/optim/inst/gjp.m trunk/octave-forge/main/optim/inst/jacobs.m trunk/octave-forge/main/optim/inst/leasqr.m trunk/octave-forge/main/optim/inst/line_min.m trunk/octave-forge/main/optim/inst/linprog.m trunk/octave-forge/main/optim/inst/mdsmax.m trunk/octave-forge/main/optim/inst/minimize.m trunk/octave-forge/main/optim/inst/nelder_mead_min.m trunk/octave-forge/main/optim/inst/nmsmax.m trunk/octave-forge/main/optim/inst/nonlin_curvefit.m trunk/octave-forge/main/optim/inst/nonlin_residmin.m trunk/octave-forge/main/optim/inst/nrm.m trunk/octave-forge/main/optim/inst/optim_problems.m trunk/octave-forge/main/optim/inst/optimset_compat.m trunk/octave-forge/main/optim/inst/polyconf.m trunk/octave-forge/main/optim/inst/polyfitinf.m trunk/octave-forge/main/optim/inst/powell.m trunk/octave-forge/main/optim/inst/private/__dfdp__.m trunk/octave-forge/main/optim/inst/private/__lm_svd__.m trunk/octave-forge/main/optim/inst/residmin_stat.m trunk/octave-forge/main/optim/inst/rosenbrock.m trunk/octave-forge/main/optim/inst/samin_example.m trunk/octave-forge/main/optim/inst/test_d2_min_1.m trunk/octave-forge/main/optim/inst/test_d2_min_2.m trunk/octave-forge/main/optim/inst/test_d2_min_3.m trunk/octave-forge/main/optim/inst/test_fminunc_1.m trunk/octave-forge/main/optim/inst/test_min_1.m trunk/octave-forge/main/optim/inst/test_min_2.m trunk/octave-forge/main/optim/inst/test_min_3.m trunk/octave-forge/main/optim/inst/test_min_4.m trunk/octave-forge/main/optim/inst/test_minimize_1.m trunk/octave-forge/main/optim/inst/test_nelder_mead_min_1.m trunk/octave-forge/main/optim/inst/test_nelder_mead_min_2.m trunk/octave-forge/main/optim/inst/test_wpolyfit.m trunk/octave-forge/main/optim/inst/vfzero.m trunk/octave-forge/main/optim/inst/wpolyfit.m trunk/octave-forge/main/optim/inst/wrap_f_dfdp.m trunk/octave-forge/main/optim/inst/wsolve.m trunk/octave-forge/main/optim/src/__bfgsmin.cc trunk/octave-forge/main/optim/src/__disna_optim__.cc trunk/octave-forge/main/optim/src/numgradient.cc trunk/octave-forge/main/optim/src/numhessian.cc trunk/octave-forge/main/optim/src/samin.cc Modified: trunk/octave-forge/main/optim/COPYING =================================================================== --- trunk/octave-forge/main/optim/COPYING 2012-03-30 15:02:12 UTC (rev 10115) +++ trunk/octave-forge/main/optim/COPYING 2012-03-30 15:14:48 UTC (rev 10116) @@ -1,337 +1 @@ - GNU GENERAL PUBLIC LICENSE - Version 2, June 1991 - - Copyright (C) 1989, 1991 Free Software Foundation, Inc. <http://fsf.org/> - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - - Preamble - - The licenses for most software are designed to take away your -freedom to share and change it. By contrast, the GNU General Public -License is intended to guarantee your freedom to share and change free -software--to make sure the software is free for all its users. This -General Public License applies to most of the Free Software -Foundation's software and to any other program whose authors commit to -using it. (Some other Free Software Foundation software is covered by -the GNU Library General Public License instead.) You can apply it to -your programs, too. - - When we speak of free software, we are referring to freedom, not -price. Our General Public Licenses are designed to make sure that you -have the freedom to distribute copies of free software (and charge for -this service if you wish), that you receive source code or can get it -if you want it, that you can change the software or use pieces of it -in new free programs; and that you know you can do these things. - - To protect your rights, we need to make restrictions that forbid -anyone to deny you these rights or to ask you to surrender the rights. -These restrictions translate to certain responsibilities for you if you -distribute copies of the software, or if you modify it. - - For example, if you distribute copies of such a program, whether -gratis or for a fee, you must give the recipients all the rights that -you have. You must make sure that they, too, receive or can get the -source code. And you must show them these terms so they know their -rights. - - We protect your rights with two steps: (1) copyright the software, and -(2) offer you this license which gives you legal permission to copy, -distribute and/or modify the software. - - Also, for each author's protection and ours, we want to make certain -that everyone understands that there is no warranty for this free -software. If the software is modified by someone else and passed on, we -want its recipients to know that what they have is not the original, so -that any problems introduced by others will not reflect on the original -authors' reputations. - - Finally, any free program is threatened constantly by software -patents. We wish to avoid the danger that redistributors of a free -program will individually obtain patent licenses, in effect making the -program proprietary. To prevent this, we have made it clear that any -patent must be licensed for everyone's free use or not licensed at all. - - The precise terms and conditions for copying, distribution and -modification follow. - - GNU GENERAL PUBLIC LICENSE - TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION - - 0. This License applies to any program or other work which contains -a notice placed by the copyright holder saying it may be distributed -under the terms of this General Public License. The "Program", below, -refers to any such program or work, and a "work based on the Program" -means either the Program or any derivative work under copyright law: -that is to say, a work containing the Program or a portion of it, -either verbatim or with modifications and/or translated into another -language. (Hereinafter, translation is included without limitation in -the term "modification".) Each licensee is addressed as "you". - -Activities other than copying, distribution and modification are not -covered by this License; they are outside its scope. The act of -running the Program is not restricted, and the output from the Program -is covered only if its contents constitute a work based on the -Program (independent of having been made by running the Program). -Whether that is true depends on what the Program does. - - 1. You may copy and distribute verbatim copies of the Program's -source code as you receive it, in any medium, provided that you -conspicuously and appropriately publish on each copy an appropriate -copyright notice and disclaimer of warranty; keep intact all the -notices that refer to this License and to the absence of any warranty; -and give any other recipients of the Program a copy of this License -along with the Program. - -You may charge a fee for the physical act of transferring a copy, and -you may at your option offer warranty protection in exchange for a fee. - - 2. You may modify your copy or copies of the Program or any portion -of it, thus forming a work based on the Program, and copy and -distribute such modifications or work under the terms of Section 1 -above, provided that you also meet all of these conditions: - - a) You must cause the modified files to carry prominent notices - stating that you changed the files and the date of any change. - - b) You must cause any work that you distribute or publish, that in - whole or in part contains or is derived from the Program or any - part thereof, to be licensed as a whole at no charge to all third - parties under the terms of this License. - - c) If the modified program normally reads commands interactively - when run, you must cause it, when started running for such - interactive use in the most ordinary way, to print or display an - announcement including an appropriate copyright notice and a - notice that there is no warranty (or else, saying that you provide - a warranty) and that users may redistribute the program under - these conditions, and telling the user how to view a copy of this - License. (Exception: if the Program itself is interactive but - does not normally print such an announcement, your work based on - the Program is not required to print an announcement.) - -These requirements apply to the modified work as a whole. If -identifiable sections of that work are not derived from the Program, -and can be reasonably considered independent and separate works in -themselves, then this License, and its terms, do not apply to those -sections when you distribute them as separate works. But when you -distribute the same sections as part of a whole which is a work based -on the Program, the distribution of the whole must be on the terms of -this License, whose permissions for other licensees extend to the -entire whole, and thus to each and every part regardless of who wrote it. - -Thus, it is not the intent of this section to claim rights or contest -your rights to work written entirely by you; rather, the intent is to -exercise the right to control the distribution of derivative or -collective works based on the Program. - -In addition, mere aggregation of another work not based on the Program -with the Program (or with a work based on the Program) on a volume of -a storage or distribution medium does not bring the other work under -the scope of this License. - - 3. You may copy and distribute the Program (or a work based on it, -under Section 2) in object code or executable form under the terms of -Sections 1 and 2 above provided that you also do one of the following: - - a) Accompany it with the complete corresponding machine-readable - source code, which must be distributed under the terms of Sections - 1 and 2 above on a medium customarily used for software interchange; or, - - b) Accompany it with a written offer, valid for at least three - years, to give any third party, for a charge no more than your - cost of physically performing source distribution, a complete - machine-readable copy of the corresponding source code, to be - distributed under the terms of Sections 1 and 2 above on a medium - customarily used for software interchange; or, - - c) Accompany it with the information you received as to the offer - to distribute corresponding source code. (This alternative is - allowed only for noncommercial distribution and only if you - received the program in object code or executable form with such - an offer, in accord with Subsection b above.) - -The source code for a work means the preferred form of the work for -making modifications to it. For an executable work, complete source -code means all the source code for all modules it contains, plus any -associated interface definition files, plus the scripts used to -control compilation and installation of the executable. However, as a -special exception, the source code distributed need not include -anything that is normally distributed (in either source or binary -form) with the major components (compiler, kernel, and so on) of the -operating system on which the executable runs, unless that component -itself accompanies the executable. - -If distribution of executable or object code is made by offering -access to copy from a designated place, then offering equivalent -access to copy the source code from the same place counts as -distribution of the source code, even though third parties are not -compelled to copy the source along with the object code. - - 4. You may not copy, modify, sublicense, or distribute the Program -except as expressly provided under this License. Any attempt -otherwise to copy, modify, sublicense or distribute the Program is -void, and will automatically terminate your rights under this License. -However, parties who have received copies, or rights, from you under -this License will not have their licenses terminated so long as such -parties remain in full compliance. - - 5. You are not required to accept this License, since you have not -signed it. However, nothing else grants you permission to modify or -distribute the Program or its derivative works. These actions are -prohibited by law if you do not accept this License. Therefore, by -modifying or distributing the Program (or any work based on the -Program), you indicate your acceptance of this License to do so, and -all its terms and conditions for copying, distributing or modifying -the Program or works based on it. - - 6. Each time you redistribute the Program (or any work based on the -Program), the recipient automatically receives a license from the -original licensor to copy, distribute or modify the Program subject to -these terms and conditions. You may not impose any further -restrictions on the recipients' exercise of the rights granted herein. -You are not responsible for enforcing compliance by third parties to -this License. - - 7. If, as a consequence of a court judgment or allegation of patent -infringement or for any other reason (not limited to patent issues), -conditions are imposed on you (whether by court order, agreement or -otherwise) that contradict the conditions of this License, they do not -excuse you from the conditions of this License. If you cannot -distribute so as to satisfy simultaneously your obligations under this -License and any other pertinent obligations, then as a consequence you -may not distribute the Program at all. For example, if a patent -license would not permit royalty-free redistribution of the Program by -all those who receive copies directly or indirectly through you, then -the only way you could satisfy both it and this License would be to -refrain entirely from distribution of the Program. - -If any portion of this section is held invalid or unenforceable under -any particular circumstance, the balance of the section is intended to -apply and the section as a whole is intended to apply in other -circumstances. - -It is not the purpose of this section to induce you to infringe any -patents or other property right claims or to contest validity of any -such claims; this section has the sole purpose of protecting the -integrity of the free software distribution system, which is -implemented by public license practices. Many people have made -generous contributions to the wide range of software distributed -through that system in reliance on consistent application of that -system; it is up to the author/donor to decide if he or she is willing -to distribute software through any other system and a licensee cannot -impose that choice. - -This section is intended to make thoroughly clear what is believed to -be a consequence of the rest of this License. - - 8. If the distribution and/or use of the Program is restricted in -certain countries either by patents or by copyrighted interfaces, the -original copyright holder who places the Program under this License -may add an explicit geographical distribution limitation excluding -those countries, so that distribution is permitted only in or among -countries not thus excluded. In such case, this License incorporates -the limitation as if written in the body of this License. - - 9. The Free Software Foundation may publish revised and/or new versions -of the General Public License from time to time. Such new versions will -be similar in spirit to the present version, but may differ in detail to -address new problems or concerns. - -Each version is given a distinguishing version number. If the Program -specifies a version number of this License which applies to it and "any -later version", you have the option of following the terms and conditions -either of that version or of any later version published by the Free -Software Foundation. If the Program does not specify a version number of -this License, you may choose any version ever published by the Free Software -Foundation. - - 10. If you wish to incorporate parts of the Program into other free -programs whose distribution conditions are different, write to the author -to ask for permission. For software which is copyrighted by the Free -Software Foundation, write to the Free Software Foundation; we sometimes -make exceptions for this. Our decision will be guided by the two goals -of preserving the free status of all derivatives of our free software and -of promoting the sharing and reuse of software generally. - - NO WARRANTY - - 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY -FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN -OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES -PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED -OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS -TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE -PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, -REPAIR OR CORRECTION. - - 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING -WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR -REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, -INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING -OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED -TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY -YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER -PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE -POSSIBILITY OF SUCH DAMAGES. - - END OF TERMS AND CONDITIONS - - How to Apply These Terms to Your New Programs - - If you develop a new program, and you want it to be of the greatest -possible use to the public, the best way to achieve this is to make it -free software which everyone can redistribute and change under these terms. - - To do so, attach the following notices to the program. It is safest -to attach them to the start of each source file to most effectively -convey the exclusion of warranty; and each file should have at least -the "copyright" line and a pointer to where the full notice is found. - - <one line to give the program's name and a brief idea of what it does.> - Copyright (C) <year> <name of author> - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, see <http://www.gnu.org/licenses/>. - -Also add information on how to contact you by electronic and paper mail. - -If the program is interactive, make it output a short notice like this -when it starts in an interactive mode: - - Gnomovision version 69, Copyright (C) year name of author - Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. - This is free software, and you are welcome to redistribute it - under certain conditions; type `show c' for details. - -The hypothetical commands `show w' and `show c' should show the appropriate -parts of the General Public License. Of course, the commands you use may -be called something other than `show w' and `show c'; they could even be -mouse-clicks or menu items--whatever suits your program. - -You should also get your employer (if you work as a programmer) or your -school, if any, to sign a "copyright disclaimer" for the program, if -necessary. Here is a sample; alter the names: - - Yoyodyne, Inc., hereby disclaims all copyright interest in the program - `Gnomovision' (which makes passes at compilers) written by James Hacker. - - <signature of Ty Coon>, 1 April 1989 - Ty Coon, President of Vice - -This General Public License does not permit incorporating your program into -proprietary programs. If your program is a subroutine library, you may -consider it more useful to permit linking proprietary applications with the -library. If this is what you want to do, use the GNU Library General -Public License instead of this License. +See individual files for licenses Modified: trunk/octave-forge/main/optim/DESCRIPTION =================================================================== --- trunk/octave-forge/main/optim/DESCRIPTION 2012-03-30 15:02:12 UTC (rev 10115) +++ trunk/octave-forge/main/optim/DESCRIPTION 2012-03-30 15:14:48 UTC (rev 10116) @@ -7,5 +7,5 @@ Description: Non-linear optimization toolkit. Depends: octave (>= 2.9.7), miscellaneous (>= 1.0.10), struct (>= 1.0.9) Autoload: no -License: GPL version 2 or later and GFDL +License: GFDL, GPLv3+, modified BSD, public domain Url: http://octave.sf.net Modified: trunk/octave-forge/main/optim/inst/LinearRegression.m =================================================================== --- trunk/octave-forge/main/optim/inst/LinearRegression.m 2012-03-30 15:02:12 UTC (rev 10115) +++ trunk/octave-forge/main/optim/inst/LinearRegression.m 2012-03-30 15:14:48 UTC (rev 10116) @@ -1,42 +1,41 @@ -function [p,y_var,r,p_var]=LinearRegression(F,y,weight) +## Copyright (C) 2007 Andreas Stahel <And...@bf...> +## +## This program is free software; you can redistribute it and/or modify it under +## the terms of the GNU General Public License as published by the Free Software +## Foundation; either version 3 of the License, or (at your option) any later +## version. +## +## This program is distributed in the hope that it will be useful, but WITHOUT +## ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +## details. +## +## You should have received a copy of the GNU General Public License along with +## this program; if not, see <http://www.gnu.org/licenses/>. -% general linear regression -% -% [p,y_var,r,p_var]=LinearRegression(F,y) -% [p,y_var,r,p_var]=LinearRegression(F,y,weight) -% -% determine the parameters p_j (j=1,2,...,m) such that the function -% f(x) = sum_(i=1,...,m) p_j*f_j(x) fits as good as possible to the -% given values y_i = f(x_i) -% -% parameters -% F n*m matrix with the values of the basis functions at the support points -% in column j give the values of f_j at the points x_i (i=1,2,...,n) -% y n column vector of given values -% weight n column vector of given weights -% -% return values -% p m vector with the estimated values of the parameters -% y_var estimated variance of the error -% r weighted norm of residual -% p_var estimated variance of the parameters p_j - - -## Copyright (C) 2007 Andreas Stahel <And...@bf...> +## general linear regression ## -## This program is free software; you can redistribute it and/or modify -## it under the terms of the GNU General Public License as published by -## the Free Software Foundation; either version 2 of the License, or -## (at your option) any later version. +## [p,y_var,r,p_var]=LinearRegression(F,y) +## [p,y_var,r,p_var]=LinearRegression(F,y,weight) ## -## This program is distributed in the hope that it will be useful, -## but WITHOUT ANY WARRANTY; without even the implied warranty of -## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -## GNU General Public License for more details. +## determine the parameters p_j (j=1,2,...,m) such that the function +## f(x) = sum_(i=1,...,m) p_j*f_j(x) fits as good as possible to the +## given values y_i = f(x_i) ## -## You should have received a copy of the GNU General Public License -## along with this program; If not, see <http://www.gnu.org/licenses/>. +## parameters +## F n*m matrix with the values of the basis functions at the support points +## in column j give the values of f_j at the points x_i (i=1,2,...,n) +## y n column vector of given values +## weight n column vector of given weights +## +## return values +## p m vector with the estimated values of the parameters +## y_var estimated variance of the error +## r weighted norm of residual +## p_var estimated variance of the parameters p_j +function [p,y_var,r,p_var]=LinearRegression(F,y,weight) + if (nargin < 2 || nargin >= 4) usage('wrong number of arguments in [p,y_var,r,p_var]=LinearRegression(F,y)'); end Modified: trunk/octave-forge/main/optim/inst/__bracket_min.m =================================================================== --- trunk/octave-forge/main/optim/inst/__bracket_min.m 2012-03-30 15:02:12 UTC (rev 10115) +++ trunk/octave-forge/main/optim/inst/__bracket_min.m 2012-03-30 15:14:48 UTC (rev 10116) @@ -1,3 +1,19 @@ +## Copyright (C) 2002 Etienne Grossmann <et...@is...> +## Copyright (C) 2009 Levente Torok <Tor...@gm...> +## +## This program is free software; you can redistribute it and/or modify it under +## the terms of the GNU General Public License as published by the Free Software +## Foundation; either version 3 of the License, or (at your option) any later +## version. +## +## This program is distributed in the hope that it will be useful, but WITHOUT +## ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +## details. +## +## You should have received a copy of the GNU General Public License along with +## this program; if not, see <http://www.gnu.org/licenses/>. + ## [a, b, ga, gb, nev] = semi_bracket (f, dx, a, narg, args) ## ## Find an interval containing a local minimum of the function @@ -6,10 +22,6 @@ ## a < b. ## nev is the number of function evaluations -## Author : Etienne Grossmann <et...@is...> -## Modified by: Levente Torok <Tor...@gm...> -## This software is distributed under the terms of the GPL - function [a, b, ga, gb, n] = __bracket_min (f, dx, narg, args) [a,b, ga,gb, n] = __semi_bracket (f, dx, 0, narg, args); Modified: trunk/octave-forge/main/optim/inst/__poly_2_extrema.m =================================================================== --- trunk/octave-forge/main/optim/inst/__poly_2_extrema.m 2012-03-30 15:02:12 UTC (rev 10115) +++ trunk/octave-forge/main/optim/inst/__poly_2_extrema.m 2012-03-30 15:14:48 UTC (rev 10116) @@ -1,3 +1,19 @@ +## Copyright (C) 2002 Etienne Grossmann <et...@is...> +## Copyright (C) 2009 Levente Torok <Tor...@gm...> +## +## This program is free software; you can redistribute it and/or modify it under +## the terms of the GNU General Public License as published by the Free Software +## Foundation; either version 3 of the License, or (at your option) any later +## version. +## +## This program is distributed in the hope that it will be useful, but WITHOUT +## ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +## details. +## +## You should have received a copy of the GNU General Public License along with +## this program; if not, see <http://www.gnu.org/licenses/>. + ## ex = poly_2_ex (l, f) - Extremum of a 1-var deg-2 polynomial ## ## l : 3 : variable values @@ -7,10 +23,9 @@ ## ## Assuming that f(i) = a*l(i)^2 + b* l(i) + c = P(l(i)) for some a, b, c, ## ex is the extremum of the polynome P. -## + function ex = __poly_2_extrema (l, f) - ### This somewhat helps if solution is very close to one of the points. [f,i] = sort (f); l = l(i); @@ -36,4 +51,4 @@ # ex - ex0 # end ex = l(1) + ex; -end \ No newline at end of file +end Modified: trunk/octave-forge/main/optim/inst/__semi_bracket.m =================================================================== --- trunk/octave-forge/main/optim/inst/__semi_bracket.m 2012-03-30 15:02:12 UTC (rev 10115) +++ trunk/octave-forge/main/optim/inst/__semi_bracket.m 2012-03-30 15:14:48 UTC (rev 10116) @@ -1,3 +1,19 @@ +## Copyright (C) 2002 Etienne Grossmann <et...@is...> +## Copyright (C) 2009 Levente Torok <Tor...@gm...> +## +## This program is free software; you can redistribute it and/or modify it under +## the terms of the GNU General Public License as published by the Free Software +## Foundation; either version 3 of the License, or (at your option) any later +## version. +## +## This program is distributed in the hope that it will be useful, but WITHOUT +## ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +## details. +## +## You should have received a copy of the GNU General Public License along with +## this program; if not, see <http://www.gnu.org/licenses/>. + ## [a, b, ga, gb, nev] = semi_bracket (f, dx, a, narg, args) ## ## Find an interval containing a local minimum of the function @@ -7,10 +23,6 @@ ## a < b. ## nev is the number of function evaluations. -## Author : Etienne Grossmann <et...@is...> -## Modified by: Levente Torok <Tor...@gm...> -## This software is distributed under the terms of the GPL - function [a,b,ga,gb,n] = __semi_bracket (f, dx, a, narg, args) step = 1; Modified: trunk/octave-forge/main/optim/inst/adsmax.m =================================================================== --- trunk/octave-forge/main/optim/inst/adsmax.m 2012-03-30 15:02:12 UTC (rev 10115) +++ trunk/octave-forge/main/optim/inst/adsmax.m 2012-03-30 15:14:48 UTC (rev 10116) @@ -1,44 +1,57 @@ -function [x, fmax, nf] = adsmax(f, x, stopit, savit, P, varargin) -%ADSMAX Alternating directions method for direct search optimization. -% [x, fmax, nf] = ADSMAX(FUN, x0, STOPIT, SAVIT, P) attempts to -% maximize the function FUN, using the starting vector x0. -% The alternating directions direct search method is used. -% Output arguments: -% x = vector yielding largest function value found, -% fmax = function value at x, -% nf = number of function evaluations. -% The iteration is terminated when either -% - the relative increase in function value between successive -% iterations is <= STOPIT(1) (default 1e-3), -% - STOPIT(2) function evaluations have been performed -% (default inf, i.e., no limit), or -% - a function value equals or exceeds STOPIT(3) -% (default inf, i.e., no test on function values). -% Progress of the iteration is not shown if STOPIT(5) = 0 (default 1). -% If a non-empty fourth parameter string SAVIT is present, then -% `SAVE SAVIT x fmax nf' is executed after each inner iteration. -% By default, the search directions are the co-ordinate directions. -% The columns of a fifth parameter matrix P specify alternative search -% directions (P = EYE is the default). -% NB: x0 can be a matrix. In the output argument, in SAVIT saves, -% and in function calls, x has the same shape as x0. -% ADSMAX(fun, x0, STOPIT, SAVIT, P, P1, P2,...) allows additional -% arguments to be passed to fun, via feval(fun,x,P1,P2,...). +%% Copyright (C) 2002 N.J.Higham +%% Copyright (C) 2003 Andy Adler <ad...@nc...> +%% +%% This program is free software; you can redistribute it and/or modify it under +%% the terms of the GNU General Public License as published by the Free Software +%% Foundation; either version 3 of the License, or (at your option) any later +%% version. +%% +%% This program is distributed in the hope that it will be useful, but WITHOUT +%% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +%% FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +%% details. +%% +%% You should have received a copy of the GNU General Public License along with +%% this program; if not, see <http://www.gnu.org/licenses/>. +%%ADSMAX Alternating directions method for direct search optimization. +%% [x, fmax, nf] = ADSMAX(FUN, x0, STOPIT, SAVIT, P) attempts to +%% maximize the function FUN, using the starting vector x0. +%% The alternating directions direct search method is used. +%% Output arguments: +%% x = vector yielding largest function value found, +%% fmax = function value at x, +%% nf = number of function evaluations. +%% The iteration is terminated when either +%% - the relative increase in function value between successive +%% iterations is <= STOPIT(1) (default 1e-3), +%% - STOPIT(2) function evaluations have been performed +%% (default inf, i.e., no limit), or +%% - a function value equals or exceeds STOPIT(3) +%% (default inf, i.e., no test on function values). +%% Progress of the iteration is not shown if STOPIT(5) = 0 (default 1). +%% If a non-empty fourth parameter string SAVIT is present, then +%% `SAVE SAVIT x fmax nf' is executed after each inner iteration. +%% By default, the search directions are the co-ordinate directions. +%% The columns of a fifth parameter matrix P specify alternative search +%% directions (P = EYE is the default). +%% NB: x0 can be a matrix. In the output argument, in SAVIT saves, +%% and in function calls, x has the same shape as x0. +%% ADSMAX(fun, x0, STOPIT, SAVIT, P, P1, P2,...) allows additional +%% arguments to be passed to fun, via feval(fun,x,P1,P2,...). +%% Reference: +%% N. J. Higham, Optimization by direct search in matrix computations, +%% SIAM J. Matrix Anal. Appl, 14(2): 317-333, 1993. +%% N. J. Higham, Accuracy and Stability of Numerical Algorithms, +%% Second edition, Society for Industrial and Applied Mathematics, +%% Philadelphia, PA, 2002; sec. 20.5. + % From Matrix Toolbox % Copyright (C) 2002 N.J.Higham % www.maths.man.ac.uk/~higham/mctoolbox -% distributed under the terms of the GNU General Public License -% % Modifications for octave by A.Adler 2003 -% $Id$ -% Reference: -% N. J. Higham, Optimization by direct search in matrix computations, -% SIAM J. Matrix Anal. Appl, 14(2): 317-333, 1993. -% N. J. Higham, Accuracy and Stability of Numerical Algorithms, -% Second edition, Society for Industrial and Applied Mathematics, -% Philadelphia, PA, 2002; sec. 20.5. +function [x, fmax, nf] = adsmax(f, x, stopit, savit, P, varargin) x0 = x(:); % Work with column vector internally. n = length(x0); Modified: trunk/octave-forge/main/optim/inst/battery.m =================================================================== --- trunk/octave-forge/main/optim/inst/battery.m 2012-03-30 15:02:12 UTC (rev 10115) +++ trunk/octave-forge/main/optim/inst/battery.m 2012-03-30 15:14:48 UTC (rev 10116) @@ -1,33 +1,32 @@ -# Copyright (C) 2004 Michael Creel <mic...@ua...> -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; If not, see <http://www.gnu.org/licenses/>. -# (c) Michael Creel <mic...@ua...> +## Copyright (C) 2004 Michael Creel <mic...@ua...> +## +## This program is free software; you can redistribute it and/or modify it under +## the terms of the GNU General Public License as published by the Free Software +## Foundation; either version 3 of the License, or (at your option) any later +## version. +## +## This program is distributed in the hope that it will be useful, but WITHOUT +## ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +## details. +## +## You should have received a copy of the GNU General Public License along with +## this program; if not, see <http://www.gnu.org/licenses/>. -# battery.m: repeatedly call bfgs using a battery of -# start values, to attempt to find global min -# of a nonconvex function - -# INPUTS: -# func: function to mimimize -# args: args of function -# minarg: argument to minimize w.r.t. (usually = 1) -# startvals: kxp matrix of values to try for sure (don't include all zeros, that's automatic) -# max iters per start value -# number of additional random start values to try - +## battery.m: repeatedly call bfgs using a battery of +## start values, to attempt to find global min +## of a nonconvex function +## +## INPUTS: +## func: function to mimimize +## args: args of function +## minarg: argument to minimize w.r.t. (usually = 1) +## startvals: kxp matrix of values to try for sure (don't include all zeros, that's automatic) +## max iters per start value +## number of additional random start values to try +## # OUTPUT: theta - the best value found - NOT iterated to convergence - + function theta = battery(func, args, minarg, startvals, maxiters) # setup Modified: trunk/octave-forge/main/optim/inst/bfgsmin.m =================================================================== --- trunk/octave-forge/main/optim/inst/bfgsmin.m 2012-03-30 15:02:12 UTC (rev 10115) +++ trunk/octave-forge/main/optim/inst/bfgsmin.m 2012-03-30 15:14:48 UTC (rev 10116) @@ -1,18 +1,17 @@ -## Copyright (C) 2006 Michael Creel <mic...@ua...> +## Copyright (C) 2006 Michael Creel <mic...@ua...> ## -## This program is free software; you can redistribute it and/or modify -## it under the terms of the GNU General Public License as published by -## the Free Software Foundation; either version 2 of the License, or -## (at your option) any later version. +## This program is free software; you can redistribute it and/or modify it under +## the terms of the GNU General Public License as published by the Free Software +## Foundation; either version 3 of the License, or (at your option) any later +## version. ## -## This program is distributed in the hope that it will be useful, -## but WITHOUT ANY WARRANTY; without even the implied warranty of -## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -## GNU General Public License for more details. +## This program is distributed in the hope that it will be useful, but WITHOUT +## ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +## details. ## -## You should have received a copy of the GNU General Public License -## along with this program; if not, write to the Free Software -## Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +## You should have received a copy of the GNU General Public License along with +## this program; if not, see <http://www.gnu.org/licenses/>. ## bfgsmin: bfgs or limited memory bfgs minimization of function ## Modified: trunk/octave-forge/main/optim/inst/bfgsmin_example.m =================================================================== --- trunk/octave-forge/main/optim/inst/bfgsmin_example.m 2012-03-30 15:02:12 UTC (rev 10115) +++ trunk/octave-forge/main/optim/inst/bfgsmin_example.m 2012-03-30 15:14:48 UTC (rev 10116) @@ -1,18 +1,17 @@ -# Copyright (C) 2004,2005,2006 Michael Creel <mic...@ua...> -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +## Copyright (C) 2004,2005,2006 Michael Creel <mic...@ua...> +## +## This program is free software; you can redistribute it and/or modify it under +## the terms of the GNU General Public License as published by the Free Software +## Foundation; either version 3 of the License, or (at your option) any later +## version. +## +## This program is distributed in the hope that it will be useful, but WITHOUT +## ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +## details. +## +## You should have received a copy of the GNU General Public License along with +## this program; if not, see <http://www.gnu.org/licenses/>. # usage: bfgsmin_example (to run) or edit bfgsmin_example (to examine) ## Modified: trunk/octave-forge/main/optim/inst/brent_line_min.m =================================================================== --- trunk/octave-forge/main/optim/inst/brent_line_min.m 2012-03-30 15:02:12 UTC (rev 10115) +++ trunk/octave-forge/main/optim/inst/brent_line_min.m 2012-03-30 15:14:48 UTC (rev 10116) @@ -1,3 +1,18 @@ +## Copyright (C) 2009 Levente Torok <Tor...@gm...> +## +## This program is free software; you can redistribute it and/or modify it under +## the terms of the GNU General Public License as published by the Free Software +## Foundation; either version 3 of the License, or (at your option) any later +## version. +## +## This program is distributed in the hope that it will be useful, but WITHOUT +## ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +## details. +## +## You should have received a copy of the GNU General Public License along with +## this program; if not, see <http://www.gnu.org/licenses/>. + ## -*- texinfo -*- ## @deftypefn {Function File} {[@var{s},@var{v},@var{n}]} brent_line_min ( @var{f},@var{df},@var{args},@var{ctl} ) ## Line minimization of f along df @@ -32,7 +47,6 @@ ## given. ## @end deftypefn - function [s,gs,nev] = brent_line_min( f,dx,args,ctl ) verbose = 0; Modified: trunk/octave-forge/main/optim/inst/cdiff.m =================================================================== --- trunk/octave-forge/main/optim/inst/cdiff.m 2012-03-30 15:02:12 UTC (rev 10115) +++ trunk/octave-forge/main/optim/inst/cdiff.m 2012-03-30 15:14:48 UTC (rev 10116) @@ -1,14 +1,17 @@ -## Copyright (C) 2002 Etienne Grossmann. All rights reserved. +## Copyright (C) 2002 Etienne Grossmann <et...@is...> ## -## This program is free software; you can redistribute it and/or modify it -## under the terms of the GNU General Public License as published by the -## Free Software Foundation; either version 2, or (at your option) any -## later version. +## This program is free software; you can redistribute it and/or modify it under +## the terms of the GNU General Public License as published by the Free Software +## Foundation; either version 3 of the License, or (at your option) any later +## version. ## -## This is distributed in the hope that it will be useful, but WITHOUT +## This program is distributed in the hope that it will be useful, but WITHOUT ## ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -## for more details. +## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +## details. +## +## You should have received a copy of the GNU General Public License along with +## this program; if not, see <http://www.gnu.org/licenses/>. ## c = cdiff (func,wrt,N,dfunc,stack,dx) - Code for num. differentiation ## = "function df = dfunc (var1,..,dvar,..,varN) .. endfunction @@ -42,7 +45,7 @@ ## Default:10*sqrt(eps) ## ## See also : ndiff, eval, todisk -## + function c = cdiff (func,wrt,nargs,dfunc,stack,dx) if nargin<2, Modified: trunk/octave-forge/main/optim/inst/cg_min.m =================================================================== --- trunk/octave-forge/main/optim/inst/cg_min.m 2012-03-30 15:02:12 UTC (rev 10115) +++ trunk/octave-forge/main/optim/inst/cg_min.m 2012-03-30 15:14:48 UTC (rev 10116) @@ -1,3 +1,19 @@ +## Copyright (C) 2002 Etienne Grossmann <et...@is...> +## Copyright (C) 2009 Levente Torok <Tor...@gm...> +## +## This program is free software; you can redistribute it and/or modify it under +## the terms of the GNU General Public License as published by the Free Software +## Foundation; either version 3 of the License, or (at your option) any later +## version. +## +## This program is distributed in the hope that it will be useful, but WITHOUT +## ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +## details. +## +## You should have received a copy of the GNU General Public License along with +## this program; if not, see <http://www.gnu.org/licenses/>. + ## -*- texinfo -*- ## @deftypefn {Function File} {[@var{x0},@var{v},@var{nev}]} cg_min ( @var{f},@var{df},@var{args},@var{ctl} ) ## NonLinear Conjugate Gradient method to minimize function @var{f}. @@ -54,10 +70,6 @@ ## @seealso{ bfgsmin, http://en.wikipedia.org/wiki/Nonlinear_conjugate_gradient } ## @end deftypefn -## Author : Etienne Grossmann <et...@is...> -## Modified by: Levente Torok <Tor...@gm...> -## This software is distributed under the terms of the GPL - function [x,v,nev] = cg_min (f, dfn, args, ctl) verbose = 0; Modified: trunk/octave-forge/main/optim/inst/cpiv_bard.m =================================================================== --- trunk/octave-forge/main/optim/inst/cpiv_bard.m 2012-03-30 15:02:12 UTC (rev 10115) +++ trunk/octave-forge/main/optim/inst/cpiv_bard.m 2012-03-30 15:14:48 UTC (rev 10116) @@ -1,42 +1,41 @@ -%% Copyright (C) 2010, 2011 Olaf Till +%% Copyright (C) 2010, 2011 Olaf Till <ola...@un...> %% -%% This program is free software; you can redistribute it and/or modify -%% it under the terms of the GNU General Public License as published by -%% the Free Software Foundation; either version 2 of the License, or (at -%% your option) any later version. +%% This program is free software; you can redistribute it and/or modify it under +%% the terms of the GNU General Public License as published by the Free Software +%% Foundation; either version 3 of the License, or (at your option) any later +%% version. %% -%% This program is distributed in the hope that it will be useful, but -%% WITHOUT ANY WARRANTY; without even the implied warranty of -%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -%% General Public License for more details. +%% This program is distributed in the hope that it will be useful, but WITHOUT +%% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +%% FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +%% details. %% -%% You should have received a copy of the GNU General Public License -%% along with this program; if not, write to the Free Software -%% Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301USA +%% You should have received a copy of the GNU General Public License along with +%% this program; if not, see <http://www.gnu.org/licenses/>. +%% [lb, idx, ridx, mv] = cpiv_bard (v, m[, incl]) +%% +%% v: column vector; m: matrix; incl (optional): index. length (v) +%% must equal rows (m). Finds column vectors w and l with w == v + m * +%% l, w >= 0, l >= 0, l.' * w == 0. Chooses idx, w, and l so that +%% l(~idx) == 0, l(idx) == -inv (m(idx, idx)) * v(idx), w(idx) roughly +%% == 0, and w(~idx) == v(~idx) + m(idx, ~idx).' * l(idx). idx indexes +%% at least everything indexed by incl, but l(incl) may be < 0. lb: +%% l(idx) (column vector); idx: logical index, defined above; ridx: +%% ~idx & w roughly == 0; mv: [m, v] after performing a Gauss-Jordan +%% 'sweep' (with gjp.m) on each diagonal element indexed by idx. +%% Except the handling of incl (which enables handling of equality +%% constraints in the calling code), this is called solving the +%% 'complementary pivot problem' (Cottle, R. W. and Dantzig, G. B., +%% 'Complementary pivot theory of mathematical programming', Linear +%% Algebra and Appl. 1, 102--125. References for the current +%% algorithm: Bard, Y.: Nonlinear Parameter Estimation, p. 147--149, +%% Academic Press, New York and London 1974; Bard, Y., 'An eclectic +%% approach to nonlinear programming', Proc. ANU Sem. Optimization, +%% Canberra, Austral. Nat. Univ.). + function [lb, idx, ridx, m] = cpiv_bard (v, m, incl) - %% [lb, idx, ridx, mv] = cpiv_bard (v, m[, incl]) - %% - %% v: column vector; m: matrix; incl (optional): index. length (v) - %% must equal rows (m). Finds column vectors w and l with w == v + m * - %% l, w >= 0, l >= 0, l.' * w == 0. Chooses idx, w, and l so that - %% l(~idx) == 0, l(idx) == -inv (m(idx, idx)) * v(idx), w(idx) roughly - %% == 0, and w(~idx) == v(~idx) + m(idx, ~idx).' * l(idx). idx indexes - %% at least everything indexed by incl, but l(incl) may be < 0. lb: - %% l(idx) (column vector); idx: logical index, defined above; ridx: - %% ~idx & w roughly == 0; mv: [m, v] after performing a Gauss-Jordan - %% 'sweep' (with gjp.m) on each diagonal element indexed by idx. - %% Except the handling of incl (which enables handling of equality - %% constraints in the calling code), this is called solving the - %% 'complementary pivot problem' (Cottle, R. W. and Dantzig, G. B., - %% 'Complementary pivot theory of mathematical programming', Linear - %% Algebra and Appl. 1, 102--125. References for the current - %% algorithm: Bard, Y.: Nonlinear Parameter Estimation, p. 147--149, - %% Academic Press, New York and London 1974; Bard, Y., 'An eclectic - %% approach to nonlinear programming', Proc. ANU Sem. Optimization, - %% Canberra, Austral. Nat. Univ.). - n = length (v); if (n > size (v, 1)) error ('first argument is no column vector'); % the most typical mistake Modified: trunk/octave-forge/main/optim/inst/curvefit_stat.m =================================================================== --- trunk/octave-forge/main/optim/inst/curvefit_stat.m 2012-03-30 15:02:12 UTC (rev 10115) +++ trunk/octave-forge/main/optim/inst/curvefit_stat.m 2012-03-30 15:14:48 UTC (rev 10116) @@ -1,20 +1,19 @@ ## Copyright (C) 2011 Olaf Till <ola...@un...> ## -## This program is free software; you can redistribute it and/or modify -## it under the terms of the GNU General Public License as published by -## the Free Software Foundation; either version 3 of the License, or -## (at your option) any later version. +## This program is free software; you can redistribute it and/or modify it under +## the terms of the GNU General Public License as published by the Free Software +## Foundation; either version 3 of the License, or (at your option) any later +## version. ## -## This program is distributed in the hope that it will be useful, -## but WITHOUT ANY WARRANTY; without even the implied warranty of -## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -## GNU General Public License for more details. +## This program is distributed in the hope that it will be useful, but WITHOUT +## ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +## details. ## -## You should have received a copy of the GNU General Public License -## along with this program; If not, see <http://www.gnu.org/licenses/>. +## You should have received a copy of the GNU General Public License along with +## this program; if not, see <http://www.gnu.org/licenses/>. ## -*- texinfo -*- -## ## @deftypefn {Function File} {@var{info} =} residmin_stat (@var{f}, @var{p}, @var{x}, @var{y}, @var{settings}) ## ## Frontend for computation of statistics for fitting of values, @@ -30,7 +29,6 @@ ## also a second obligatory argument which will be set to @var{x}. ## ## @seealso {residmin_stat} -## ## @end deftypefn function ret = curvefit_stat (f, pfin, x, y, settings) Modified: trunk/octave-forge/main/optim/inst/d2_min.m =================================================================== --- trunk/octave-forge/main/optim/inst/d2_min.m 2012-03-30 15:02:12 UTC (rev 10115) +++ trunk/octave-forge/main/optim/inst/d2_min.m 2012-03-30 15:14:48 UTC (rev 10116) @@ -1,18 +1,17 @@ - -## Copyright (C) 2002 Etienne Grossmann. All rights reserved. +## Copyright (C) 2002 Etienne Grossmann <et...@cs...> ## -## This program is free software; you can redistribute it and/or modify it -## under the terms of the GNU General Public License as published by the -## Free Software Foundation; either version 2, or (at your option) any -## later version. +## This program is free software; you can redistribute it and/or modify it under +## the terms of the GNU General Public License as published by the Free Software +## Foundation; either version 3 of the License, or (at your option) any later +## version. ## -## This is distributed in the hope that it will be useful, but WITHOUT +## This program is distributed in the hope that it will be useful, but WITHOUT ## ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -## for more details. +## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +## details. ## -## Changelog: -## 2002 / 05 / 09 : Heuristic for negative hessian +## You should have received a copy of the GNU General Public License along with +## this program; if not, see <http://www.gnu.org/licenses/>. ## [x,v,nev,h,args] = d2_min(f,d2f,args,ctl,code) - Newton-like minimization ## @@ -82,9 +81,6 @@ function [xbest,vbest,nev,hbest,args] = d2_min (f,d2f,args,ctl,code) -## Author : Etienne Grossmann <et...@cs...> -## - maxout = inf; maxinner = 30 ; Modified: trunk/octave-forge/main/optim/inst/dcdp.m =================================================================== --- trunk/octave-forge/main/optim/inst/dcdp.m 2012-03-30 15:02:12 UTC (rev 10115) +++ trunk/octave-forge/main/optim/inst/dcdp.m 2012-03-30 15:14:48 UTC (rev 10116) @@ -1,29 +1,29 @@ %% Copyright (C) 2010, 2011 Olaf Till <ola...@un...> %% -%% This program is free software; you can redistribute it and/or modify -%% it under the terms of the GNU General Public License as published by -%% the Free Software Foundation; either version 2 of the License, or -%% (at your option) any later version. +%% This program is free software; you can redistribute it and/or modify it under +%% the terms of the GNU General Public License as published by the Free Software +%% Foundation; either version 3 of the License, or (at your option) any later +%% version. %% -%% This program is distributed in the hope that it will be useful, -%% but WITHOUT ANY WARRANTY; without even the implied warranty of -%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -%% GNU General Public License for more details. +%% This program is distributed in the hope that it will be useful, but WITHOUT +%% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +%% FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +%% details. %% -%% You should have received a copy of the GNU General Public License -%% along with this program; If not, see <http://www.gnu.org/licenses/>. +%% You should have received a copy of the GNU General Public License along with +%% this program; if not, see <http://www.gnu.org/licenses/>. +%% function prt = dcdp (f, p, dp, func[, bounds]) +%% +%% This is an interface to __dfdp__.m, similar to dfdp.m, but for +%% functions only of parameters 'p', not of independents 'x'. See +%% dfdp.m. +%% +%% dfpdp is more general and is meant to be used instead of dcdp in +%% optimization. + function prt = dcdp (f, p, dp, func, bounds) - %% function prt = dcdp (f, p, dp, func[, bounds]) - %% - %% This is an interface to __dfdp__.m, similar to dfdp.m, but for - %% functions only of parameters 'p', not of independents 'x'. See - %% dfdp.m. - %% - %% dfpdp is more general and is meant to be used instead of dcdp in - %% optimization. - if (ischar (func)) func = str2func (func); end @@ -40,3 +40,4 @@ hook.diff_onesided = dp < 0; prt = __dfdp__ (p, func, hook); +end Modified: trunk/octave-forge/main/optim/inst/de_min.m =================================================================== --- trunk/octave-forge/main/optim/inst/de_min.m 2012-03-30 15:02:12 UTC (rev 10115) +++ trunk/octave-forge/main/optim/inst/de_min.m 2012-03-30 15:14:48 UTC (rev 10116) @@ -1,22 +1,18 @@ -## Copyright (C) 2009-2010 Christian Fischer <cfi...@it...> ## Copyright (C) 1996, 1997 R. Storn +## Copyright (C) 2009-2010 Christian Fischer <cfi...@it...> ## -## This program is free software; you can redistribute it and/or modify -## it under the terms of the GNU General Public License as published by -## the Free Software Foundation; either version 3 of the License, or -## (at your option) any later version. +## This program is free software; you can redistribute it and/or modify it under +## the terms of the GNU General Public License as published by the Free Software +## Foundation; either version 3 of the License, or (at your option) any later +## version. ## -## This program is distributed in the hope that it will be useful, -## but WITHOUT ANY WARRANTY; without even the implied warranty of -## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -## GNU General Public License for more details. +## This program is distri... [truncated message content] |
From: <car...@us...> - 2012-04-05 21:45:23
|
Revision: 10154 http://octave.svn.sourceforge.net/octave/?rev=10154&view=rev Author: carandraug Date: 2012-04-05 21:45:17 +0000 (Thu, 05 Apr 2012) Log Message: ----------- fmin: deprecating in favour of fminbnd Modified Paths: -------------- trunk/octave-forge/main/optim/NEWS trunk/octave-forge/main/optim/inst/fmin.m Modified: trunk/octave-forge/main/optim/NEWS =================================================================== --- trunk/octave-forge/main/optim/NEWS 2012-04-05 19:26:23 UTC (rev 10153) +++ trunk/octave-forge/main/optim/NEWS 2012-04-05 21:45:17 UTC (rev 10154) @@ -10,6 +10,13 @@ fminunc_compat optimset_compat + ** The function `fmin' has been deprecated in favour of using `fminbnd' + directly. If one really wishes to use the short version, one can + easily create an alias on an octaverc file (see `doc startup') with + the following code + + function out=fmin(varargin) out=fminbnd(varargin{:}); endfunction + ** The package Makefile has been adapted for compatibility with Octave 3.6.0. ** Bugfixes on the functions: Modified: trunk/octave-forge/main/optim/inst/fmin.m =================================================================== --- trunk/octave-forge/main/optim/inst/fmin.m 2012-04-05 19:26:23 UTC (rev 10153) +++ trunk/octave-forge/main/optim/inst/fmin.m 2012-04-05 21:45:17 UTC (rev 10154) @@ -15,6 +15,13 @@ function ret=fmin(varargin) + persistent warned = false; + if (! warned) + warned = true; + warning ("Octave:deprecated-function", + "`fmin' has been deprecated, and will be removed in the future. Use `fminbnd' directly instead."); + endif + ## alias for fminbnd ret = fminbnd(varargin{:}); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <i7...@us...> - 2010-08-29 09:35:22
|
Revision: 7597 http://octave.svn.sourceforge.net/octave/?rev=7597&view=rev Author: i7tiol Date: 2010-08-29 09:35:15 +0000 (Sun, 29 Aug 2010) Log Message: ----------- - optim_problems.m: added unconstrained problems schittkowski_281, _289, and _391, added feasible initial values to schittkowski_373. - wrap_f_dfdp.m: new function, for passing objective function and jacobian to some optimizers. - leasqr.m: bugfix in passing bounds in internal wrappers (corrected a former fix in revision 7426). - bumped version number to 1.0.14 (because 1.0.13 had been announced as a package, though it was never released) Revision Links: -------------- http://octave.svn.sourceforge.net/octave/?rev=7426&view=rev Modified Paths: -------------- trunk/octave-forge/main/optim/DESCRIPTION trunk/octave-forge/main/optim/inst/leasqr.m trunk/octave-forge/main/optim/inst/optim_problems.m Added Paths: ----------- trunk/octave-forge/main/optim/inst/wrap_f_dfdp.m Modified: trunk/octave-forge/main/optim/DESCRIPTION =================================================================== --- trunk/octave-forge/main/optim/DESCRIPTION 2010-08-29 01:23:30 UTC (rev 7596) +++ trunk/octave-forge/main/optim/DESCRIPTION 2010-08-29 09:35:15 UTC (rev 7597) @@ -1,6 +1,6 @@ Name: Optim -Version: 1.0.13 -Date: 2009-09-21 +Version: 1.0.14 +Date: 2010-08-29 Author: Various Authors Maintainer: The Octave Community Title: Optimzation. Modified: trunk/octave-forge/main/optim/inst/leasqr.m =================================================================== --- trunk/octave-forge/main/optim/inst/leasqr.m 2010-08-29 01:23:30 UTC (rev 7596) +++ trunk/octave-forge/main/optim/inst/leasqr.m 2010-08-29 09:35:15 UTC (rev 7597) @@ -354,7 +354,10 @@ end if (strcmp (func2str (df_gencstr), 'dcdp')) df_gencstr = @ (f, p, dp, fun, idx, db) ... - df_gencstr (f, p, dp, fun, db); + df_gencstr (f, p, dp, fun, db{:}); + else + df_gencstr = @ (f, p, dp, fun, idx, db) ... + df_gencstr (f, p, dp, fun, idx, db{:}); end end [rm, cm] = size (mc); @@ -511,7 +514,7 @@ df_gencstr (f(nidxh(idx(nidxh))), p, dp, ... @ (tp) f_gencstr (tp, idx(nidxh)), ... idx(nidxh), ... - dfdp_bounds{:})); + dfdp_bounds)); if (any (~isinf (maxstep))) warning ('setting both a maximum fractional step change of parameters and general constraints may result in inefficiency and failure'); end Modified: trunk/octave-forge/main/optim/inst/optim_problems.m =================================================================== --- trunk/octave-forge/main/optim/inst/optim_problems.m 2010-08-29 01:23:30 UTC (rev 7596) +++ trunk/octave-forge/main/optim/inst/optim_problems.m 2010-08-29 09:35:15 UTC (rev 7597) @@ -123,6 +123,10 @@ %% numbered from 201 to 395 and may appear here under the fields %% .curve, .general, or .zero. %% + %% .general.schittkowski_281: 10 parameters, unconstrained. + %% + %% .general.schittkowski_289: 30 parameters, unconstrained. + %% %% .general.schittkowski_327 and %% %% .curve.schittkowski_327: Two parameters, one general inequality @@ -136,12 +140,27 @@ %% .general.schittkowski_372: 9 parameters, 12 general inequality %% constraints, 6 bounds. Infeasible initial parameters %% (.curve.schittkowski_372.init_p_f(1) provides a set of more or less - %% feasible parameters. leasqr sticks at the (feasible) initial + %% feasible parameters). leasqr sticks at the (feasible) initial %% values. sqp has no problems. %% %% .curve.schittkowski_373: 9 parameters, 6 equality constraints. - %% Infeasible initial parameters. + %% Infeasible initial parameters (.curve.schittkowski_373.init_p_f(1) + %% provides a set of more or less feasible parameters). leasqr sticks + %% at the (feasible) initial values. sqp has no problems. + %% + %% .general.schittkowski_391: 30 parameters, unconstrained. The best + %% solution given in the publication seems not very good, obviously + %% the used routine had not managed to get very far from the starting + %% parameters; it has been replaced here by a better (Octaves + %% fminunc). The result still varies widely (without much changes in + %% objective function) with changes of starting values. Maybe not a + %% very good test problem, no well defined minimum ... + %% needed for some anonymous functions + if (exist ('ifelse') ~= 5) + ifelse = @ scalar_ifelse; + end + if (~exist ('OCTAVE_VERSION')) NA = NaN; end @@ -379,6 +398,44 @@ -5.0039950796246986e+00, -7.9749636293721071e+00]; ret.curve.p_r.f = @ (x, p) f_r (x, p, hook); + ret.general.schittkowski_281.dfdp = ... + @ (p) schittkowski_281_dfdp (p); + ret.general.schittkowski_281.init_p = zeros (10, 1); + ret.general.schittkowski_281.result.p = ones (10, 1); % 'theoretically' + ret.general.schittkowski_281.result.obj = 0; % 'theoretically' + ret.general.schittkowski_281.strict_inequc.bounds = []; + ret.general.schittkowski_281.strict_inequc.linear = []; + ret.general.schittkowski_281.strict_inequc.general = []; + ret.general.schittkowski_281.non_strict_inequc.bounds = []; + ret.general.schittkowski_281.non_strict_inequc.linear = []; + ret.general.schittkowski_281.non_strict_inequc.general = []; + ret.general.schittkowski_281.equc.linear = []; + ret.general.schittkowski_281.equc.general = []; + ret.general.schittkowski_281.f = ... + @ (p) (sum (((1:10).') .^ 3 .* (p - 1) .^ 2)) ^ (1 / 3); + + ret.general.schittkowski_289.dfdp = ... + @ (p) exp (- sum (p .^ 2) / 60) / 30 * p; + ret.general.schittkowski_289.init_p = [-1.03; 1.07; -1.10; 1.13; ... + -1.17; 1.20; -1.23; 1.27; ... + -1.30; 1.33; -1.37; 1.40; ... + -1.43; 1.47; -1.50; 1.53; ... + -1.57; 1.60; -1.63; 1.67; ... + -1.70; 1.73; -1.77; 1.80; ... + -1.83; 1.87; -1.90; 1.93; ... + -1.97; 2.00]; + ret.general.schittkowski_289.result.p = zeros (30, 1); % 'theoretically' + ret.general.schittkowski_289.result.obj = 0; % 'theoretically' + ret.general.schittkowski_289.strict_inequc.bounds = []; + ret.general.schittkowski_289.strict_inequc.linear = []; + ret.general.schittkowski_289.strict_inequc.general = []; + ret.general.schittkowski_289.non_strict_inequc.bounds = []; + ret.general.schittkowski_289.non_strict_inequc.linear = []; + ret.general.schittkowski_289.non_strict_inequc.general = []; + ret.general.schittkowski_289.equc.linear = []; + ret.general.schittkowski_289.equc.general = []; + ret.general.schittkowski_289.f = @ (p) 1 - exp (- sum (p .^ 2) / 60); + ret.curve.schittkowski_327.dfdp = ... @ (x, p) [1 + exp(-p(2) * (x - 8)), ... (p(1) + .49) * (8 - x) .* exp (-p(2) * (x - 8))]; @@ -388,9 +445,9 @@ 18; 18; 20; 20; 20; 22; 22; 22; 24; 24; 24; 26; 26; 26; 28; ... 28; 30; 30; 30; 32; 32; 34; 36; 36; 38; 38; 40; 42]; ret.curve.schittkowski_327.data.y= ... - [.49; .49; .48; .47; .48; .47; .46; .46; .45; .43; .45; .43; \ - .43; .44; .43; .43; .46; .45; .42; .42; .43; .41; .41; .40; \ - .42; .40; .40; .41; .40; .41; .41; .40; .40; .40; .38; .41; \ + [.49; .49; .48; .47; .48; .47; .46; .46; .45; .43; .45; .43; ... + .43; .44; .43; .43; .46; .45; .42; .42; .43; .41; .41; .40; ... + .42; .40; .40; .41; .40; .41; .41; .40; .40; .40; .38; .41; ... .40; .40; .41; .38; .40; .40; .39; .39]; ret.curve.schittkowski_327.data.wt = []; ret.curve.schittkowski_327.data.cov = []; @@ -426,9 +483,9 @@ 18; 18; 20; 20; 20; 22; 22; 22; 24; 24; 24; 26; 26; 26; 28; ... 28; 30; 30; 30; 32; 32; 34; 36; 36; 38; 38; 40; 42]; ret.general.schittkowski_327.data.y= ... - [.49; .49; .48; .47; .48; .47; .46; .46; .45; .43; .45; .43; \ - .43; .44; .43; .43; .46; .45; .42; .42; .43; .41; .41; .40; \ - .42; .40; .40; .41; .40; .41; .41; .40; .40; .40; .38; .41; \ + [.49; .49; .48; .47; .48; .47; .46; .46; .45; .43; .45; .43; ... + .43; .44; .43; .43; .46; .45; .42; .42; .43; .41; .41; .40; ... + .42; .40; .40; .41; .40; .41; .41; .40; .40; .40; .38; .41; ... .40; .40; .41; .38; .40; .40; .39; .39]; x = ret.general.schittkowski_327.data.x; y = ret.general.schittkowski_327.data.y; @@ -488,7 +545,7 @@ ret.curve.schittkowski_372.data.y= zeros (6, 1); ret.curve.schittkowski_372.data.wt = []; ret.curve.schittkowski_372.data.cov = []; - %% recomputed with sqp (e.g. not with curve fitting) + %% recomputed with sqp (i.e. not with curve fitting) ret.curve.schittkowski_372.result.p = [5.2330557804078126e+02; ... -1.5694790476454301e+02; ... -1.9966450018535931e-01; ... @@ -536,6 +593,17 @@ %% not feasible ret.curve.schittkowski_373.init_p = [300; -100; -.1997; -127; ... -151; 379; 421; 460; 426]; + %% feasible + ret.curve.schittkowski_373.init_p_f = @ (id) ... + ifelse (id == 0, 1, [2.5722721227695763e+02; ... + -1.5126681606092043e+02; ... + 8.3101871447778766e-02; ... + -3.0390506000425454e+01; ... + 1.1661334225083069e+01; ... + 2.6097719374430665e+02; ... + 3.2814725183082305e+02; ... + 3.9686840023267564e+02; ... + 3.9796353824451995e+02]); ret.curve.schittkowski_373.data.x = (1:6).'; % any different numbers ret.curve.schittkowski_373.data.y= zeros (6, 1); ret.curve.schittkowski_373.data.wt = []; @@ -616,6 +684,51 @@ ret.general.schittkowski_372.equc.general = []; ret.general.schittkowski_372.f = @ (p) sumsq (p(4:9)); + ret.general.schittkowski_391.dfdp = []; + ret.general.schittkowski_391.init_p = ... + -2.8742711 * alpha_391 (zeros (30, 1), 1:30); + %% computed with fminunc (Octave) + ret.general.schittkowski_391.result.p = [-1.1986682e+18; ... + -1.1474574e+07; ... + -1.3715802e+07; ... + -1.0772255e+07; ... + -1.0634232e+07; ... + -1.0622915e+07; ... + -8.8775399e+06; ... + -8.8201496e+06; ... + -9.7729975e+06; ... + -1.0431808e+07; ... + -1.0415089e+07; ... + -1.0350400e+07; ... + -1.0325094e+07; ... + -1.0278561e+07; ... + -1.0275751e+07; ... + -1.0276546e+07; ... + -1.0292584e+07; ... + -1.0289350e+07; ... + -1.0192566e+07; ... + -1.0058577e+07; ... + -1.0096341e+07; ... + -1.0242386e+07; ... + -1.0615831e+07; ... + -1.1142096e+07; ... + -1.1617283e+07; ... + -1.2005738e+07; ... + -1.2282117e+07; ... + -1.2301260e+07; ... + -1.2051365e+07; ... + -1.1704693e+07]; + ret.general.schittkowski_391.result.obj = -5.1615468e+20; + ret.general.schittkowski_391.strict_inequc.bounds = []; + ret.general.schittkowski_391.strict_inequc.linear = []; + ret.general.schittkowski_391.strict_inequc.general = []; + ret.general.schittkowski_391.non_strict_inequc.bounds = []; + ret.general.schittkowski_391.non_strict_inequc.linear = []; + ret.general.schittkowski_391.non_strict_inequc.general = []; + ret.general.schittkowski_391.equc.linear = []; + ret.general.schittkowski_391.equc.general = []; + ret.general.schittkowski_391.f = @ (p) sum (alpha_391 (p, 1:30)); + function ret = f_1 (x, p) ret = p(1) + x(:, 1) ./ (p(2) * x(:, 2) + p(3) * x(:, 3)); @@ -717,6 +830,30 @@ ret(idx) = - ((p(4) + p(1)) * p(2)) ./ ... ((p(5) * dls(idx)) ./ (1 - tf(idx) .^ 2) + p(1)) + p(2); + function ret = alpha_391 (p, id) + + %% for .general.schittkowski_391; id is a numeric index(-vector) + %% into p + + p = p(:); + n = size (p, 1); + + nid = length (id); + id = reshape (id, 1, nid); + + v = sqrt (repmat (p .^ 2, 1, nid) + 1 ./ ((1:n).') * id); + + log_v = log (v); + + ret = 420 * p(id) + (id(:) - 15) .^ 3 + ... + sum (v .* (sin (log_v) .^ 5 + cos (log_v) .^ 5)).'; + + function ret = schittkowski_281_dfdp (p) + + tp = (sum (((1:10).') .^ 3 .* (p - 1) .^ 2)) ^ (- 2 / 3) / 3; + + ret = 2 * ((1:10).') .^ 3 .* (p - 1) * tp; + function state = fixed_step_rk4 (t, x0, step, f) %% minimalistic fourth order ODE-solver, as said to be a popular one @@ -1104,6 +1241,15 @@ ret = ret(idx); end + function fval = scalar_ifelse (cond, tval, fval) + + %% needed for some anonymous functions, builtin ifelse only available + %% in Octave > 3.2; we need only the scalar case here + + if (cond) + fval = tval; + end + %!demo %! p_t = optim_problems ().curve.p_1; %! global verbose; Added: trunk/octave-forge/main/optim/inst/wrap_f_dfdp.m =================================================================== --- trunk/octave-forge/main/optim/inst/wrap_f_dfdp.m (rev 0) +++ trunk/octave-forge/main/optim/inst/wrap_f_dfdp.m 2010-08-29 09:35:15 UTC (rev 7597) @@ -0,0 +1,43 @@ +%% Copyright (C) 2010 Olaf Till <ola...@un...> +%% +%% This program is free software; you can redistribute it and/or modify +%% it under the terms of the GNU General Public License as published by +%% the Free Software Foundation; either version 3 of the License, or (at +%% your option) any later version. +%% +%% This program is distributed in the hope that it will be useful, but +%% WITHOUT ANY WARRANTY; without even the implied warranty of +%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +%% General Public License for more details. +%% +%% You should have received a copy of the GNU General Public License +%% along with this program; If not, see <http://www.gnu.org/licenses/>. + +function [ret1, ret2] = wrap_f_dfdp (f, dfdp, varargin) + + %% [ret1, ret2] = wrap_f_dfdp (f, dfdp, varargin) + %% + %% f and dftp should be the objective function (or "model function" in + %% curve fitting) and its jacobian, respectively, of an optimization + %% problem. ret1: f (varagin{:}), ret2: dfdp (varargin{:}). ret2 is + %% only computed if more than one output argument is given. This + %% manner of calling f and dfdp is needed by some optimization + %% functions. + + if (nargin < 3) + print_usage (); + end + + if (ischar (f)) + f = str2func (f); + end + + if (ischar (dfdp)) + dfdp = str2func (dfdp); + end + + ret1 = f (varargin{:}); + + if (nargout > 1) + ret2 = dfdp (varargin{:}); + end This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <i7...@us...> - 2010-11-11 11:46:00
|
Revision: 7908 http://octave.svn.sourceforge.net/octave/?rev=7908&view=rev Author: i7tiol Date: 2010-11-11 11:45:54 +0000 (Thu, 11 Nov 2010) Log Message: ----------- Fix __dfdp__.m called with less than 3 arguments. Modified Paths: -------------- trunk/octave-forge/main/optim/DESCRIPTION trunk/octave-forge/main/optim/inst/__dfdp__.m trunk/octave-forge/main/optim/inst/__nonlin_residmin__.m trunk/octave-forge/main/optim/inst/nonlin_residmin.m Modified: trunk/octave-forge/main/optim/DESCRIPTION =================================================================== --- trunk/octave-forge/main/optim/DESCRIPTION 2010-11-10 08:46:34 UTC (rev 7907) +++ trunk/octave-forge/main/optim/DESCRIPTION 2010-11-11 11:45:54 UTC (rev 7908) @@ -1,6 +1,6 @@ Name: Optim -Version: 1.0.15 -Date: 2010-10-25 +Version: 1.0.16 +Date: 2010-11-05 Author: Various Authors Maintainer: The Octave Community Title: Optimzation. Modified: trunk/octave-forge/main/optim/inst/__dfdp__.m =================================================================== --- trunk/octave-forge/main/optim/inst/__dfdp__.m 2010-11-10 08:46:34 UTC (rev 7907) +++ trunk/octave-forge/main/optim/inst/__dfdp__.m 2010-11-11 11:45:54 UTC (rev 7908) @@ -72,6 +72,7 @@ bounds = ones (n, 2); bounds(:, 1) = -Inf; bounds(:, 2) = Inf; + plabels = num2cell ((1:n).'); end prt = zeros (m, n); % initialise Jacobian to Zero Modified: trunk/octave-forge/main/optim/inst/__nonlin_residmin__.m =================================================================== --- trunk/octave-forge/main/optim/inst/__nonlin_residmin__.m 2010-11-10 08:46:34 UTC (rev 7907) +++ trunk/octave-forge/main/optim/inst/__nonlin_residmin__.m 2010-11-11 11:45:54 UTC (rev 7908) @@ -122,6 +122,9 @@ endif else pord = pord(:); + if (rows (unique (pord)) < rows (pord)) + error ("duplicate parameter names in 'param_order'"); + endif endif if (! pin_struct) @@ -333,12 +336,24 @@ ## linear inequality constraints if (mc_struct) - mc = cat (1, fields2cell (mc, pord){:}); + idx = arefields (mc, pord); + if (rows (fieldnames (mc)) > sum (idx)) + error ("unknown fields in structure of linear inequality constraints"); + endif + smc = mc; + mc = zeros (np, rows (vc)); + mc(idx, :) = cat (1, fields2cell (smc, pord(idx)){:}); endif ## linear equality constraints if (emc_struct) - emc = cat (1, fields2cell (emc, pord){:}); + idx = arefields (emc, pord); + if (rows (fieldnames (emc)) > sum (idx)) + error ("unknown fields in structure of linear equality constraints"); + endif + semc = emc; + emc = zeros (np, rowd (evc)); + emc(idx, :) = cat (1, fields2cell (semc, pord(idx)){:}); endif ## parameter-related configuration for jacobi functions Modified: trunk/octave-forge/main/optim/inst/nonlin_residmin.m =================================================================== --- trunk/octave-forge/main/optim/inst/nonlin_residmin.m 2010-11-10 08:46:34 UTC (rev 7907) +++ trunk/octave-forge/main/optim/inst/nonlin_residmin.m 2010-11-11 11:45:54 UTC (rev 7908) @@ -197,6 +197,7 @@ ## Similarly, for specifying linear constraints, instead of the matrix ## (called @code{m} above), a structure containing the rows of the ## matrix in fields under the respective parameter names can be given. +## In this case, rows containing only zeros need not be given. ## ## The vector/matrix-based settings @code{bounds}, @code{fixed}, ## @code{diffp}, @code{diff_onesided}, @code{fract_prec}, and This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <i7...@us...> - 2010-12-02 10:16:24
|
Revision: 7974 http://octave.svn.sourceforge.net/octave/?rev=7974&view=rev Author: i7tiol Date: 2010-12-02 10:16:18 +0000 (Thu, 02 Dec 2010) Log Message: ----------- param_config need only contain parameters with non-defaults. Modified Paths: -------------- trunk/octave-forge/main/optim/DESCRIPTION trunk/octave-forge/main/optim/inst/__nonlin_residmin__.m trunk/octave-forge/main/optim/inst/nonlin_residmin.m Modified: trunk/octave-forge/main/optim/DESCRIPTION =================================================================== --- trunk/octave-forge/main/optim/DESCRIPTION 2010-12-02 10:10:27 UTC (rev 7973) +++ trunk/octave-forge/main/optim/DESCRIPTION 2010-12-02 10:16:18 UTC (rev 7974) @@ -1,6 +1,6 @@ Name: Optim Version: 1.0.16 -Date: 2010-11-05 +Date: 2010-12-02 Author: Various Authors Maintainer: The Octave Community Title: Optimzation. Modified: trunk/octave-forge/main/optim/inst/__nonlin_residmin__.m =================================================================== --- trunk/octave-forge/main/optim/inst/__nonlin_residmin__.m 2010-12-02 10:10:27 UTC (rev 7973) +++ trunk/octave-forge/main/optim/inst/__nonlin_residmin__.m 2010-12-02 10:16:18 UTC (rev 7974) @@ -155,14 +155,15 @@ ## parameter-related configuration is either allowed by a structure ## or by vectors if (! (isempty (bounds) && isempty (max_fract_change) && \ - isempty (fract_prec) && isempty (diffp) && \ - isempty (diff_onesided) && isempty (fixed))) + isempty (fract_prec) && isempty (diffp) && \ + isempty (diff_onesided) && isempty (fixed))) error ("if param_config is given, its potential items must not be configured in another way"); endif - if (! all (arefields (pconf, pord))) - error ("param_config does not contain fields for all parameters"); - endif + ## supplement parameter names lacking in param_config + nidx = ! arefields (pconf, pord); + pconf = cell2fields ({struct()}(ones (1, sum (nidx))), \ + pord(nidx), 2, pconf); pconf = structcat (1, fields2cell (pconf, pord){:}); Modified: trunk/octave-forge/main/optim/inst/nonlin_residmin.m =================================================================== --- trunk/octave-forge/main/optim/inst/nonlin_residmin.m 2010-12-02 10:10:27 UTC (rev 7973) +++ trunk/octave-forge/main/optim/inst/nonlin_residmin.m 2010-12-02 10:16:18 UTC (rev 7974) @@ -205,13 +205,13 @@ ## The vector/matrix-based settings @code{bounds}, @code{fixed}, ## @code{diffp}, @code{diff_onesided}, @code{fract_prec}, and ## @code{max_fract_change} can be replaced by the setting -## @code{param_config}. It is a structure containing at least all fields -## named in @code{param_order}. For each parameter, there may be -## subfields with the same names as the above vector/matrix-based -## settings, but containing a scalar value (or a two-element row vector -## in the case of bounds) for the respective parameter. If -## @code{param_config} is specified, none of the above -## vector/matrix-based settings may be used. +## @code{param_config}. It is a structure that can contain fields named +## in @code{param_order}. For each such field, there may be subfields +## with the same names as the above vector/matrix-based settings, but +## containing a scalar value (or a two-element row vector in the case of +## bounds) for the respective parameter. If @code{param_config} is +## specified, none of the above vector/matrix-based settings may be +## used. ## ## Description of backends (currently only one) ## This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <i7...@us...> - 2010-12-02 10:21:40
|
Revision: 7975 http://octave.svn.sourceforge.net/octave/?rev=7975&view=rev Author: i7tiol Date: 2010-12-02 10:21:34 +0000 (Thu, 02 Dec 2010) Log Message: ----------- New function vfzero, variant of fzero. Modified Paths: -------------- trunk/octave-forge/main/optim/INDEX Added Paths: ----------- trunk/octave-forge/main/optim/inst/vfzero.m Modified: trunk/octave-forge/main/optim/INDEX =================================================================== --- trunk/octave-forge/main/optim/INDEX 2010-12-02 10:16:18 UTC (rev 7974) +++ trunk/octave-forge/main/optim/INDEX 2010-12-02 10:21:34 UTC (rev 7975) @@ -18,6 +18,8 @@ nonlin_residmin nonlin_curvefit LinearRegression +Zero finding + vfzero Compatibility fminunc_compat optimset_compat Added: trunk/octave-forge/main/optim/inst/vfzero.m =================================================================== --- trunk/octave-forge/main/optim/inst/vfzero.m (rev 0) +++ trunk/octave-forge/main/optim/inst/vfzero.m 2010-12-02 10:21:34 UTC (rev 7975) @@ -0,0 +1,359 @@ +## Copyright (C) 2008, 2009 VZLU Prague, a.s. +## +## This file is part of Octave. +## +## Octave is free software; you can redistribute it and/or modify it +## under the terms of the GNU General Public License as published by +## the Free Software Foundation; either version 3 of the License, or (at +## your option) any later version. +## +## Octave is distributed in the hope that it will be useful, but +## WITHOUT ANY WARRANTY; without even the implied warranty of +## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +## General Public License for more details. +## +## You should have received a copy of the GNU General Public License +## along with Octave; see the file COPYING. If not, see +## <http://www.gnu.org/licenses/>. +## +## Author: Jaroslav Hajek <hi...@gm...> + +## -*- texinfo -*- +## @deftypefn {Function File} {} vfzero (@var{fun}, @var{x0}) +## @deftypefnx {Function File} {} vfzero (@var{fun}, @var{x0}, @var{options}) +## @deftypefnx {Function File} {[@var{x}, @var{fval}, @var{info}, @var{output}] =} vfzero (@dots{}) +## A variant of @code{fzero}. Finds a zero of a vector-valued +## multivariate function where each output element only depends on the +## input element with the same index (so the Jacobian is diagonal). +## +## @var{fun} should be a handle or name of a function returning a column +## vector. @var{x0} should be a two-column matrix, each row specifying +## two points which bracket a zero of the respective output element of +## @var{fun}. +## +## If @var{x0} is a single-column matrix then several nearby and distant +## values are probed in an attempt to obtain a valid bracketing. If +## this is not successful, the function fails. @var{options} is a +## structure specifying additional options. Currently, @code{vfzero} +## recognizes these options: @code{"FunValCheck"}, @code{"OutputFcn"}, +## @code{"TolX"}, @code{"MaxIter"}, @code{"MaxFunEvals"}. For a +## description of these options, see @ref{doc-optimset,,optimset}. +## +## On exit, the function returns @var{x}, the approximate zero and +## @var{fval}, the function value thereof. @var{info} is a column vector +## of exit flags that can have these values: +## +## @itemize +## @item 1 The algorithm converged to a solution. +## +## @item 0 Maximum number of iterations or function evaluations has been +## reached. +## +## @item -1 The algorithm has been terminated from user output function. +## +## @item -5 The algorithm may have converged to a singular point. +## @end itemize +## +## @var{output} is a structure containing runtime information about the +## @code{fzero} algorithm. Fields in the structure are: +## +## @itemize +## @item iterations Number of iterations through loop. +## +## @item nfev Number of function evaluations. +## +## @item bracketx A two-column matrix with the final bracketing of the +## zero along the x-axis. +## +## @item brackety A two-column matrix with the final bracketing of the +## zero along the y-axis. +## @end itemize +## @seealso{optimset, fsolve} +## @end deftypefn + +## This is essentially the ACM algorithm 748: Enclosing Zeros of +## Continuous Functions due to Alefeld, Potra and Shi, ACM Transactions +## on Mathematical Software, Vol. 21, No. 3, September 1995. Although +## the workflow should be the same, the structure of the algorithm has +## been transformed non-trivially; instead of the authors' approach of +## sequentially calling building blocks subprograms we implement here a +## FSM version using one interior point determination and one bracketing +## per iteration, thus reducing the number of temporary variables and +## simplifying the algorithm structure. Further, this approach reduces +## the need for external functions and error handling. The algorithm has +## also been slightly modified. + +## Vectorized by Olaf Till. + +## PKG_ADD: __all_opts__ ("vfzero"); + +function [x, fval, info, output] = vfzero (fun, x0, options = struct ()) + + ## Get default options if requested. + if (nargin == 1 && ischar (fun) && strcmp (fun, 'defaults')) + x = optimset ("MaxIter", Inf, "MaxFunEvals", Inf, "TolX", 1e-8, \ + "OutputFcn", [], "FunValCheck", "off"); + return; + endif + + if (nargin < 2 || nargin > 3) + print_usage (); + endif + + if (ischar (fun)) + fun = str2func (fun, "global"); + endif + + ## TODO + ## displev = optimget (options, "Display", "notify"); + funvalchk = strcmpi (optimget (options, "FunValCheck", "off"), "on"); + outfcn = optimget (options, "OutputFcn"); + tolx = optimget (options, "TolX", 1e-8); + maxiter = optimget (options, "MaxIter", Inf); + maxfev = optimget (options, "MaxFunEvals", Inf); + nx = rows (x0); + ## fun may assume a certain length of x, so we will always call it + ## with the full-length x, even if only some elements are needed + + persistent mu = 0.5; + + if (funvalchk) + ## Replace fun with a guarded version. + fun = @(x) guarded_eval (fun, x); + endif + + ## The default exit flag if exceeded number of iterations. + info = zeros (nx, 1); + niter = 0; + nfev = 0; + + x = fval = a = fa = b = fb = aa = c = u = fu = NaN (nx, 1); + bracket_ready = false (nx, 1); + eps = eps (class (x0)); + + ## Prepare... + a = x0(:, 1); + fa = fun (a)(:); + nfev = 1; + if (columns (x0) > 1) + b = x0(:, 2); + fb = fun (b)(:); + nfev += 1; + else + ## Try to get b. + aa(idx = a == 0) = 1; + aa(! idx) = a(! idx); + for tb = [0.9*aa, 1.1*aa, aa-1, aa+1, 0.5*aa 1.5*aa, -aa, 2*aa, -10*aa, 10*aa] + tfb = fun (tb)(:); nfev += 1; + idx = ! bracket_ready & sign (fa) .* sign (tfb) <= 0; + bracket_ready |= idx; + b(idx) = tb(idx); + fb(idx) = tfb(idx); + if (all (bracket_ready)) + break; + endif + endfor + endif + + tp = a(idx = b < a); + a(idx) = b(idx); + b(idx) = tp; + + tp = fa(idx); + fa(idx) = fb(idx); + fb(idx) = tp; + + if (! all (sign (fa) .* sign (fb) <= 0)) + error ("fzero:bracket", "vfzero: not a valid initial bracketing"); + endif + + slope0 = (fb - fa) ./ (b - a); + + idx = fa == 0; + b(idx) = a(idx); + fb(idx) = fa(idx); + + idx = (! idx & fb == 0); + a(idx) = b(idx); + fa(idx) = fb(idx); + + itype = ones (nx, 1); + + idx = abs (fa) < abs (fb); + u(idx) = a(idx); fu(idx) = fa(idx); + u(! idx) = b(! idx); fu(! idx) = fb(! idx); + + d = e = u; + fd = fe = fu; + mba = mu * (b - a); + not_ready = true (nx, 1); + while (niter < maxiter && nfev < maxfev && any (not_ready)) + ## itype == 1 + type1idx = not_ready & itype == 1; + ## The initial test. + idx = b - a <= 2*(2 * eps * abs (u) + tolx) & type1idx; + x(idx) = u(idx); fval(idx) = fu(idx); + info(idx) = 1; + not_ready(idx) = false; + type1idx &= not_ready; + ## Secant step. + idx = type1idx & \ + (tidx = abs (fa) <= 1e3*abs (fb) & abs (fb) <= 1e3*abs (fa)); + c(idx) = u(idx) - (a(idx) - b(idx)) ./ (fa(idx) - fb(idx)) .* fu(idx); + ## Bisection step. + idx = type1idx & ! tidx; + c(idx) = 0.5*(a(idx) + b(idx)); + d(type1idx) = u(type1idx); fd(type1idx) = fu(type1idx); + itype(type1idx) = 5; + + ## itype == 2 or 3 + type23idx = not_ready & (itype == 2 | itype == 3); + uidx = cellfun (@ (x) length (unique (x)), \ + num2cell ([fa, fb, fd, fe], 2)) == 4; + oidx = sign (c - a) .* sign (c - b) > 0; + ## Inverse cubic interpolation. + idx = type23idx & (uidx & ! oidx); + q11 = (d(idx) - e(idx)) .* fd(idx) ./ (fe(idx) - fd(idx)); + q21 = (b(idx) - d(idx)) .* fb(idx) ./ (fd(idx) - fb(idx)); + q31 = (a(idx) - b(idx)) .* fa(idx) ./ (fb(idx) - fa(idx)); + d21 = (b(idx) - d(idx)) .* fd(idx) ./ (fd(idx) - fb(idx)); + d31 = (a(idx) - b(idx)) .* fb(idx) ./ (fb(idx) - fa(idx)); + q22 = (d21 - q11) .* fb(idx) ./ (fe(idx) - fb(idx)); + q32 = (d31 - q21) .* fa(idx) ./ (fd(idx) - fa(idx)); + d32 = (d31 - q21) .* fd(idx) ./ (fd(idx) - fa(idx)); + q33 = (d32 - q22) .* fa(idx) ./ (fe(idx) - fa(idx)); + c(idx) = a(idx) + q31 + q32 + q33; + ## Quadratic interpolation + newton. + idx = type23idx & (oidx | ! uidx); + a0 = fa(idx); + a1 = (fb(idx) - fa(idx))./(b(idx) - a(idx)); + a2 = ((fd(idx) - fb(idx))./(d(idx) - b(idx)) - a1) ./ (d(idx) - a(idx)); + ## Modification 1: this is simpler and does not seem to be worse. + c(idx) = a(idx) - a0./a1; + taidx = a2 != 0; + tidx = idx; + tidx(tidx) = taidx; + c(tidx) = a(tidx)(:) - (a0(taidx)./a1(taidx))(:); + for i = 1:3 + tidx &= i <= itype; + taidx = tidx(idx); + pc = a0(taidx)(:) + (a1(taidx)(:) + \ + a2(taidx)(:).*(c(tidx) - b(tidx))(:)) \ + .*(c(tidx) - a(tidx))(:); + pdc = a1(taidx)(:) + a2(taidx)(:).*(2*c(tidx) - a(tidx) - b(tidx))(:); + tidx0 = tidx; + tidx0(tidx0) &= (p0idx = pdc == 0); + taidx0 = tidx0(idx); + tidx(tidx) &= ! p0idx; + c(tidx0) = a(tidx0)(:) - (a0(taidx0)./a1(taidx0))(:); + c(tidx) = c(tidx)(:) - (pc(! p0idx)./pdc(! p0idx))(:); + endfor + itype(type23idx) += 1; + + ## itype == 4 + type4idx = not_ready & itype == 4; + ## Double secant step. + idx = type4idx; + c(idx) = u(idx) - 2*(b(idx) - a(idx))./(fb(idx) - fa(idx)).*fu(idx); + ## Bisect if too far. + idx = type4idx & abs (c - u) > 0.5*(b - a); + c(idx) = 0.5 * (b(idx) + a(idx)); + itype(type4idx) = 5; + + ## itype == 5 + type5idx = not_ready & itype == 5; + ## Bisection step. + idx = type5idx; + c(idx) = 0.5 * (b(idx) + a(idx)); + itype(type5idx) = 2; + + ## Don't let c come too close to a or b. + delta = 2*0.7*(2 * eps * abs (u) + tolx); + nidx = not_ready & ! (idx = b - a <= 2*delta); + idx &= not_ready; + c(idx) = (a(idx) + b(idx))/2; + c(nidx) = max (a(nidx) + delta(nidx), \ + min (b(nidx) - delta(nidx), c(nidx))); + + ## Calculate new point. + x = c; + fval = fc = fun (c)(:); + niter ++; nfev ++; + + ## Modification 2: skip inverse cubic interpolation if + ## nonmonotonicity is detected. + nidx = not_ready & ! (idx = sign (fc - fa) .* sign (fc - fb) >= 0); + idx &= not_ready; + ## The new point broke monotonicity. + ## Disable inverse cubic. + fe(idx) = fc(idx); + ## + e(nidx) = d(nidx); fe(nidx) = fd(nidx); + + ## Bracketing. + idx1 = not_ready & sign (fa) .* sign (fc) < 0; + idx2 = not_ready & ! idx1 & sign (fb) .* sign (fc) < 0; + idx3 = not_ready & ! (idx1 | idx2) & fc == 0; + d(idx1) = b(idx1); fd(idx1) = fb(idx1); + b(idx1) = c(idx1); fb(idx1) = fc(idx1); + d(idx2) = a(idx2); fd(idx2) = fa(idx2); + a(idx2) = c(idx2); fa(idx2) = fc(idx2); + a(idx3) = b(idx3) = c(idx3); fa(idx3) = fb(idx3) = fc(idx3); + info(idx3) = 1; + not_ready(idx3) = false; + if (any (not_ready & ! (idx1 | idx2 | idx3))) + ## This should never happen. + error ("fzero:bracket", "vfzero: zero point is not bracketed"); + endif + + ## If there's an output function, use it now. + if (! isempty (outfcn)) + optv.funccount = nfev; + optv.fval = fval; + optv.iteration = niter; + idx = not_ready & outfcn (x, optv, "iter"); + info(idx) = -1; + not_ready(idx) = false; + endif + + nidx = not_ready & ! (idx = abs (fa) < abs (fb)); + idx &= not_ready; + u(idx) = a(idx); fu(idx) = fa(idx); + u(nidx) = b(nidx); fu(nidx) = fb(nidx); + idx = not_ready & b - a <= 2*(2 * eps * abs (u) + tolx); + info(idx) = 1; + not_ready(idx) = false; + + ## Skip bisection step if successful reduction. + itype(not_ready & itype == 5 & (b - a) <= mba) = 2; + idx = not_ready & itype == 2; + mba(idx) = mu * (b(idx) - a(idx)); + endwhile + + ## Check solution for a singularity by examining slope + info(not_ready & info == 1 & (b - a) != 0 & \ + abs ((fb - fa)./(b - a) ./ slope0) > max (1e6, 0.5/(eps+tolx))) \ + = - 5; + + output.iterations = niter; + output.funcCount = nfev; + output.bracketx = [a, b]; + output.brackety = [fa, fb]; + +endfunction + +## An assistant function that evaluates a function handle and checks for +## bad results. +function fx = guarded_eval (fun, x) + fx = fun (x); + if (! isreal (fx)) + error ("fzero:notreal", "vfzero: non-real value encountered"); + elseif (any (isnan (fx))) + error ("fzero:isnan", "vfzero: NaN value encountered"); + endif +endfunction + +%!shared opt0 +%! opt0 = optimset ("tolx", 0); +%!assert(vfzero(@cos, [0, 3], opt0), pi/2, 10*eps) +%!assert(vfzero(@(x) x^(1/3) - 1e-8, [0,1], opt0), 1e-24, 1e-22*eps) This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <i7...@us...> - 2010-12-21 16:44:28
|
Revision: 8028 http://octave.svn.sourceforge.net/octave/?rev=8028&view=rev Author: i7tiol Date: 2010-12-21 16:44:20 +0000 (Tue, 21 Dec 2010) Log Message: ----------- Allow named parameters to be arrays. Split bounds setting to lower and upper bounds. Modified Paths: -------------- trunk/octave-forge/main/optim/DESCRIPTION trunk/octave-forge/main/optim/inst/__dfdp__.m trunk/octave-forge/main/optim/inst/__lm_svd__.m trunk/octave-forge/main/optim/inst/__nonlin_residmin__.m trunk/octave-forge/main/optim/inst/dcdp.m trunk/octave-forge/main/optim/inst/dfdp.m trunk/octave-forge/main/optim/inst/dfpdp.m trunk/octave-forge/main/optim/inst/dfxpdp.m trunk/octave-forge/main/optim/inst/nonlin_residmin.m Modified: trunk/octave-forge/main/optim/DESCRIPTION =================================================================== --- trunk/octave-forge/main/optim/DESCRIPTION 2010-12-18 18:12:40 UTC (rev 8027) +++ trunk/octave-forge/main/optim/DESCRIPTION 2010-12-21 16:44:20 UTC (rev 8028) @@ -5,7 +5,7 @@ Maintainer: The Octave Community Title: Optimzation. Description: Non-linear optimization toolkit. -Depends: octave (>= 2.9.7), miscellaneous (>= 1.0.10), struct (>= 1.0.8) +Depends: octave (>= 2.9.7), miscellaneous (>= 1.0.11), struct (>= 1.0.8) Autoload: yes License: GPL version 2 or later and GFDL Url: http://octave.sf.net Modified: trunk/octave-forge/main/optim/inst/__dfdp__.m =================================================================== --- trunk/octave-forge/main/optim/inst/__dfdp__.m 2010-12-18 18:12:40 UTC (rev 8027) +++ trunk/octave-forge/main/optim/inst/__dfdp__.m 2010-12-21 16:44:20 UTC (rev 8028) @@ -51,28 +51,31 @@ diff_onesided = false (n, 1); end - if (isfield (hook, 'bounds')) - bounds = hook.bounds; + if (isfield (hook, 'lbound')) + lbound = hook.lbound; else - bounds = ones (n, 2); - bounds(:, 1) = -Inf; - bounds(:, 2) = Inf; + lbound = - Inf (n, 1); end + if (isfield (hook, 'ubound')) + ubound = hook.ubound; + else + ubound = Inf (n, 1); + end + if (isfield (hook, 'plabels')) plabels = hook.plabels; else - plabels = num2cell ((1:n).'); + plabels = cell2cell (num2cell ((1:n).'), 1); end else fixed = false (n, 1); diff_onesided = fixed; diffp = .001 * ones (n, 1); - bounds = ones (n, 2); - bounds(:, 1) = -Inf; - bounds(:, 2) = Inf; - plabels = num2cell ((1:n).'); + lbound = - Inf (n, 1); + ubound = Inf (n, 1); + plabels = cell2cell (num2cell ((1:n).'), 1); end prt = zeros (m, n); % initialise Jacobian to Zero @@ -91,11 +94,11 @@ %% p may be slightly out of bounds due to inaccuracy, or exactly at %% the bound -> single sided interval - idxvl = p <= bounds(:, 1); - idxvg = p >= bounds(:, 2); - p1(idxvl) = min (p(idxvl) + absdel(idxvl), bounds(idxvl, 2)); + idxvl = p <= lbound; + idxvg = p >= ubound; + p1(idxvl) = min (p(idxvl) + absdel(idxvl), ubound(idxvl, 1)); idxd(idxvl) = false; - p1(idxvg) = max (p(idxvg) - absdel(idxvg), bounds(idxvg, 1)); + p1(idxvg) = max (p(idxvg) - absdel(idxvg), lbound(idxvg, 1)); idxd(idxvg) = false; idxs = ~(fixed | idxd); % single sided interval @@ -109,19 +112,19 @@ % versions %% remaining single sided intervals, violating a bound -> take largest %% possible direction of single sided interval - idxvs(idxnvs) = p1(idxnvs) < bounds(idxnvs, 1) | ... - p1(idxnvs) > bounds(idxnvs, 2); - del1 = p(idxvs) - bounds(idxvs, 1); - del2 = bounds(idxvs, 2) - p(idxvs); + idxvs(idxnvs) = p1(idxnvs) < lbound(idxnvs, 1) | ... + p1(idxnvs) > ubound(idxnvs, 1); + del1 = p(idxvs) - lbound(idxvs, 1); + del2 = ubound(idxvs, 1) - p(idxvs); idx1g2 = del1 > del2; idx1g2w(idxvs) = idx1g2; idx1le2w(idxvs) = ~idx1g2; - p1(idx1g2w) = max (p(idx1g2w) - absdel(idx1g2w), bounds(idx1g2w, 1)); + p1(idx1g2w) = max (p(idx1g2w) - absdel(idx1g2w), lbound(idx1g2w, 1)); p1(idx1le2w) = min (p(idx1le2w) + absdel(idx1le2w), ... - bounds(idx1le2w, 2)); + ubound(idx1le2w, 1)); %% double sided interval - p1(idxnvd) = min (p(idxnvd) + absdel(idxnvd), bounds(idxnvd, 2)); - p2(idxnvd) = max (p(idxnvd) - absdel(idxnvd), bounds(idxnvd, 1)); + p1(idxnvd) = min (p(idxnvd) + absdel(idxnvd), ubound(idxnvd, 1)); + p2(idxnvd) = max (p(idxnvd) - absdel(idxnvd), lbound(idxnvd, 1)); del(idxs) = p1(idxs) - p(idxs); del(idxd) = p1(idxd) - p2(idxd); Modified: trunk/octave-forge/main/optim/inst/__lm_svd__.m =================================================================== --- trunk/octave-forge/main/optim/inst/__lm_svd__.m 2010-12-18 18:12:40 UTC (rev 8027) +++ trunk/octave-forge/main/optim/inst/__lm_svd__.m 2010-12-21 16:44:20 UTC (rev 8028) @@ -38,8 +38,8 @@ n_gencstr = hook.n_gencstr; % number of non-linear constraints eq_idx = hook.eq_idx; % logical index of equality constraints in all % constraints - bounds = hook.bounds; % bounds, subset of linear inequality - % constraints in mc and vc + lbound = hook.lbound; % bounds, subset of linear inequality + ubound = hook.ubound; % constraints in mc and vc %% passed values of constraints for initial parameters pin_cstr = hook.pin_cstr; @@ -80,7 +80,8 @@ %% some useful variables derived from passed variables n_lcstr = size (vc, 1); have_constraints_except_bounds = ... - n_lcstr + n_gencstr > sum (reshape (~isinf (bounds), [], 1)); + n_lcstr + n_gencstr > ... + sum (lbound ~= -Inf) + sum (ubound ~= Inf); n = length (pin); wtl = wt(:); @@ -98,7 +99,7 @@ warning ('initial parameters violate equality constraints'); end end - idx = bounds(:, 1) == bounds(:, 2); + idx = lbound == ubound; if (any (idx)) warning ('lower and upper bounds identical for some parameters, fixing the respective parameters'); fixed(idx) = true; @@ -106,18 +107,18 @@ if (all (fixed)) error ('no free parameters'); end - lidx = pin < bounds(:, 1); - uidx = pin > bounds(:, 2); + lidx = pin < lbound; + uidx = pin > ubound; if (any (lidx | uidx) && have_constraints_except_bounds) warning ('initial parameters outside bounds, not corrected since other constraints are given'); else if (any (lidx)) warning ('some initial parameters set to lower bound'); - pin(lidx) = bounds(lidx, 1); + pin(lidx, 1) = lbound(lidx, 1); end if (any (uidx)) warning ('some initial parameters set to upper bound'); - pin(uidx) = bounds(uidx, 2); + pin(uidx, 1) = ubound(uidx, 1); end end if (n_gencstr > 0 && any (~isinf (maxstep))) @@ -425,12 +426,12 @@ %% --- but only if no further constraints are given, otherwise %% the inaccuracy in honoring them might increase by this if (~have_constraints_except_bounds) - lidx = p < bounds(:, 1); - uidx = p > bounds(:, 2); - p(lidx) = bounds(lidx, 1); - p(uidx) = bounds(uidx, 2); - chg(lidx) = p(lidx) - pprev(lidx); - chg(uidx) = p(uidx) - pprev(uidx); + lidx = p < lbound; + uidx = p > ubound; + p(lidx, 1) = lbound(lidx, 1); + p(uidx, 1) = ubound(uidx, 1); + chg(lidx, 1) = p(lidx, 1) - pprev(lidx, 1); + chg(uidx, 1) = p(uidx, 1) - pprev(uidx, 1); end %% f = F (p); Modified: trunk/octave-forge/main/optim/inst/__nonlin_residmin__.m =================================================================== --- trunk/octave-forge/main/optim/inst/__nonlin_residmin__.m 2010-12-18 18:12:40 UTC (rev 8027) +++ trunk/octave-forge/main/optim/inst/__nonlin_residmin__.m 2010-12-21 16:44:20 UTC (rev 8028) @@ -37,13 +37,15 @@ if (nargin == 1 && ischar (f) && strcmp (f, "defaults")) p = optimset ("param_config", [], \ "param_order", [], \ + "param_dims", [], \ "f_inequc_pstruct", false, \ "f_equc_pstruct", false, \ "f_pstruct", false, \ "df_inequc_pstruct", false, \ "df_equc_pstruct", false, \ "dfdp_pstruct", false, \ - "bounds", [], \ + "lbound", [], \ + "ubound", [], \ "dfdp", [], \ "cpiv", @ cpiv_bard, \ "max_fract_change", [], \ @@ -84,6 +86,7 @@ pconf = optimget (settings, "param_config"); pord = optimget (settings, "param_order"); + pdims = optimget (settings, "param_dims"); f_inequc_pstruct = optimget (settings, "f_inequc_pstruct", false); f_equc_pstruct = optimget (settings, "f_equc_pstruct", false); f_pstruct = optimget (settings, "f_pstruct", false); @@ -92,7 +95,8 @@ f_inequc_pstruct); df_equc_pstruct = optimget (settings, "df_equc_pstruct", \ f_equc_pstruct); - bounds = optimget (settings, "bounds"); + lbound = optimget (settings, "lbound"); + ubound = optimget (settings, "ubound"); dfdp = optimget (settings, "dfdp"); if (ischar (dfdp)) dfdp = str2func (dfdp); endif max_fract_change = optimget (settings, "max_fract_change"); @@ -101,6 +105,11 @@ diff_onesided = optimget (settings, "diff_onesided"); fixed = optimget (settings, "fixed"); + any_vector_conf = ! (isempty (lbound) && isempty (ubound) && \ + isempty (max_fract_change) && \ + isempty (fract_prec) && isempty (diffp) && \ + isempty (diff_onesided) && isempty (fixed)); + ## collect constraints [mc, vc, f_genicstr, df_gencstr, user_df_gencstr] = \ __collect_constraints__ (optimget (settings, "inequc")); @@ -117,34 +126,97 @@ if (! user_df_genecstr) df_equc_pstruct = false; endif ## some settings require a parameter order - if (isempty (pord)) - if ((pin_struct || ! isempty (pconf) || f_inequc_pstruct || \ - f_equc_pstruct || f_pstruct || dfdp_pstruct || \ - df_inequc_pstruct || df_equc_pstruct || mc_struct || \ - emc_struct)) - error ("given settings require specification of parameter order"); + if ((pin_struct || ! isempty (pconf) || f_inequc_pstruct || \ + f_equc_pstruct || f_pstruct || dfdp_pstruct || \ + df_inequc_pstruct || df_equc_pstruct || mc_struct || \ + emc_struct)) + if (isempty (pord)) + if (pin_struct) + if (any_vector_conf || \ + ! (f_pstruct && \ + (f_inequc_pstruct || isempty (f_genicstr)) && \ + (f_equc_pstruct || isempty (f_genecstr)) && \ + (dfdp_pstruct || isempty (dfdp)) && \ + (df_inequc_pstruct || ! user_df_gencstr) && \ + (df_equc_pstruct || ! user_df_genecstr) && \ + (mc_struct || isempty (mc)) && \ + (emc_struct || isempty (emc)))) + error ("no parameter order specified and constructing a parameter order from the structure of initial parameters can not be done since not all configuration or given functions are structure based"); + else + pord = fieldnames (pin); + endif + else + error ("given settings require specification of parameter order or initial parameters in the form of a structure"); + endif endif - else pord = pord(:); - if (rows (unique (pord)) < rows (pord)) + if (pin_struct && ! all (arefields (pin, pord))) + error ("some initial parameters lacking"); + endif + if ((nnames = rows (unique (pord))) < rows (pord)) error ("duplicate parameter names in 'param_order'"); endif + if (isempty (pdims)) + if (pin_struct) + pdims = cellfun \ + (@ size, fields2cell (pin, pord), "UniformOutput", false); + else + pdims = num2cell (ones (nnames, 2), 2); + endif + else + pdims = pdims(:); + if (pin_struct && \ + ! all (cellfun (@ (x, y) prod (size (x)) == prod (y), \ + struct2cell (pin), pdims))) + error ("given param_dims and dimensions of initial parameters do not match"); + endif + endif + if (nnames != rows (pdims)) + error ("lengths of 'param_order' and 'param_dims' not equal"); + endif + pnel = cellfun (@ prod, pdims); + ppartidx = cumsum (pnel); + ppartidx = [[1; ppartidx(1:end-1)+1], ppartidx]; + if (any (pnel > 1)) + pnonscalar = true; + cpnel = num2cell (pnel); + prepidx = cat (1, cellfun \ + (@ (x, n) x(ones (1, n), 1), \ + num2cell ((1:nnames).'), cpnel, \ + "UniformOutput", false){:}); + epord = pord(prepidx, 1); + psubidx = cat (1, cellfun \ + (@ (n) (1:n).', cpnel, \ + "UniformOutput", false){:}); + else + pnonscalar = false; # some less expensive interfaces later + prepidx = (1:nnames).'; + epord = pord; + psubidx = ones (nnames, 1); + endif + else + pord = []; # spares checks for given but not needed endif - if (! pin_struct) + if (pin_struct) + np = sum (pnel); + else np = length (pin); - else - np = length (pord); + if (! isempty (pord) && np != sum (pnel)) + error ("number of initial parameters not correct"); + endif endif - plabels = num2cell ((1:np).'); + plabels = cell2cell (num2cell ((1:np).'), 1); if (! isempty (pord)) - plabels = cat (2, plabels, pord); + plabels = cat (2, plabels, cell2cell (epord, 1), \ + cell2cell (num2cell (psubidx), 1)); endif ## some useful vectors zerosvec = zeros (np, 1); NAvec = NA (np, 1); + Infvec = Inf (np, 1); falsevec = false (np, 1); sizevec = [np, 1]; @@ -154,10 +226,9 @@ ## parameter-related configuration is either allowed by a structure ## or by vectors - if (! (isempty (bounds) && isempty (max_fract_change) && \ - isempty (fract_prec) && isempty (diffp) && \ - isempty (diff_onesided) && isempty (fixed))) - error ("if param_config is given, its potential items must not be configured in another way"); + if (any_vector_conf) + error ("if param_config is given, its potential items must not \ + be configured in another way"); endif ## supplement parameter names lacking in param_config @@ -167,52 +238,119 @@ pconf = structcat (1, fields2cell (pconf, pord){:}); - bounds = zeros (np, 2); - bounds(:, 1) = -Inf; - bounds(:, 2) = Inf; - if (isfield (pconf, "bounds")) - bounds(! fieldempty (pconf, "bounds"), :) = cat (1, pconf.bounds); + ## in the following, use reshape with explicit dimensions (instead + ## of x(:)) so that errors are thrown if a configuration item has + ## incorrect number of elements + + lbound = - Infvec; + if (isfield (pconf, "lbound")) + idx = ! fieldempty (pconf, "lbound"); + if (pnonscalar) + lbound (idx(prepidx), 1) = \ + cat (1, cellfun (@ (x, n) reshape (x, n, 1), \ + {pconf(idx).lbound}.', \ + cpnel(idx), "UniformOutput", false){:}); + else + lbound(idx, 1) = cat (1, pconf.lbound); + endif endif + ubound = Infvec; + if (isfield (pconf, "ubound")) + idx = ! fieldempty (pconf, "ubound"); + if (pnonscalar) + ubound (idx(prepidx), 1) = \ + cat (1, cellfun (@ (x, n) reshape (x, n, 1), \ + {pconf(idx).ubound}.', \ + cpnel(idx), "UniformOutput", false){:}); + else + ubound(idx, 1) = cat (1, pconf.ubound); + endif + endif + max_fract_change = fract_prec = NAvec; if (isfield (pconf, "max_fract_change")) - max_fract_change(! fieldempty (pconf, "max_fract_change")) = \ - [pconf.max_fract_change]; + idx = ! fieldempty (pconf, "max_fract_change"); + if (pnonscalar) + max_fract_change(idx(prepidx)) = \ + cat (1, cellfun (@ (x, n) reshape (x, n, 1), \ + {pconf(idx).max_fract_change}.', \ + cpnel(idx), \ + "UniformOutput", false){:}); + else + max_fract_change(idx) = [pconf.max_fract_change]; + endif endif if (isfield (pconf, "fract_prec")) - fract_prec(! fieldempty (pconf, "fract_prec")) = \ - [pconf.fract_prec]; + idx = ! fieldempty (pconf, "fract_prec"); + if (pnonscalar) + fract_prec(idx(prepidx)) = \ + cat (1, cellfun (@ (x, n) reshape (x, n, 1), \ + {pconf(idx).fract_prec}.', cpnel(idx), \ + "UniformOutput", false){:}); + else + fract_prec(idx) = [pconf.fract_prec]; + endif endif diffp = zerosvec; diffp(:) = diffp_default; if (isfield (pconf, "diffp")) - diffp(! fieldempty (pconf, "diffp")) = [pconf.diffp]; + idx = ! fieldempty (pconf, "diffp"); + if (pnonscalar) + diffp(idx(prepidx)) = \ + cat (1, cellfun (@ (x, n) reshape (x, n, 1), \ + {pconf(idx).diffp}.', cpnel(idx), \ + "UniformOutput", false){:}); + else + diffp(idx) = [pconf.diffp]; + endif endif diff_onesided = fixed = falsevec; if (isfield (pconf, "diff_onesided")) - diff_onesided(! fieldempty (pconf, "diff_onesided")) = \ - logical ([pconf.diff_onesided]); + idx = ! fieldempty (pconf, "diff_onesided"); + if (pnonscalar) + diff_onesided(idx(prepidx)) = \ + logical \ + (cat (1, cellfun (@ (x, n) reshape (x, n, 1), \ + {pconf(idx).diff_onesided}.', cpnel(idx), \ + "UniformOutput", false){:})); + else + diff_onesided(idx) = logical ([pconf.diff_onesided]); + endif endif if (isfield (pconf, "fixed")) - fixed(! fieldempty (pconf, "fixed")) = logical ([pconf.fixed]); + idx = ! fieldempty (pconf, "fixed"); + if (pnonscalar) + fixed(idx(prepidx)) = \ + logical \ + (cat (1, cellfun (@ (x, n) reshape (x, n, 1), \ + {pconf(idx).fixed}.', cpnel(idx), \ + "UniformOutput", false){:})); + else + fixed(idx) = logical ([pconf.fixed]); + endif endif else ## use supplied configuration vectors - if (isempty (bounds)) - bounds = zeros (np, 2); - bounds(:, 1) = -Inf; - bounds(:, 2) = Inf; - elseif (any (size (bounds) != [np, 2])) + if (isempty (lbound)) + lbound = - Infvec; + elseif (any (size (lbound) != sizevec)) error ("bounds: wrong dimensions"); endif + if (isempty (ubound)) + ubound = Infvec; + elseif (any (size (ubound) != sizevec)) + error ("bounds: wrong dimensions"); + endif + if (isempty (max_fract_change)) max_fract_change = NAvec; elseif (any (size (max_fract_change) != sizevec)) @@ -256,10 +394,10 @@ endif endif - ## guaranty all (bounds(:, 1) <= bounds(:, 2)) - tp = bounds((idx = bounds(:, 1) > bounds(:, 2)), 2); - bounds(idx, 2) = bounds(idx, 1); - bounds(idx, 1) = tp; + ## guaranty all (lbound <= ubound) + if (any (lbound > ubound)) + error ("some lower bounds larger than upper bounds"); + endif #### consider whether initial parameters and functions are based on #### parameter structures or parameter vectors; wrappers for call to @@ -267,16 +405,27 @@ ## initial parameters if (pin_struct) - if (! all (arefields (pin, pord))) - error ("some initial parameters lacking"); + if (pnonscalar) + pin = cat (1, cellfun (@ (x, n) reshape (x, n, 1), \ + fields2cell (pin, pord), cpnel, \ + "UniformOutput", false){:}); + else + pin = cat (1, fields2cell (pin, pord){:}); endif - pin = cat (1, fields2cell (pin, pord){:}); endif ## model function if (f_pstruct) - f = @ (p, varargin) \ - f (cell2struct (num2cell (p), pord, 1), varargin{:}); + if (pnonscalar) + f = @ (p, varargin) \ + f (cell2struct \ + (cellfun (@ reshape, partarray (p, ppartidx), \ + pdims, "UniformOutput", false), \ + pord, 1), varargin{:}); + else + f = @ (p, varargin) \ + f (cell2struct (num2cell (p), pord, 1), varargin{:}); + endif endif f_pin = f (pin); if (isfield (hook, "observations")) @@ -292,18 +441,37 @@ dfdp = @ (p, hook) __dfdp__ (p, f, hook); endif if (dfdp_pstruct) - dfdp = @ (p, hook) \ - cat (2, \ - fields2cell \ - (dfdp (cell2struct (num2cell (p), pord, 1), hook), \ - pord){:}); + if (pnonscalar) + dfdp = @ (p, hook) \ + cat (2, \ + fields2cell \ + (dfdp (cell2struct \ + (cellfun (@ reshape, partarray (p, ppartidx), \ + pdims, "UniformOutput", false), \ + pord, 1), hook), \ + pord){:}); + else + dfdp = @ (p, hook) \ + cat (2, \ + fields2cell \ + (dfdp (cell2struct (num2cell (p), pord, 1), hook), \ + pord){:}); + endif endif ## function for general inequality constraints if (f_inequc_pstruct) - f_genicstr = @ (p, varargin) \ - f_genicstr \ - (cell2struct (num2cell (p), pord, 1), varargin{:}); + if (pnonscalar) + f_genicstr = @ (p, varargin) \ + f_genicstr (cell2struct \ + (cellfun (@ reshape, partarray (p, ppartidx), \ + pdims, "UniformOutput", false), \ + pord, 1), varargin{:}); + else + f_genicstr = @ (p, varargin) \ + f_genicstr \ + (cell2struct (num2cell (p), pord, 1), varargin{:}); + endif endif ## note this stage @@ -311,19 +479,39 @@ ## jacobian of general inequality constraints if (df_inequc_pstruct) - df_gencstr = @ (p, func, idx, hook) \ - cat (2, \ - fields2cell \ - (df_gencstr (cell2struct (num2cell (p), pord, 1), \ - func, idx, hook), \ - pord){:}); + if (pnonscalar) + df_gencstr = @ (p, func, idx, hook) \ + cat (2, \ + fields2cell \ + (df_gencstr \ + (cell2struct \ + (cellfun (@ reshape, partarray (p, ppartidx), \ + pdims, "UniformOutput", false), pord, 1), \ + func, idx, hook), \ + pord){:}); + else + df_gencstr = @ (p, func, idx, hook) \ + cat (2, \ + fields2cell \ + (df_gencstr (cell2struct (num2cell (p), pord, 1), \ + func, idx, hook), \ + pord){:}); + endif endif ## function for general equality constraints if (f_equc_pstruct) - f_genecstr = @ (p, varargin) \ - f_genecstr \ - (cell2struct (num2cell (p), pord, 1), varargin{:}); + if (pnonscalar) + f_genecstr = @ (p, varargin) \ + f_genecstr (cell2struct \ + (cellfun (@ reshape, partarray (p, ppartidx), \ + pdims, "UniformOutput", false), \ + pord, 1), varargin{:}); + else + f_genecstr = @ (p, varargin) \ + f_genecstr \ + (cell2struct (num2cell (p), pord, 1), varargin{:}); + endif endif ## note this stage @@ -331,12 +519,24 @@ ## jacobian of general equality constraints if (df_equc_pstruct) - df_genecstr = @ (p, func, idx, hook) \ - cat (2, \ - fields2cell \ - (df_genecstr (cell2struct (num2cell (p), pord, 1), \ - func, idx, hook), \ - pord){:}); + if (pnonscalar) + df_genecstr = @ (p, func, idx, hook) \ + cat (2, \ + fields2cell \ + (df_genecstr \ + (cell2struct \ + (cellfun (@ reshape, partarray (p, ppartidx), \ + pdims, "UniformOutput", false), pord, 1), \ + func, idx, hook), \ + pord){:}); + else + df_genecstr = @ (p, func, idx, hook) \ + cat (2, \ + fields2cell \ + (df_genecstr (cell2struct (num2cell (p), pord, 1), \ + func, idx, hook), \ + pord){:}); + endif endif ## linear inequality constraints @@ -347,7 +547,7 @@ endif smc = mc; mc = zeros (np, rows (vc)); - mc(idx, :) = cat (1, fields2cell (smc, pord(idx)){:}); + mc(idx(prepidx), :) = cat (1, fields2cell (smc, pord(idx)){:}); endif ## linear equality constraints @@ -358,21 +558,50 @@ endif semc = emc; emc = zeros (np, rows (evc)); - emc(idx, :) = cat (1, fields2cell (semc, pord(idx)){:}); + emc(idx(prepidx), :) = cat (1, fields2cell (semc, pord(idx)){:}); endif ## parameter-related configuration for jacobi functions if (dfdp_pstruct || df_inequc_pstruct || df_equc_pstruct) - s_diffp = cell2struct (num2cell (diffp), pord, 1); - s_diff_onesided = cell2struct (num2cell (diff_onesided), pord, 1); - s_orig_bounds = cell2struct (num2cell (bounds, 2), pord, 1); - s_plabels = cell2struct (cell2cell (plabels, 1), pord, 1); - s_orig_fixed = cell2struct (num2cell (fixed), pord, 1); + if(pnonscalar) + s_diffp = cell2struct \ + (cellfun (@ reshape, partarray (diffp, ppartidx), \ + pdims, "UniformOutput", false), pord, 1); + s_diff_onesided = cell2struct \ + (cellfun (@ reshape, partarray (diff_onesided, ppartidx), \ + pdims, "UniformOutput", false), pord, 1); + s_orig_lbound = cell2struct \ + (cellfun (@ reshape, partarray (lbound, ppartidx), \ + pdims, "UniformOutput", false), pord, 1); + s_orig_ubound = cell2struct \ + (cellfun (@ reshape, partarray (ubound, ppartidx), \ + pdims, "UniformOutput", false), pord, 1); + s_plabels = cell2struct \ + (cell2cell \ + (cat (2, cellfun \ + (@ (x) cellfun \ + (@ reshape, partarray (cat (1, x{:}), ppartidx), \ + pdims, "UniformOutput", false), \ + cell2cell (plabels, 2), "UniformOutput", false){:}), \ + 1), \ + pord, 1); + s_plabels = cell2struct (cell2cell (plabels, 1), pord, 1); + s_orig_fixed = cell2struct \ + (cellfun (@ reshape, partarray (fixed, ppartidx), \ + pdims, "UniformOutput", false), pord, 1); + else + s_diffp = cell2struct (num2cell (diffp), pord, 1); + s_diff_onesided = cell2struct (num2cell (diff_onesided), pord, 1); + s_orig_lbound = cell2struct (num2cell (lbound), pord, 1); + s_orig_ubound = cell2struct (num2cell (ubound), pord, 1); + s_plabels = cell2struct (cell2cell (plabels, 1), pord, 1); + s_orig_fixed = cell2struct (num2cell (fixed), pord, 1); + endif endif #### some further values and checks - if (any (fixed & (pin < bounds(:, 1) | pin > bounds(:, 2)))) + if (any (fixed & (pin < lbound | pin > ubound))) warning ("some fixed parameters outside bounds"); endif @@ -435,7 +664,8 @@ backend = map_backend (backend); #### handle fixing of parameters - orig_bounds = bounds; + orig_lbound = lbound; + orig_ubound = ubound; orig_fixed = fixed; if (all (fixed)) error ("no free parameters"); @@ -482,7 +712,8 @@ ## _last_ of all, vectors of parameter-related configuration, ## including "fixed" itself - bounds = bounds(nonfixed, :); + lbound = lbound(nonfixed, :); + ubound = ubound(nonfixed, :); max_fract_change = max_fract_change(nonfixed); fract_prec = fract_prec(nonfixed); fixed = fixed(nonfixed); @@ -494,19 +725,20 @@ if (dfdp_pstruct) dfdp = @ (p, hook) \ dfdp (p, cell2fields \ - ({s_diffp, s_diff_onesided, s_orig_bounds, s_plabels, \ + ({s_diffp, s_diff_onesided, s_orig_lbound, \ + s_orig_ubound, s_plabels, \ cell2fields(num2cell(hook.fixed), pord(nonfixed), \ 1, s_orig_fixed)}, \ - {"diffp", "diff_onesided", "bounds", "plabels", \ - "fixed"}, \ + {"diffp", "diff_onesided", "lbound", "ubound", \ + "plabels", "fixed"}, \ 2, hook)); else dfdp = @ (p, hook) \ dfdp (p, cell2fields \ - ({diffp, diff_onesided, orig_bounds, plabels, \ - assign(orig_fixed, nonfixed, hook.fixed)}, \ - {"diffp", "diff_onesided", "bounds", "plabels", \ - "fixed"}, \ + ({diffp, diff_onesided, orig_lbound, orig_ubound, \ + plabels, assign(orig_fixed, nonfixed, hook.fixed)}, \ + {"diffp", "diff_onesided", "lbound", "ubound", \ + "plabels", "fixed"}, \ 2, hook)); endif @@ -514,19 +746,21 @@ if (df_inequc_pstruct) df_gencstr = @ (p, func, idx, hook) \ df_gencstr (p, func, idx, cell2fields \ - ({s_diffp, s_diff_onesided, s_orig_bounds, s_plabels, \ + ({s_diffp, s_diff_onesided, s_orig_lbound, \ + s_orig_ubound, s_plabels, \ cell2fields(num2cell(hook.fixed), pord(nonfixed), \ 1, s_orig_fixed)}, \ - {"diffp", "diff_onesided", "bounds", "plabels", \ - "fixed"}, \ + {"diffp", "diff_onesided", "lbound", "ubound", \ + "plabels", "fixed"}, \ 2, hook)); else df_gencstr = @ (p, func, idx, hook) \ df_gencstr (p, func, idx, cell2fields \ - ({diffp, diff_onesided, orig_bounds, plabels, \ + ({diffp, diff_onesided, orig_lbound, \ + orig_ubound, plabels, \ assign(orig_fixed, nonfixed, hook.fixed)}, \ - {"diffp", "diff_onesided", "bounds", "plabels", \ - "fixed"}, \ + {"diffp", "diff_onesided", "lbound", "ubound", \ + "plabels", "fixed"}, \ 2, hook)); endif @@ -534,19 +768,21 @@ if (df_equc_pstruct) df_genecstr = @ (p, func, idx, hook) \ df_genecstr (p, func, idx, cell2fields \ - ({s_diffp, s_diff_onesided, s_orig_bounds, s_plabels, \ + ({s_diffp, s_diff_onesided, s_orig_lbound, \ + s_orig_ubound, s_plabels, \ cell2fields(num2cell(hook.fixed), pord(nonfixed), \ 1, s_orig_fixed)}, \ - {"diffp", "diff_onesided", "bounds", "plabels", \ - "fixed"}, \ + {"diffp", "diff_onesided", "lbound", "ubound", \ + "plabels", "fixed"}, \ 2, hook)); else df_genecstr = @ (p, func, idx, hook) \ df_genecstr (p, func, idx, cell2fields \ - ({diffp, diff_onesided, orig_bounds, plabels, \ + ({diffp, diff_onesided, orig_lbound, \ + orig_ubound, plabels, \ assign(orig_fixed, nonfixed, hook.fixed)}, \ - {"diffp", "diff_onesided", "bounds", "plabels", \ - "fixed"}, \ + {"diffp", "diff_onesided", "lbound", "ubound", \ + "plabels", "fixed"}, \ 2, hook)); endif @@ -554,10 +790,10 @@ ## include bounds into linear inequality constraints tp = eye (sum (nonfixed)); - lidx = ! isinf (bounds(:, 1)); - uidx = ! isinf (bounds(:, 2)); + lidx = lbound != - Inf; + uidx = ubound != Inf; mc = cat (2, mc, tp(:, lidx), - tp(:, uidx)); - vc = cat (1, vc, - bounds(lidx, 1), bounds(uidx, 2)); + vc = cat (1, vc, - lbound(lidx, 1), ubound(uidx, 1)); ## concatenate linear inequality and equality constraints mc = cat (2, mc, emc); @@ -644,7 +880,8 @@ hook.df_cstr = df_cstr; hook.n_gencstr = n_gencstr; hook.eq_idx = eq_idx; - hook.bounds = bounds; + hook.lbound = lbound; + hook.ubound = ubound; ## passed values of constraints for initial parameters hook.pin_cstr = pin_cstr; @@ -671,7 +908,14 @@ [p, resid, cvg, outp] = backend (f, pin, hook); if (pin_struct) - p = cell2struct (num2cell (p), pord, 1); + if (pnonscalar) + p = cell2struct \ + (cellfun (@ reshape, partarray (p, ppartidx), \ + pdims, "UniformOutput", false), \ + pord, 1); + else + p = cell2struct (num2cell (p), pord, 1); + endif endif endfunction Modified: trunk/octave-forge/main/optim/inst/dcdp.m =================================================================== --- trunk/octave-forge/main/optim/inst/dcdp.m 2010-12-18 18:12:40 UTC (rev 8027) +++ trunk/octave-forge/main/optim/inst/dcdp.m 2010-12-21 16:44:20 UTC (rev 8028) @@ -31,7 +31,8 @@ hook.f = f; if (nargin > 4) - hook.bounds = bounds; + hook.lbounds = bounds(:, 1); + hook.ubounds = bounds(:, 2); end hook.diffp = abs (dp); Modified: trunk/octave-forge/main/optim/inst/dfdp.m =================================================================== --- trunk/octave-forge/main/optim/inst/dfdp.m 2010-12-18 18:12:40 UTC (rev 8027) +++ trunk/octave-forge/main/optim/inst/dfdp.m 2010-12-21 16:44:20 UTC (rev 8028) @@ -59,7 +59,8 @@ hook.f = f; if (nargin > 5) - hook.bounds = bounds; + hook.lbound = bounds(:, 1); + hook.ubound = bounds(:, 2); end hook.diffp = abs (dp); Modified: trunk/octave-forge/main/optim/inst/dfpdp.m =================================================================== --- trunk/octave-forge/main/optim/inst/dfpdp.m 2010-12-18 18:12:40 UTC (rev 8027) +++ trunk/octave-forge/main/optim/inst/dfpdp.m 2010-12-21 16:44:20 UTC (rev 8028) @@ -37,9 +37,9 @@ %% (useful in optimization if some parameters are not optimized, but %% are 'fixed'). %% - %% hook.bounds: Two-column matrix of parameter bounds (or -Inf or - %% +Inf, respectively) to be respected in finite differencing. The - %% consistency of this matrix is not checked. + %% hook.lbound, hook.ubound: vectors of lower and upper parameter + %% bounds (or -Inf or +Inf, respectively) to be respected in finite + %% differencing. The consistency of bounds is not checked. %% This is an interface to __dfdp__.m. Modified: trunk/octave-forge/main/optim/inst/dfxpdp.m =================================================================== --- trunk/octave-forge/main/optim/inst/dfxpdp.m 2010-12-18 18:12:40 UTC (rev 8027) +++ trunk/octave-forge/main/optim/inst/dfxpdp.m 2010-12-21 16:44:20 UTC (rev 8028) @@ -37,9 +37,9 @@ %% (useful in optimization if some parameters are not optimized, but %% are 'fixed'). %% - %% hook.bounds: Two-column matrix of parameter bounds (or -Inf or - %% +Inf, respectively) to be respected in finite differencing. The - %% consistency of this matrix is not checked. + %% hook.lbound, hook.ubound: vectors of lower and upper parameter + %% bounds (or -Inf or +Inf, respectively) to be respected in finite + %% differencing. The consistency of bounds is not checked. %% This is an interface to __dfdp__.m. Modified: trunk/octave-forge/main/optim/inst/nonlin_residmin.m =================================================================== --- trunk/octave-forge/main/optim/inst/nonlin_residmin.m 2010-12-18 18:12:40 UTC (rev 8027) +++ trunk/octave-forge/main/optim/inst/nonlin_residmin.m 2010-12-21 16:44:20 UTC (rev 8028) @@ -75,18 +75,19 @@ ## parameters, reshaped to a column vector, @code{fixed}: logical vector ## indicating which parameters are not optimized, so these partial ## derivatives need not be computed and can be set to zero, -## @code{diffp}, @code{diff_onesided}, @code{bounds}: identical to the -## user settings of this name, @code{plabels}: 2-dimensional cell-array -## with labels for parameters, one row for each parameter, the row -## contains one entry with the numerical index ot this parameter. The -## default jacobian function will call the model function with the -## second argument set with fields @code{f}: as the @code{f} passed to -## the jacobian function, @code{plabels}: row of @code{plabels} as -## passed to the jacobian function corresponding to current parameter, -## @code{side}: @code{0} for one-sided interval, @code{1} or @code{2}, -## respectively, for the sides of a two-sided interval, and -## @code{parallel}: logical scalar indicating parallel computation of -## partial derivatives. +## @code{diffp}, @code{diff_onesided}, @code{lbound}, @code{ubound}: +## identical to the user settings of this name, @code{plabels}: +## 1-dimensional cell-array of column-cell-arrays, each column with +## labels for all parameters, the first column contains the numerical +## indices of the parameters. The default jacobian function will call +## the model function with the second argument set with fields @code{f}: +## as the @code{f} passed to the jacobian function, @code{plabels}: +## cell-array of 1x1 cell-arrays with the entries of the +## column-cell-arrays of @code{plabels} as passed to the jacobian +## function corresponding to current parameter, @code{side}: @code{0} +## for one-sided interval, @code{1} or @code{2}, respectively, for the +## sides of a two-sided interval, and @code{parallel}: logical scalar +## indicating parallel computation of partial derivatives. ## ## @code{diffp}: column vector of fractional intervals (doubled for ## central intervals) supposed to be used by jacobian functions @@ -102,8 +103,8 @@ ## done independently of the backend, but the backend may choose to fix ## additional parameters under certain conditions. ## -## @code{bounds}: 2-column matrix of bounds for parameters. Default: -## @code{-Inf} and @code{+Inf} for the first and second column, +## @code{lbound}, @code{ubound}: column vectors of lower and upper +## bounds for parameters. Default: @code{-Inf} and @code{+Inf}, ## respectively. The bounds are non-strict, i.e. parameters are allowed ## to be exactly equal to a bound. The default jacobian function will ## respect bounds (but no further inequality constraints) in finite @@ -178,8 +179,11 @@ ## ## Structure-based parameter handling ## -## The setting @code{param_order}, a cell-array of parameter names, is a -## prerequisite for any kind of structure-based parameter handling. +## The setting @code{param_order} is a cell-array with names of the +## optimized parameters. If not given, and initial parameters are a +## structure, all parameters in the structure are optimized. It is an +## error if @code{param_order} is not given and there are any +## non-structure-based configuration items or functions. ## ## The initial parameters @var{pin} can be given as a structure ## containing at least all fields named in @code{param_order}. In this @@ -202,17 +206,28 @@ ## matrix in fields under the respective parameter names can be given. ## In this case, rows containing only zeros need not be given. ## -## The vector/matrix-based settings @code{bounds}, @code{fixed}, -## @code{diffp}, @code{diff_onesided}, @code{fract_prec}, and -## @code{max_fract_change} can be replaced by the setting +## The vector-based settings @code{lbound}, @code{ubound}, +## @code{fixed}, @code{diffp}, @code{diff_onesided}, @code{fract_prec}, +## and @code{max_fract_change} can be replaced by the setting ## @code{param_config}. It is a structure that can contain fields named ## in @code{param_order}. For each such field, there may be subfields -## with the same names as the above vector/matrix-based settings, but -## containing a scalar value (or a two-element row vector in the case of -## bounds) for the respective parameter. If @code{param_config} is -## specified, none of the above vector/matrix-based settings may be -## used. +## with the same names as the above vector-based settings, but +## containing a scalar value for the respective parameter. If +## @code{param_config} is specified, none of the above +## vector/matrix-based settings may be used. ## +## Additionally, named parameters are allowed to be non-scalar real +## arrays. In this case, their dimensions are given by the setting +## @code{param_dims}, a cell-array of dimension vectors, each containing +## at least two dimensions; if not given, dimensions are taken from the +## initial parameters, if these are given in a structure. Any +## vector-based settings or not structure-based linear constraints then +## must correspond to an order of parameters with all parameters +## reshaped to vectors and concatenated in the user-given order of +## parameter names. Structure-based settings or structure-based initial +## parameters must contain arrays with dimensions reshapable to those of +## the respective parameters. +## ## Description of backends (currently only one) ## ## "lm_svd_feasible" This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <i7...@us...> - 2011-01-16 17:47:45
|
Revision: 8058 http://octave.svn.sourceforge.net/octave/?rev=8058&view=rev Author: i7tiol Date: 2011-01-16 17:47:39 +0000 (Sun, 16 Jan 2011) Log Message: ----------- Forgot to add this in the previous commit. Modified Paths: -------------- trunk/octave-forge/main/optim/DESCRIPTION Added Paths: ----------- trunk/octave-forge/main/optim/PKG_ADD Modified: trunk/octave-forge/main/optim/DESCRIPTION =================================================================== --- trunk/octave-forge/main/optim/DESCRIPTION 2011-01-16 17:46:28 UTC (rev 8057) +++ trunk/octave-forge/main/optim/DESCRIPTION 2011-01-16 17:47:39 UTC (rev 8058) @@ -5,7 +5,7 @@ Maintainer: The Octave Community Title: Optimzation. Description: Non-linear optimization toolkit. -Depends: octave (>= 2.9.7), miscellaneous (>= 1.0.11), struct (>= 1.0.8) +Depends: octave (>= 2.9.7), miscellaneous (>= 1.0.11), struct (>= 1.0.9) Autoload: yes License: GPL version 2 or later and GFDL Url: http://octave.sf.net Added: trunk/octave-forge/main/optim/PKG_ADD =================================================================== --- trunk/octave-forge/main/optim/PKG_ADD (rev 0) +++ trunk/octave-forge/main/optim/PKG_ADD 2011-01-16 17:47:39 UTC (rev 8058) @@ -0,0 +1,5 @@ +if (compare_versions (version (), "3.3.55", ">=")) + ## optimset mechanism was fixed for option names with underscores + ## sometime in 3.3.54+, if I remember right + __all_opts__ ("__nonlin_residmin__"); +endif This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <i7...@us...> - 2011-02-25 08:44:36
|
Revision: 8137 http://octave.svn.sourceforge.net/octave/?rev=8137&view=rev Author: i7tiol Date: 2011-02-25 08:44:30 +0000 (Fri, 25 Feb 2011) Log Message: ----------- Update copyright notices of functions for 'subpackage' nonlin_residmin. Modified Paths: -------------- trunk/octave-forge/main/optim/DESCRIPTION trunk/octave-forge/main/optim/inst/__collect_constraints__.m trunk/octave-forge/main/optim/inst/__dfdp__.m trunk/octave-forge/main/optim/inst/__lm_svd__.m trunk/octave-forge/main/optim/inst/__nonlin_residmin__.m trunk/octave-forge/main/optim/inst/__plot_cmds__.m trunk/octave-forge/main/optim/inst/cpiv_bard.m trunk/octave-forge/main/optim/inst/dcdp.m trunk/octave-forge/main/optim/inst/dfdp.m trunk/octave-forge/main/optim/inst/dfpdp.m trunk/octave-forge/main/optim/inst/dfxpdp.m trunk/octave-forge/main/optim/inst/gjp.m trunk/octave-forge/main/optim/inst/leasqr.m trunk/octave-forge/main/optim/inst/nonlin_curvefit.m trunk/octave-forge/main/optim/inst/nonlin_residmin.m Modified: trunk/octave-forge/main/optim/DESCRIPTION =================================================================== --- trunk/octave-forge/main/optim/DESCRIPTION 2011-02-25 08:33:33 UTC (rev 8136) +++ trunk/octave-forge/main/optim/DESCRIPTION 2011-02-25 08:44:30 UTC (rev 8137) @@ -1,6 +1,6 @@ Name: Optim Version: 1.0.16 -Date: 2010-12-02 +Date: 2011-01-01 Author: Various Authors Maintainer: The Octave Community Title: Optimzation. Modified: trunk/octave-forge/main/optim/inst/__collect_constraints__.m =================================================================== --- trunk/octave-forge/main/optim/inst/__collect_constraints__.m 2011-02-25 08:33:33 UTC (rev 8136) +++ trunk/octave-forge/main/optim/inst/__collect_constraints__.m 2011-02-25 08:44:30 UTC (rev 8137) @@ -1,4 +1,4 @@ -## Copyright (C) 2010 Olaf Till <ola...@un...> +## Copyright (C) 2010, 2011 Olaf Till <ola...@un...> ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by Modified: trunk/octave-forge/main/optim/inst/__dfdp__.m =================================================================== --- trunk/octave-forge/main/optim/inst/__dfdp__.m 2011-02-25 08:33:33 UTC (rev 8136) +++ trunk/octave-forge/main/optim/inst/__dfdp__.m 2011-02-25 08:44:30 UTC (rev 8137) @@ -1,7 +1,7 @@ %% Copyright (C) 1992-1994 Richard Shrager %% Copyright (C) 1992-1994 Arthur Jutan %% Copyright (C) 1992-1994 Ray Muzic -%% Copyright (C) 2010 Olaf Till <ola...@un...> +%% Copyright (C) 2010, 2011 Olaf Till <ola...@un...> %% %% This program is free software; you can redistribute it and/or modify %% it under the terms of the GNU General Public License as published by Modified: trunk/octave-forge/main/optim/inst/__lm_svd__.m =================================================================== --- trunk/octave-forge/main/optim/inst/__lm_svd__.m 2011-02-25 08:33:33 UTC (rev 8136) +++ trunk/octave-forge/main/optim/inst/__lm_svd__.m 2011-02-25 08:44:30 UTC (rev 8137) @@ -1,7 +1,7 @@ %% Copyright (C) 1992-1994 Richard Shrager %% Copyright (C) 1992-1994 Arthur Jutan %% Copyright (C) 1992-1994 Ray Muzic -%% Copyright (C) 2010 Olaf Till <ola...@un...> +%% Copyright (C) 2010, 2011 Olaf Till <ola...@un...> %% %% This program is free software; you can redistribute it and/or modify %% it under the terms of the GNU General Public License as published by Modified: trunk/octave-forge/main/optim/inst/__nonlin_residmin__.m =================================================================== --- trunk/octave-forge/main/optim/inst/__nonlin_residmin__.m 2011-02-25 08:33:33 UTC (rev 8136) +++ trunk/octave-forge/main/optim/inst/__nonlin_residmin__.m 2011-02-25 08:44:30 UTC (rev 8137) @@ -1,4 +1,4 @@ -## Copyright (C) 2010 Olaf Till <ola...@un...> +## Copyright (C) 2010, 2011 Olaf Till <ola...@un...> ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by Modified: trunk/octave-forge/main/optim/inst/__plot_cmds__.m =================================================================== --- trunk/octave-forge/main/optim/inst/__plot_cmds__.m 2011-02-25 08:33:33 UTC (rev 8136) +++ trunk/octave-forge/main/optim/inst/__plot_cmds__.m 2011-02-25 08:44:30 UTC (rev 8137) @@ -1,4 +1,4 @@ -%% Copyright (C) 2010 Olaf Till <ola...@un...> +%% Copyright (C) 2010, 2011 Olaf Till <ola...@un...> %% %% This program is free software; you can redistribute it and/or modify %% it under the terms of the GNU General Public License as published by Modified: trunk/octave-forge/main/optim/inst/cpiv_bard.m =================================================================== --- trunk/octave-forge/main/optim/inst/cpiv_bard.m 2011-02-25 08:33:33 UTC (rev 8136) +++ trunk/octave-forge/main/optim/inst/cpiv_bard.m 2011-02-25 08:44:30 UTC (rev 8137) @@ -1,4 +1,4 @@ -%% Copyright (C) 2010 Olaf Till +%% Copyright (C) 2010, 2011 Olaf Till %% %% This program is free software; you can redistribute it and/or modify %% it under the terms of the GNU General Public License as published by Modified: trunk/octave-forge/main/optim/inst/dcdp.m =================================================================== --- trunk/octave-forge/main/optim/inst/dcdp.m 2011-02-25 08:33:33 UTC (rev 8136) +++ trunk/octave-forge/main/optim/inst/dcdp.m 2011-02-25 08:44:30 UTC (rev 8137) @@ -1,4 +1,4 @@ -%% Copyright (C) 2010 Olaf Till <ola...@un...> +%% Copyright (C) 2010, 2011 Olaf Till <ola...@un...> %% %% This program is free software; you can redistribute it and/or modify %% it under the terms of the GNU General Public License as published by Modified: trunk/octave-forge/main/optim/inst/dfdp.m =================================================================== --- trunk/octave-forge/main/optim/inst/dfdp.m 2011-02-25 08:33:33 UTC (rev 8136) +++ trunk/octave-forge/main/optim/inst/dfdp.m 2011-02-25 08:44:30 UTC (rev 8137) @@ -1,7 +1,7 @@ %% Copyright (C) 1992-1994 Richard Shrager %% Copyright (C) 1992-1994 Arthur Jutan %% Copyright (C) 1992-1994 Ray Muzic -%% Copyright (C) 2010 Olaf Till <ola...@un...> +%% Copyright (C) 2010, 2011 Olaf Till <ola...@un...> %% %% This program is free software; you can redistribute it and/or modify %% it under the terms of the GNU General Public License as published by Modified: trunk/octave-forge/main/optim/inst/dfpdp.m =================================================================== --- trunk/octave-forge/main/optim/inst/dfpdp.m 2011-02-25 08:33:33 UTC (rev 8136) +++ trunk/octave-forge/main/optim/inst/dfpdp.m 2011-02-25 08:44:30 UTC (rev 8137) @@ -1,4 +1,4 @@ -%% Copyright (C) 2010 Olaf Till <ola...@un...> +%% Copyright (C) 2010, 2011 Olaf Till <ola...@un...> %% %% This program is free software; you can redistribute it and/or modify %% it under the terms of the GNU General Public License as published by Modified: trunk/octave-forge/main/optim/inst/dfxpdp.m =================================================================== --- trunk/octave-forge/main/optim/inst/dfxpdp.m 2011-02-25 08:33:33 UTC (rev 8136) +++ trunk/octave-forge/main/optim/inst/dfxpdp.m 2011-02-25 08:44:30 UTC (rev 8137) @@ -1,4 +1,4 @@ -%% Copyright (C) 2010 Olaf Till <ola...@un...> +%% Copyright (C) 2010, 2011 Olaf Till <ola...@un...> %% %% This program is free software; you can redistribute it and/or modify %% it under the terms of the GNU General Public License as published by Modified: trunk/octave-forge/main/optim/inst/gjp.m =================================================================== --- trunk/octave-forge/main/optim/inst/gjp.m 2011-02-25 08:33:33 UTC (rev 8136) +++ trunk/octave-forge/main/optim/inst/gjp.m 2011-02-25 08:44:30 UTC (rev 8137) @@ -1,4 +1,4 @@ -%% Copyright (C) 2010 Olaf Till +%% Copyright (C) 2010, 2011 Olaf Till %% %% This program is free software; you can redistribute it and/or modify %% it under the terms of the GNU General Public License as published by Modified: trunk/octave-forge/main/optim/inst/leasqr.m =================================================================== --- trunk/octave-forge/main/optim/inst/leasqr.m 2011-02-25 08:33:33 UTC (rev 8136) +++ trunk/octave-forge/main/optim/inst/leasqr.m 2011-02-25 08:44:30 UTC (rev 8137) @@ -1,7 +1,7 @@ %% Copyright (C) 1992-1994 Richard Shrager %% Copyright (C) 1992-1994 Arthur Jutan %% Copyright (C) 1992-1994 Ray Muzic -%% Copyright (C) 2010 Olaf Till <ola...@un...> +%% Copyright (C) 2010, 2011 Olaf Till <ola...@un...> %% %% This program is free software; you can redistribute it and/or modify %% it under the terms of the GNU General Public License as published by Modified: trunk/octave-forge/main/optim/inst/nonlin_curvefit.m =================================================================== --- trunk/octave-forge/main/optim/inst/nonlin_curvefit.m 2011-02-25 08:33:33 UTC (rev 8136) +++ trunk/octave-forge/main/optim/inst/nonlin_curvefit.m 2011-02-25 08:44:30 UTC (rev 8137) @@ -1,4 +1,4 @@ -## Copyright (C) 2010 Olaf Till <ola...@un...> +## Copyright (C) 2010, 2011 Olaf Till <ola...@un...> ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by Modified: trunk/octave-forge/main/optim/inst/nonlin_residmin.m =================================================================== --- trunk/octave-forge/main/optim/inst/nonlin_residmin.m 2011-02-25 08:33:33 UTC (rev 8136) +++ trunk/octave-forge/main/optim/inst/nonlin_residmin.m 2011-02-25 08:44:30 UTC (rev 8137) @@ -1,4 +1,4 @@ -## Copyright (C) 2010 Olaf Till <ola...@un...> +## Copyright (C) 2010, 2011 Olaf Till <ola...@un...> ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <i7...@us...> - 2011-02-25 10:07:14
|
Revision: 8139 http://octave.svn.sourceforge.net/octave/?rev=8139&view=rev Author: i7tiol Date: 2011-02-25 10:07:07 +0000 (Fri, 25 Feb 2011) Log Message: ----------- Fix new bounds handling. Fix demo 2. Modified Paths: -------------- trunk/octave-forge/main/optim/DESCRIPTION trunk/octave-forge/main/optim/inst/leasqr.m Modified: trunk/octave-forge/main/optim/DESCRIPTION =================================================================== --- trunk/octave-forge/main/optim/DESCRIPTION 2011-02-25 08:58:49 UTC (rev 8138) +++ trunk/octave-forge/main/optim/DESCRIPTION 2011-02-25 10:07:07 UTC (rev 8139) @@ -1,6 +1,6 @@ Name: Optim Version: 1.0.16 -Date: 2011-01-01 +Date: 2011-02-25 Author: Various Authors Maintainer: The Octave Community Title: Optimzation. Modified: trunk/octave-forge/main/optim/inst/leasqr.m =================================================================== --- trunk/octave-forge/main/optim/inst/leasqr.m 2011-02-25 08:58:49 UTC (rev 8138) +++ trunk/octave-forge/main/optim/inst/leasqr.m 2011-02-25 10:07:07 UTC (rev 8139) @@ -538,8 +538,9 @@ hook.eq_idx = false (size (vc, 1) + n_gencstr, 1); hook.eq_idx(eq_idx) = true; % logical index of equality constraints in % all constraints - hook.bounds = bounds; % bounds, subset of linear inequality + hook.lbound = bounds(:, 1); % bounds, subset of linear inequality % constraints in mc and vc + hook.ubound = bounds(:, 2); %% passed values of constraints for initial parameters hook.pin_cstr = pin_cstr; @@ -783,7 +784,7 @@ %! %% other configuration (default values): %! tolerance = .0001; %! max_iterations = 20; -%! weights = ones (5, 1); +%! weights = ones (1, 5); %! dp = [.001; .001]; % bidirectional numeric gradient stepsize %! dFdp = 'dfdp'; % function for gradient (numerical) %! This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <i7...@us...> - 2011-03-07 20:06:11
|
Revision: 8164 http://octave.svn.sourceforge.net/octave/?rev=8164&view=rev Author: i7tiol Date: 2011-03-07 20:06:05 +0000 (Mon, 07 Mar 2011) Log Message: ----------- Fix some empty index problems. Modified Paths: -------------- trunk/octave-forge/main/optim/DESCRIPTION trunk/octave-forge/main/optim/inst/__dfdp__.m Modified: trunk/octave-forge/main/optim/DESCRIPTION =================================================================== --- trunk/octave-forge/main/optim/DESCRIPTION 2011-03-07 17:34:16 UTC (rev 8163) +++ trunk/octave-forge/main/optim/DESCRIPTION 2011-03-07 20:06:05 UTC (rev 8164) @@ -1,6 +1,6 @@ Name: Optim -Version: 1.0.16 -Date: 2011-02-25 +Version: 1.0.17 +Date: 2011-03-07 Author: Various Authors Maintainer: The Octave Community Title: Optimzation. Modified: trunk/octave-forge/main/optim/inst/__dfdp__.m =================================================================== --- trunk/octave-forge/main/optim/inst/__dfdp__.m 2011-03-07 17:34:16 UTC (rev 8163) +++ trunk/octave-forge/main/optim/inst/__dfdp__.m 2011-03-07 20:06:05 UTC (rev 8164) @@ -96,9 +96,9 @@ %% the bound -> single sided interval idxvl = p <= lbound; idxvg = p >= ubound; - p1(idxvl) = min (p(idxvl) + absdel(idxvl), ubound(idxvl, 1)); + p1(idxvl) = min (p(idxvl, 1) + absdel(idxvl, 1), ubound(idxvl, 1)); idxd(idxvl) = false; - p1(idxvg) = max (p(idxvg) - absdel(idxvg), lbound(idxvg, 1)); + p1(idxvg) = max (p(idxvg, 1) - absdel(idxvg, 1), lbound(idxvg, 1)); idxd(idxvg) = false; idxs = ~(fixed | idxd); % single sided interval @@ -112,19 +112,22 @@ % versions %% remaining single sided intervals, violating a bound -> take largest %% possible direction of single sided interval - idxvs(idxnvs) = p1(idxnvs) < lbound(idxnvs, 1) | ... - p1(idxnvs) > ubound(idxnvs, 1); - del1 = p(idxvs) - lbound(idxvs, 1); - del2 = ubound(idxvs, 1) - p(idxvs); + idxvs(idxnvs) = p1(idxnvs, 1) < lbound(idxnvs, 1) | ... + p1(idxnvs, 1) > ubound(idxnvs, 1); + del1 = p(idxvs, 1) - lbound(idxvs, 1); + del2 = ubound(idxvs, 1) - p(idxvs, 1); idx1g2 = del1 > del2; idx1g2w(idxvs) = idx1g2; idx1le2w(idxvs) = ~idx1g2; - p1(idx1g2w) = max (p(idx1g2w) - absdel(idx1g2w), lbound(idx1g2w, 1)); - p1(idx1le2w) = min (p(idx1le2w) + absdel(idx1le2w), ... + p1(idx1g2w) = max (p(idx1g2w, 1) - absdel(idx1g2w, 1), ... + lbound(idx1g2w, 1)); + p1(idx1le2w) = min (p(idx1le2w, 1) + absdel(idx1le2w, 1), ... ubound(idx1le2w, 1)); %% double sided interval - p1(idxnvd) = min (p(idxnvd) + absdel(idxnvd), ubound(idxnvd, 1)); - p2(idxnvd) = max (p(idxnvd) - absdel(idxnvd), lbound(idxnvd, 1)); + p1(idxnvd) = min (p(idxnvd, 1) + absdel(idxnvd, 1), ... + ubound(idxnvd, 1)); + p2(idxnvd) = max (p(idxnvd, 1) - absdel(idxnvd, 1), ... + lbound(idxnvd, 1)); del(idxs) = p1(idxs) - p(idxs); del(idxd) = p1(idxd) - p2(idxd); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |