diff options
Diffstat (limited to 'build/Scilab')
| -rw-r--r-- | build/Scilab/Checkdims.sci | 56 | ||||
| -rw-r--r-- | build/Scilab/Checklhs.sci | 79 | ||||
| -rw-r--r-- | build/Scilab/Checkrhs.sci | 102 | ||||
| -rw-r--r-- | build/Scilab/Checktype.sci | 3 | ||||
| -rw-r--r-- | build/Scilab/Checkvector.sci | 2 | ||||
| -rw-r--r-- | build/Scilab/intfmincon.sci | 317 | ||||
| -rw-r--r-- | build/Scilab/intfminimax.sci | 454 |
7 files changed, 900 insertions, 113 deletions
diff --git a/build/Scilab/Checkdims.sci b/build/Scilab/Checkdims.sci new file mode 100644 index 0000000..0936222 --- /dev/null +++ b/build/Scilab/Checkdims.sci @@ -0,0 +1,56 @@ + +// Copyright (C) 2010 - DIGITEO - Michael Baudin +// +// This file must be used under the terms of the GNU LGPL license. + +function errmsg = Checkdims ( funname , var , varname , ivar , matdims ) + // Generates an error if the variable has not the required size. + // + // Calling Sequence + // errmsg = Checkdims ( funname , var , varname , ivar , matdims ) + // + // Parameters + // funname : a 1 x 1 matrix of strings, the name of the calling function. + // var : a 1 x 1 matrix of valid Scilab data type, the variable + // varname : a 1 x 1 matrix of string, the name of the variable + // ivar : a 1 x 1 matrix of floating point integers, the index of the input argument in the calling sequence + // matdims : 1 x 2 matrix of floating point integers, the number of rows, columns for the variable #ivar + // errmsg : a 1 x 1 matrix of strings, the error message. If there was no error, the error message is the empty matrix. + // + // Description + // This function is designed to be used to design functions where + // the input argument has a known shape. + // This function cannot be use when var is a function, or more + // generally, for any input argument for which the size function + // does not work. + // Last update : 05/08/2010. + // + // Examples + // // The function takes a 2 x 3 matrix of doubles. + // function y = myfunction ( x ) + // Checkdims ( "myfunction" , x , "x" , 1 , [2 3] ) + // y = x + // endfunction + // // Calling sequences which work + // y = myfunction ( ones(2,3) ) + // y = myfunction ( zeros(2,3) ) + // // Calling sequences which generate an error + // y = myfunction ( ones(1,3) ) + // y = myfunction ( zeros(2,4) ) + // + // Authors + // Michael Baudin - 2010 - DIGITEO + // + + [lhs,rhs]=argn() + Checkrhs ( funname , rhs , 5 ) + Checklhs ( funname , lhs , [0 1] ) + + errmsg = [] + if ( or ( size(var) <> matdims ) ) then + strexp = strcat(string(matdims)," ") + strcomp = strcat(string(size(var))," ") + errmsg = msprintf(gettext("%s: Expected size [%s] for input argument %s at input #%d, but got [%s] instead."), funname, strexp, varname , ivar , strcomp ); + error(errmsg) + end +endfunction diff --git a/build/Scilab/Checklhs.sci b/build/Scilab/Checklhs.sci new file mode 100644 index 0000000..fd47b0c --- /dev/null +++ b/build/Scilab/Checklhs.sci @@ -0,0 +1,79 @@ +// Copyright (C) 2010 - DIGITEO - Michael Baudin +// +// This file must be used under the terms of the GNU LGPL license. + +function errmsg = Checklhs ( funname , lhs , lhsset ) + // Generates an error if the number of LHS is not in given set. + // + // Calling Sequence + // errmsg = Checklhs ( funname , lhs , lhsset ) + // + // Parameters + // funname : a 1 x 1 matrix of strings, the name of the calling function. + // lhs : a 1 x 1 matrix of floating point integers, the actual number of output arguments + // lhsset : a 1 x n or n x 1 matrix of floating point integers, the authorized number of output arguments + // errmsg : a 1 x 1 matrix of strings, the error message. If there was no error, the error message is the empty matrix. + // + // Description + // This function is designed to be used to design functions with + // variable number of output arguments. + // Notice that it is useless to call this function if the + // function definition does not use the varargout statement. + // Notice that a function as a minimum of 1 output argument. + // Last update : 29/07/2010. + // + // Examples + // // The function takes 3 input arguments and 1/2 output arguments + // function varargout = myfunction ( x1 , x2 , x3 ) + // [lhs, rhs] = argn() + // Checkrhs ( "myfunction" , rhs , 3 : 3 ) + // Checklhs ( "myfunction" , lhs , 1 : 2 ) + // y1 = x1 + x2 + // y2 = x2 + x3 + // varargout(1) = y1 + // if ( lhs == 2 ) then + // varargout(2) = y2 + // end + // endfunction + // // Calling sequences which work + // myfunction ( 1 , 2 , 3 ) + // y1 = myfunction ( 1 , 2 , 3 ) + // [ y1 , y2 ] = myfunction ( 1 , 2 , 3 ) + // // Calling sequences which generate an error + // [ y1 , y2 , y3 ] = myfunction ( 1 , 2 , 3 ) + // + // // The function takes 1 or 3 output arguments, but not 2 + // function varargout = myfunction ( x1 , x2 , x3 ) + // [lhs, rhs] = argn() + // Checkrhs ( "myfunction" , rhs , 3 : 3 ) + // Checklhs ( "myfunction" , lhs , [1 3] ) + // y1 = x1 + x2 + // y2 = x2 + x3 + // y3 = x1 + x3 + // varargout(1) = y1 + // if ( lhs == 3 ) then + // varargout(2) = y2 + // varargout(3) = y3 + // end + // endfunction + // // Calling sequences which work + // myfunction ( 1 , 2 , 3 ) + // y1 = myfunction ( 1 , 2 , 3 ) + // [ y1 , y2 , y3 ] = myfunction ( 1 , 2 , 3 ) + // // Calling sequences which generate an error + // [y1 , y2] = myfunction ( 1 , 2 , 3 ) + // + // Authors + // Michael Baudin - 2010 - DIGITEO + // + + errmsg = [] + if ( and ( lhs <> lhsset ) ) then + lhsstr = strcat(string(lhsset)," ") + errmsg = msprintf(gettext("%s: Unexpected number of output arguments : %d provided while the expected number of output arguments should be in the set [%s]."), funname , lhs , lhsstr ); + error(errmsg) + end +endfunction + + + diff --git a/build/Scilab/Checkrhs.sci b/build/Scilab/Checkrhs.sci new file mode 100644 index 0000000..6b5cf5b --- /dev/null +++ b/build/Scilab/Checkrhs.sci @@ -0,0 +1,102 @@ +// Copyright (C) 2010 - DIGITEO - Michael Baudin +// +// This file must be used under the terms of the GNU LGPL license. + +function errmsg = Checkrhs ( funname , rhs , rhsset ) + // Generates an error if the number of RHS is not in given set. + // + // Calling Sequence + // errmsg = Checkrhs ( funname , rhs , rhsset ) + // + // Parameters + // funname : a 1 x 1 matrix of strings, the name of the calling function. + // rhs : a 1 x 1 matrix of floating point integers, the actual number of input arguments + // rhsset : a 1 x n or n x 1 matrix of floating point integers, the authorized number of input arguments + // errmsg : a 1 x 1 matrix of strings, the error message. If there was no error, the error message is the empty matrix. + // + // Description + // This function is designed to be used to design functions with + // variable number of input arguments. + // Notice that it is useless to call this function if the + // function definition does not use the varargin statement. + // Last update : 05/08/2010. + // Last update : 29/07/2010. + // + // Examples + // // The function takes 2/3 input arguments and 1 output arguments + // function y = myfunction ( varargin ) + // [lhs, rhs] = argn() + // Checkrhs ( "myfunction" , rhs , 2:3 ) + // Checklhs ( "myfunction" , lhs , 1 ) + // x1 = varargin(1) + // x2 = varargin(2) + // if ( rhs >= 3 ) then + // x3 = varargin(3) + // else + // x3 = 2 + // end + // y = x1 + x2 + x3 + // endfunction + // // Calling sequences which work + // y = myfunction ( 1 , 2 ) + // y = myfunction ( 1 , 2 , 3 ) + // // Calling sequences which generate an error + // y = myfunction ( 1 ) + // y = myfunction ( 1 , 2 , 3 , 4 ) + // + // // The function takes 2 or 4 input arguments, but not 3 + // function y = myfunction ( varargin ) + // [lhs, rhs] = argn() + // Checkrhs ( "myfunction" , rhs , [2 4] ) + // Checklhs ( "myfunction" , lhs , 1 ) + // x1 = varargin(1) + // x2 = varargin(2) + // if ( rhs >= 3 ) then + // x3 = varargin(3) + // x4 = varargin(4) + // else + // x3 = 2 + // x4 = 3 + // end + // y = x1 + x2 + x3 + x4 + // endfunction + // // Calling sequences which work + // y = myfunction ( 1 , 2 ) + // y = myfunction ( 1 , 2 , 3 , 4 ) + // // Calling sequences which generate an error + // y = myfunction ( 1 ) + // y = myfunction ( 1 , 2 , 3 ) + // y = myfunction ( 1 , 2 , 3 , 4, 5 ) + // + // // The function takes 2 input arguments and 0/1 output arguments. + // // Notice that if the checkrhs function is not called, + // // the variable x2 might be used from the user's context, + // // that is, if the caller has defined the variable x2, it + // // is used in the callee. + // // Here, we want to avoid this. + // function y = myfunction ( x1 , x2 ) + // [lhs, rhs] = argn() + // Checkrhs ( "myfunction" , rhs , 2 ) + // Checklhs ( "myfunction" , lhs , [0 1] ) + // y = x1 + x2 + // endfunction + // // Calling sequences which work + // y = myfunction ( 1 , 2 ) + // // Calling sequences which generate an error + // y = myfunction ( 1 ) + // y = myfunction ( 1 , 2 , 3 ) + // + // Authors + // Michael Baudin - 2010 - DIGITEO + // + + errmsg = [] + if ( and(rhs <> rhsset) ) then + rhsstr = strcat(string(rhsset)," ") + errmsg = msprintf(gettext("%s: Unexpected number of input arguments : %d provided while the number of expected input arguments should be in the set [%s]."), funname , rhs , rhsstr ); + error(errmsg) + end +endfunction + + + diff --git a/build/Scilab/Checktype.sci b/build/Scilab/Checktype.sci index 0465d7f..3f50fa2 100644 --- a/build/Scilab/Checktype.sci +++ b/build/Scilab/Checktype.sci @@ -60,3 +60,6 @@ function errmsg = Checktype ( funname , var , varname , ivar , expectedtype ) error(errmsg); end endfunction + + + diff --git a/build/Scilab/Checkvector.sci b/build/Scilab/Checkvector.sci index f24a92d..76bdcc6 100644 --- a/build/Scilab/Checkvector.sci +++ b/build/Scilab/Checkvector.sci @@ -49,7 +49,7 @@ function errmsg = Checkvector ( funname , var , varname , ivar , nbval ) ncols = size(var,"c") if ( nrows <> 1 & ncols <> 1 ) then strcomp = strcat(string(size(var))," ") - errmsg = msprintf(gettext("%s: Expected a vector matrix for input argument %s at input #%d, but current dimensions are [%s] instead."), funname, varname , ivar , strcomp ); + errmsg = msprintf(gettext("%s: Expected a vector matrix for input argument %s at input #%d, but got [%s] instead."), funname, varname , ivar , strcomp ); error(errmsg) end if ( ( nrows == 1 & ncols <> nbval ) | ( ncols == 1 & nrows <> nbval ) ) then diff --git a/build/Scilab/intfmincon.sci b/build/Scilab/intfmincon.sci index 0d6cf6d..cd234de 100644 --- a/build/Scilab/intfmincon.sci +++ b/build/Scilab/intfmincon.sci @@ -10,48 +10,53 @@ // Email: toolbox@scilab.in function [xopt,fopt,exitflag,gradient,hessian] = intfmincon (varargin) - // Solves a constrainted multi-variable mixed integer non linear programming problem - // - // Calling Sequence - // xopt = intfmincon(f,x0,intcon,A,b) - // xopt = intfmincon(f,x0,intcon,A,b,Aeq,beq) - // xopt = intfmincon(f,x0,intcon,A,b,Aeq,beq,lb,ub) - // xopt = intfmincon(f,x0,intcon,A,b,Aeq,beq,lb,ub,nlc) - // xopt = intfmincon(f,x0,intcon,A,b,Aeq,beq,lb,ub,nlc,options) - // [xopt,fopt] = intfmincon(.....) - // [xopt,fopt,exitflag]= intfmincon(.....) - // [xopt,fopt,exitflag,gradient]=intfmincon(.....) - // [xopt,fopt,exitflag,gradient,hessian]=intfmincon(.....) + // Solves a constrainted multi-variable mixed integer non linear programming problem + // + // Calling Sequence + // xopt = intfmincon(f,x0,intcon,A,b) + // xopt = intfmincon(f,x0,intcon,A,b,Aeq,beq) + // xopt = intfmincon(f,x0,intcon,A,b,Aeq,beq,lb,ub) + // xopt = intfmincon(f,x0,intcon,A,b,Aeq,beq,lb,ub,nlc) + // xopt = intfmincon(f,x0,intcon,A,b,Aeq,beq,lb,ub,nlc,options) + // [xopt,fopt] = intfmincon(.....) + // [xopt,fopt,exitflag]= intfmincon(.....) + // [xopt,fopt,exitflag,gradient]=intfmincon(.....) + // [xopt,fopt,exitflag,gradient,hessian]=intfmincon(.....) // // Parameters // f : a function, representing the objective function of the problem - // x0 : a vector of doubles, containing the starting values of variables. - // intcon : a vector of integers, represents which variables are constrained to be integers - // A : a matrix of double, represents the linear coefficients in the inequality constraints A⋅x ≤ b. - // b : a vector of double, represents the linear coefficients in the inequality constraints A⋅x ≤ b. - // Aeq : a matrix of double, represents the linear coefficients in the equality constraints Aeq⋅x = beq. - // beq : a vector of double, represents the linear coefficients in the equality constraints Aeq⋅x = beq. - // lb : Lower bounds, specified as a vector or array of double. lb represents the lower bounds elementwise in lb ≤ x ≤ ub. - // ub : Upper bounds, specified as a vector or array of double. ub represents the upper bounds elementwise in lb ≤ x ≤ ub. - // nlc : a function, representing the Non-linear Constraints functions(both Equality and Inequality) of the problem. It is declared in such a way that non-linear inequality constraints are defined first as a single row vector (c), followed by non-linear equality constraints as another single row vector (ceq). Refer Example for definition of Constraint function. - // options : a list, containing the option for user to specify. See below for details. - // xopt : a vector of doubles, containing the the computed solution of the optimization problem. - // fopt : a scalar of double, containing the the function value at x. - // exitflag : a scalar of integer, containing the flag which denotes the reason for termination of algorithm. See below for details. - // gradient : a vector of doubles, containing the Objective's gradient of the solution. - // hessian : a matrix of doubles, containing the Objective's hessian of the solution. - // - // Description - // Search the minimum of a multi-variable function on bounded interval specified by : - // Find the minimum of f(x) such that + // x0 : a vector of doubles, containing the starting values of variables. + // intcon : a vector of integers, represents which variables are constrained to be integers + // A : a matrix of double, represents the linear coefficients in the inequality constraints A⋅x ≤ b. + // b : a vector of double, represents the linear coefficients in the inequality constraints A⋅x ≤ b. + // Aeq : a matrix of double, represents the linear coefficients in the equality constraints Aeq⋅x = beq. + // beq : a vector of double, represents the linear coefficients in the equality constraints Aeq⋅x = beq. + // lb : Lower bounds, specified as a vector or array of double. lb represents the lower bounds elementwise in lb ≤ x ≤ ub. + // ub : Upper bounds, specified as a vector or array of double. ub represents the upper bounds elementwise in lb ≤ x ≤ ub. + // nlc : a function, representing the Non-linear Constraints functions(both Equality and Inequality) of the problem. It is declared in such a way that non-linear inequality constraints are defined first as a single row vector (c), followed by non-linear equality constraints as another single row vector (ceq). Refer Example for definition of Constraint function. + // options : a list, containing the option for user to specify. See below for details. + // xopt : a vector of doubles, containing the the computed solution of the optimization problem. + // fopt : a scalar of double, containing the the function value at x. + // exitflag : a scalar of integer, containing the flag which denotes the reason for termination of algorithm. See below for details. + // gradient : a vector of doubles, containing the Objective's gradient of the solution. + // hessian : a matrix of doubles, containing the Objective's hessian of the solution. // - // <latex> - // \begin{eqnarray} - // &\mbox{min}_{x} - // & f(x)\\ - // & \text{subject to} & x1 \ < x \ < x2 \\ - // \end{eqnarray} - // </latex> + // Description + // Search the minimum of a mixed integer constrained optimization problem specified by : + // Find the minimum of f(x) such that + // + // <latex> + // \begin{eqnarray} + // &\mbox{min}_{x} + // & f(x) \\ + // & \text{subject to} & A*x \leq b \\ + // & & Aeq*x \ = beq\\ + // & & c(x) \leq 0\\ + // & & ceq(x) \ = 0\\ + // & & lb \leq x \leq ub \\ + // & & x_i \in \!\, \mathbb{Z}, i \in \!\, I + // \end{eqnarray} + // </latex> // // The routine calls Bonmin for solving the Bounded Optimization problem, Bonmin is a library written in C++. // @@ -72,65 +77,146 @@ function [xopt,fopt,exitflag,gradient,hessian] = intfmincon (varargin) // The exitflag allows to know the status of the optimization which is given back by Ipopt. // <itemizedlist> // <listitem>exitflag=0 : Optimal Solution Found </listitem> - // <listitem>exitflag=1 : Maximum Number of Iterations Exceeded. Output may not be optimal.</listitem> - // <listitem>exitflag=2 : Maximum CPU Time exceeded. Output may not be optimal.</listitem> - // <listitem>exitflag=3 : Stop at Tiny Step.</listitem> - // <listitem>exitflag=4 : Solved To Acceptable Level.</listitem> - // <listitem>exitflag=5 : Converged to a point of local infeasibility.</listitem> + // <listitem>exitflag=1 : InFeasible Solution.</listitem> + // <listitem>exitflag=2 : Objective Function is Continuous Unbounded.</listitem> + // <listitem>exitflag=3 : Limit Exceeded.</listitem> + // <listitem>exitflag=4 : User Interrupt.</listitem> + // <listitem>exitflag=5 : MINLP Error.</listitem> // </itemizedlist> // // For more details on exitflag see the Bonmin documentation, go to http://www.coin-or.org/Bonmin - // - // Examples - // //Find x in R^6 such that it minimizes: - // //f(x)= sin(x1) + sin(x2) + sin(x3) + sin(x4) + sin(x5) + sin(x6) - // //-2 <= x1,x2,x3,x4,x5,x6 <= 2 - // //Objective function to be minimised - // function y=f(x) - // y=0 - // for i =1:6 - // y=y+sin(x(i)); - // end - // endfunction - // //Variable bounds - // x1 = [-2, -2, -2, -2, -2, -2]; - // x2 = [2, 2, 2, 2, 2, 2]; - // intcon = [2 3 4] - // //Options - // options=list("MaxIter",[1500],"CpuTime", [100]) - // [x,fval] =intfmincon(f ,intcon, x1, x2, options) - // // Press ENTER to continue - // - // Examples - // //Find x in R such that it minimizes: - // //f(x)= 1/x^2 - // //0 <= x <= 1000 - // //Objective function to be minimised - // function y=f(x) - // y=1/x^2; - // endfunction - // //Variable bounds - // x1 = [0]; - // x2 = [1000]; - // intcon = [1]; - // [x,fval,exitflag,output,lambda] =intfmincon(f,intcon , x1, x2) - // // Press ENTER to continue - // - // Examples - // //The below problem is an unbounded problem: - // //Find x in R^2 such that it minimizes: - // //f(x)= -[(x1-1)^2 + (x2-1)^2] - // //-inf <= x1,x2 <= inf - // //Objective function to be minimised - // function y=f(x) - // y=-((x(1)-1)^2+(x(2)-1)^2); - // endfunction - // //Variable bounds - // x1 = [-%inf , -%inf]; - // x2 = [ %inf , %inf]; - // //Options - // options=list("MaxIter",[1500],"CpuTime", [100]) - // [x,fval,exitflag,output,lambda] =intfmincon(f,intcon, x1, x2, options) + // + // Examples + // //Find x in R^2 such that it minimizes: + // //f(x)= -x1 -x2/3 + // //x0=[0,0] + // //constraint-1 (c1): x1 + x2 <= 2 + // //constraint-2 (c2): x1 + x2/4 <= 1 + // //constraint-3 (c3): x1 - x2 <= 2 + // //constraint-4 (c4): -x1/4 - x2 <= 1 + // //constraint-5 (c5): -x1 - x2 <= -1 + // //constraint-6 (c6): -x1 + x2 <= 2 + // //constraint-7 (c7): x1 + x2 = 2 + // //Objective function to be minimised + // function [y,dy]=f(x) + // y=-x(1)-x(2)/3; + // dy= [-1,-1/3]; + // endfunction + // //Starting point, linear constraints and variable bounds + // x0=[0 , 0]; + // intcon = [1] + // A=[1,1 ; 1,1/4 ; 1,-1 ; -1/4,-1 ; -1,-1 ; -1,1]; + // b=[2;1;2;1;-1;2]; + // Aeq=[1,1]; + // beq=[2]; + // lb=[]; + // ub=[]; + // nlc=[]; + // //Options + // options=list("GradObj", "on"); + // //Calling Ipopt + // [x,fval,exitflag,grad,hessian] =intfmincon(f, x0,intcon,A,b,Aeq,beq,lb,ub,nlc,options) + // // Press ENTER to continue + // + // Examples + // //Find x in R^3 such that it minimizes: + // //f(x)= x1*x2 + x2*x3 + // //x0=[0.1 , 0.1 , 0.1] + // //constraint-1 (c1): x1^2 - x2^2 + x3^2 <= 2 + // //constraint-2 (c2): x1^2 + x2^2 + x3^2 <= 10 + // //Objective function to be minimised + // function [y,dy]=f(x) + // y=x(1)*x(2)+x(2)*x(3); + // dy= [x(2),x(1)+x(3),x(2)]; + // endfunction + // //Starting point, linear constraints and variable bounds + // x0=[0.1 , 0.1 , 0.1]; + // intcon = [2] + // A=[]; + // b=[]; + // Aeq=[]; + // beq=[]; + // lb=[]; + // ub=[]; + // //Nonlinear constraints + // function [c,ceq,cg,cgeq]=nlc(x) + // c = [x(1)^2 - x(2)^2 + x(3)^2 - 2 , x(1)^2 + x(2)^2 + x(3)^2 - 10]; + // ceq = []; + // cg=[2*x(1) , -2*x(2) , 2*x(3) ; 2*x(1) , 2*x(2) , 2*x(3)]; + // cgeq=[]; + // endfunction + // //Options + // options=list("MaxIter", [1500], "CpuTime", [500], "GradObj", "on","GradCon", "on"); + // //Calling Ipopt + // [x,fval,exitflag,output] =intfmincon(f, x0,intcon,A,b,Aeq,beq,lb,ub,nlc,options) + // // Press ENTER to continue + // + // Examples + // //The below problem is an unbounded problem: + // //Find x in R^3 such that it minimizes: + // //f(x)= -(x1^2 + x2^2 + x3^2) + // //x0=[0.1 , 0.1 , 0.1] + // // x1 <= 0 + // // x2 <= 0 + // // x3 <= 0 + // //Objective function to be minimised + // function y=f(x) + // y=-(x(1)^2+x(2)^2+x(3)^2); + // endfunction + // //Starting point, linear constraints and variable bounds + // x0=[0.1 , 0.1 , 0.1]; + // intcon = [3] + // A=[]; + // b=[]; + // Aeq=[]; + // beq=[]; + // lb=[]; + // ub=[0,0,0]; + // //Options + // options=list("MaxIter", [1500], "CpuTime", [500]); + // //Calling Ipopt + // [x,fval,exitflag,grad,hessian] =intfmincon(f, x0,intcon,A,b,Aeq,beq,lb,ub,[],options) + // // Press ENTER to continue + // + // Examples + // //The below problem is an infeasible problem: + // //Find x in R^3 such that in minimizes: + // //f(x)=x1*x2 + x2*x3 + // //x0=[1,1,1] + // //constraint-1 (c1): x1^2 <= 1 + // //constraint-2 (c2): x1^2 + x2^2 <= 1 + // //constraint-3 (c3): x3^2 <= 1 + // //constraint-4 (c4): x1^3 = 0.5 + // //constraint-5 (c5): x2^2 + x3^2 = 0.75 + // // 0 <= x1 <=0.6 + // // 0.2 <= x2 <= inf + // // -inf <= x3 <= 1 + // //Objective function to be minimised + // function [y,dy]=f(x) + // y=x(1)*x(2)+x(2)*x(3); + // dy= [x(2),x(1)+x(3),x(2)]; + // endfunction + // //Starting point, linear constraints and variable bounds + // x0=[1,1,1]; + // intcon = [2] + // A=[]; + // b=[]; + // Aeq=[]; + // beq=[]; + // lb=[0 0.2,-%inf]; + // ub=[0.6 %inf,1]; + // //Nonlinear constraints + // function [c,ceq,cg,cgeq]=nlc(x) + // c=[x(1)^2-1,x(1)^2+x(2)^2-1,x(3)^2-1]; + // ceq=[x(1)^3-0.5,x(2)^2+x(3)^2-0.75]; + // cg = [2*x(1),0,0;2*x(1),2*x(2),0;0,0,2*x(3)]; + // cgeq = [3*x(1)^2,0,0;0,2*x(2),2*x(3)]; + // endfunction + // //Options + // options=list("MaxIter", [1500], "CpuTime", [500], "GradObj", "on","GradCon", "on"); + // //Calling Ipopt + // [x,fval,exitflag,grad,hessian] =intfmincon(f, x0,intcon,A,b,Aeq,beq,lb,ub,nlc,options) + // // Press ENTER to continue // Authors // Harpreet Singh @@ -146,14 +232,14 @@ function [xopt,fopt,exitflag,gradient,hessian] = intfmincon (varargin) //Storing the Input Parameters fun = varargin(1); x0 = varargin(2); - intcon = varargin(3); - A = varargin(4); - b = varargin(5); - Aeq = []; - beq = []; - lb = []; - ub = []; - nlc = []; + intcon = varargin(3); + A = varargin(4); + b = varargin(5); + Aeq = []; + beq = []; + lb = []; + ub = []; + nlc = []; if (rhs>5) then Aeq = varargin(6); @@ -282,9 +368,9 @@ options = list('integertolerance',1d-06,'maxnodes',2147483647,'cputime',1d10,'al options(10) = param(2*i); case 'gradobj' then Checktype("intfmincon_options", param(2*i), param(2*i-1), 2*i, "string"); - if(convstr(options(2*i),'l') == "on") then + if(convstr(param(2*i),'l') == "on") then options(12) = "on" - elseif(convstr(options(2*i),'l') == "off") then + elseif(convstr(param(2*i),'l') == "off") then options(12) = "off" else error(999, 'Unknown string passed in gradobj.'); @@ -292,11 +378,11 @@ options = list('integertolerance',1d-06,'maxnodes',2147483647,'cputime',1d10,'al case 'hessian' then Checktype("intfmincon_options", param(2*i), param(2*i-1), 2*i, "function"); options(14) = param(2*i); - case 'GradCon' then + case 'gradcon' then Checktype("intfmincon_options", param(2*i), param(2*i-1), 2*i, "string"); - if(convstr(options(2*i),'l') == "on") then + if(convstr(param(2*i),'l') == "on") then options(16) = "on" - elseif(convstr(options(2*i),'l') == "off") then + elseif(convstr(param(2*i),'l') == "off") then options(16) = "off" else error(999, 'Unknown string passed in gradcon.'); @@ -315,19 +401,20 @@ options = list('integertolerance',1d-06,'maxnodes',2147483647,'cputime',1d10,'al end if(options(12) == "on") then - if(execstr('[grad_y,grad_dy]=fun(x1)','errcatch')==59) then + if(execstr('[grad_y,grad_dy]=fun(x0)','errcatch')==59) then errmsg = msprintf(gettext("%s: Gradient of objective function is not provided"), "intfmincon"); error(errmsg); end + if(grad_dy<>[]) then Checkvector("intfmincon_options", grad_dy, "dy", 12, nbVar); + end end if(options(14) == "on") then - if(execstr('[hessian_y,hessian_dy,hessian]=fun(x1)','errcatch')==59) then + if(execstr('[hessian_y,hessian_dy,hessian]=fun(x0)','errcatch')==59) then errmsg = msprintf(gettext("%s: Gradient of objective function is not provided"), "intfmincon"); error(errmsg); end - if ( ~isequal(size(hessian) == [nbVar nbVar]) ) then errmsg = msprintf(gettext("%s: Size of hessian should be nbVar X nbVar"), "intfmincon"); error(errmsg); @@ -338,7 +425,8 @@ options = list('integertolerance',1d-06,'maxnodes',2147483647,'cputime',1d10,'al numNlec = 0; numNlc = 0; - if (type(nlc) == 13 | type(nlc) == 11) then + if (type(nlc) == 13 | type(nlc) == 11) then + [sample_c,sample_ceq] = nlc(x0); if(execstr('[sample_c,sample_ceq] = nlc(x0)','errcatch')==21) then errmsg = msprintf(gettext("%s: Non-Linear Constraint function and x0 did not match"), intfmincon); error(errmsg); @@ -387,6 +475,8 @@ options = list('integertolerance',1d-06,'maxnodes',2147483647,'cputime',1d10,'al function [y,check] = _addnlc(x) x= x(:) + c = [] + ceq = [] try if((type(nlc) == 13 | type(nlc) == 11) & numNlc~=0) then [c,ceq]=nlc(x) @@ -404,7 +494,10 @@ options = list('integertolerance',1d-06,'maxnodes',2147483647,'cputime',1d10,'al function [dy,check] = _gradnlc(x) if (options(16) =="on") then try - [y,dy]=nlc(x) + [y1,y2,dy1,dy2]=nlc(x) + //Adding derivative of Linear Constraint + dylin = [A;Aeq] + dy = [dy1;dy2;dylin]; [dy,check] = checkIsreal(dy) catch dy = 0; diff --git a/build/Scilab/intfminimax.sci b/build/Scilab/intfminimax.sci new file mode 100644 index 0000000..2b51fd5 --- /dev/null +++ b/build/Scilab/intfminimax.sci @@ -0,0 +1,454 @@ +// Copyright (C) 2015 - IIT Bombay - FOSSEE +// +// This file must be used under the terms of the CeCILL. +// This source file is licensed as described in the file COPYING, which +// you should have received as part of this distribution. The terms +// are also available at +// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt +// Authors: Animesh Baranawal +// Organization: FOSSEE, IIT Bombay +// Email: toolbox@scilab.in + +function [x,fval,maxfval,exitflag,output,lambda] = intfminimax(varargin) + // Solves minimax constraint problem + // + // Calling Sequence + // xopt = intfminimax(fun,x0,intcon) + // xopt = intfminimax(fun,x0,intcon,A,b) + // xopt = intfminimax(fun,x0,intcon,A,b,Aeq,beq) + // xopt = intfminimax(fun,x0,intcon,A,b,Aeq,beq,lb,ub) + // xopt = intfminimax(fun,x0,intcon,A,b,Aeq,beq,lb,ub,nonlinfun) + // xopt = intfminimax(fun,x0,intcon,A,b,Aeq,beq,lb,ub,nonlinfun,options) + // [xopt, fval] = intfminimax(.....) + // [xopt, fval, maxfval]= intfminimax(.....) + // [xopt, fval, maxfval, exitflag]= intfminimax(.....) + // [xopt, fval, maxfval, exitflag, output]= intfminimax(.....) + // [xopt, fval, maxfval, exitflag, output, lambda]= intfminimax(.....) + // + // Parameters + // fun: The function to be minimized. fun is a function that accepts a vector x and returns a vector F, the objective functions evaluated at x. + // x0 : a vector of double, contains initial guess of variables. + // A : a matrix of double, represents the linear coefficients in the inequality constraints A⋅x ≤ b. + // intcon : a vector of integers, represents which variables are constrained to be integers + // b : a vector of double, represents the linear coefficients in the inequality constraints A⋅x ≤ b. + // Aeq : a matrix of double, represents the linear coefficients in the equality constraints Aeq⋅x = beq. + // beq : a vector of double, represents the linear coefficients in the equality constraints Aeq⋅x = beq. + // lb : a vector of double, contains lower bounds of the variables. + // ub : a vector of double, contains upper bounds of the variables. + // nonlinfun: function that computes the nonlinear inequality constraints c⋅x ≤ 0 and nonlinear equality constraints c⋅x = 0. + // xopt : a vector of double, the computed solution of the optimization problem. + // fopt : a double, the value of the function at x. + // maxfval: a 1x1 matrix of doubles, the maximum value in vector fval + // exitflag : The exit status. See below for details. + // output : The structure consist of statistics about the optimization. See below for details. + // lambda : The structure consist of the Lagrange multipliers at the solution of problem. See below for details. + // + // Description + // intfminimax minimizes the worst-case (largest) value of a set of multivariable functions, starting at an initial estimate. This is generally referred to as the minimax problem. + // + // <latex> + // \min_{x} \max_{i} F_{i}(x)\: \textrm{such that} \:\begin{cases} + // & c(x) \leq 0 \\ + // & ceq(x) = 0 \\ + // & A.x \leq b \\ + // & Aeq.x = beq \\ + // & lb \leq x \leq ub + // & x_i \in \!\, \mathbb{Z}, i \in \!\, I + // \end{cases} + // </latex> + // + // Currently, intfminimax calls intfmincon which uses the bonmin algorithm. + // + // max-min problems can also be solved with intfminimax, using the identity + // + // <latex> + // \max_{x} \min_{i} F_{i}(x) = -\min_{x} \max_{i} \left( -F_{i}(x) \right) + // </latex> + // + // The options allows the user to set various parameters of the Optimization problem. + // It should be defined as type "list" and contains the following fields. + // <itemizedlist> + // <listitem>Syntax : options= list("IntegerTolerance", [---], "MaxNodes",[---], "MaxIter", [---], "AllowableGap",[---] "CpuTime", [---],"gradobj", "off", "hessian", "off" );</listitem> + // <listitem>IntegerTolerance : a Scalar, a number with that value of an integer is considered integer..</listitem> + // <listitem>MaxNodes : a Scalar, containing the Maximum Number of Nodes that the solver should search.</listitem> + // <listitem>CpuTime : a Scalar, containing the Maximum amount of CPU Time that the solver should take.</listitem> + // <listitem>AllowableGap : a Scalar, to stop the tree search when the gap between the objective value of the best known solution is reached.</listitem> + // <listitem>MaxIter : a Scalar, containing the Maximum Number of Iteration that the solver should take.</listitem> + // <listitem>gradobj : a string, to turn on or off the user supplied objective gradient.</listitem> + // <listitem>hessian : a Scalar, to turn on or off the user supplied objective hessian.</listitem> + // <listitem>Default Values : options = list('integertolerance',1d-06,'maxnodes',2147483647,'cputime',1d10,'allowablegap',0,'maxiter',2147483647,'gradobj',"off",'hessian',"off")</listitem> + // + // The objective function must have header : + // <programlisting> + // F = fun(x) + // </programlisting> + // where x is a n x 1 matrix of doubles and F is a m x 1 matrix of doubles where m is the total number of objective functions inside F. + // On input, the variable x contains the current point and, on output, the variable F must contain the objective function values. + // + // By default, the gradient options for intfminimax are turned off and and intfmincon does the gradient opproximation of objective function. In case the GradObj option is off and GradConstr option is on, intfminimax approximates Objective function gradient using numderivative toolbox. + // + // If we can provide exact gradients, we should do so since it improves the convergence speed of the optimization algorithm. + // + // </itemizedlist> + // + // The exitflag allows to know the status of the optimization which is given back by Ipopt. + // <itemizedlist> + // <listitem>exitflag=0 : Optimal Solution Found </listitem> + // <listitem>exitflag=1 : InFeasible Solution.</listitem> + // <listitem>exitflag=2 : Objective Function is Continuous Unbounded.</listitem> + // <listitem>exitflag=3 : Limit Exceeded.</listitem> + // <listitem>exitflag=4 : User Interrupt.</listitem> + // <listitem>exitflag=5 : MINLP Error.</listitem> + // </itemizedlist> + // + // For more details on exitflag see the ipopt documentation, go to http://www.coin-or.org/bonmin/ + // + // Examples + // // A basic case : + // // we provide only the objective function and the nonlinear constraint + // // function + // function f = myfun(x) + // f(1)= 2*x(1)^2 + x(2)^2 - 48*x(1) - 40*x(2) + 304; //Objectives + // f(2)= -x(1)^2 - 3*x(2)^2; + // f(3)= x(1) + 3*x(2) -18; + // f(4)= -x(1) - x(2); + // f(5)= x(1) + x(2) - 8; + // endfunction + // // The initial guess + // x0 = [0.1,0.1]; + // // The expected solution : only 4 digits are guaranteed + // xopt = [4 4] + // fopt = [0 -64 -2 -8 0] + // intcon = [1] + // maxfopt = 0 + // // Run fminimax + // [x,fval,maxfval,exitflag,output,lambda] = fminimax(myfun, x0,intcon) + // // Press ENTER to continue + // + // Examples + // // A case where we provide the gradient of the objective + // // functions and the Jacobian matrix of the constraints. + // // The objective function and its gradient + // function [f,G] = myfun(x) + // f(1)= 2*x(1)^2 + x(2)^2 - 48*x(1) - 40*x(2) + 304; + // f(2)= -x(1)^2 - 3*x(2)^2; + // f(3)= x(1) + 3*x(2) -18; + // f(4)= -x(1) - x(2); + // f(5)= x(1) + x(2) - 8; + // G = [ 4*x(1) - 48, -2*x(1), 1, -1, 1; + // 2*x(2) - 40, -6*x(2), 3, -1, 1; ]' + // endfunction + // // The nonlinear constraints + // function [c,ceq,DC,DCeq] = confun(x) + // // Inequality constraints + // c = [1.5 + x(1)*x(2) - x(1) - x(2), -x(1)*x(2) - 10] + // // No nonlinear equality constraints + // ceq=[] + // DC= [x(2)-1, -x(2); + // x(1)-1, -x(1)]' + // DCeq = []' + // endfunction + // // Test with both gradient of objective and gradient of constraints + // minimaxOptions = list("GradObj","on","GradCon","on"); + // // The initial guess + // x0 = [0,10]; + // intcon = [2] + // // Run intfminimax + // [x,fval,maxfval,exitflag,output] = intfminimax(myfun,x0,intcon,[],[],[],[],[],[], confun, minimaxOptions) + // + // Authors + // Harpreet Singh + + // Check number of input and output arguments + [minmaxLhs,minmaxRhs] = argn() + Checkrhs("fminimax", minmaxRhs, [2 3 5 7 9 10 11]) + Checklhs("fminimax", minmaxLhs, 1:7) + + // Proper initialisation of objective function + minmaxObjfun = varargin(1) + Checktype("fminimax", minmaxObjfun, "minmaxObjfun", 1, "function") + + // Proper initialisation of starting point + minmaxStartpoint = varargin(2) + Checktype("fminimax", minmaxStartpoint, "minmaxStartpoint", 2, "constant") + + minmaxNumvar = size(minmaxStartpoint,"*") + Checkvector("fminimax", minmaxStartpoint, "minmaxStartpoint", 2, minmaxNumvar) + minmaxStartpoint = minmaxStartpoint(:) + + if(minmaxRhs < 3) then // if A and b are not provided, declare as empty + intcon = 0; + else + intcon = varargin(3); + end + + // Proper initialisation of A and b + if(minmaxRhs < 4) then // if A and b are not provided, declare as empty + minmaxA = [] + minmaxB = [] + else + minmaxA = varargin(4) + minmaxB = varargin(5) + end + + Checktype("fminimax", minmaxA, "A", 4, "constant") + Checktype("fminimax", minmaxB, "b", 5, "constant") + + // Check if A and b of proper dimensions + if(minmaxA <> [] & minmaxB == []) then + errmsg = msprintf(gettext("%s: Incompatible input arguments #%d and #%d: matrix A is empty, but the column vector b is not empty"), "fminimax", 4, 5) + error(errmsg) + end + + if(minmaxA == [] & minmaxB <> []) then + errmsg = msprintf(gettext("%s: Incompatible input arguments #%d and #%d: matrix A is not empty, but the column vector b is empty"), "fminimax", 4, 5) + error(errmsg) + end + + minmaxNumrowA = size(minmaxA,"r") + if(minmaxA <> []) then + Checkdims("fminimax", minmaxA, "A", 4, [minmaxNumrowA minmaxNumvar]) + Checkvector("fminimax", minmaxB, "b", 5, minmaxNumrowA) + minmaxB = minmaxB(:) + end + + // Proper initialisation of Aeq and beq + if(minmaxRhs < 6) then // if Aeq and beq are not provided, declare as empty + minmaxAeq = [] + minmaxBeq = [] + else + minmaxAeq = varargin(6) + minmaxBeq = varargin(7) + end + + Checktype("fminimax", minmaxAeq, "Aeq", 6, "constant") + Checktype("fminimax", minmaxBeq, "beq", 7, "constant") + + // Check if Aeq and beq of proper dimensions + if(minmaxAeq <> [] & minmaxBeq == []) then + errmsg = msprintf(gettext("%s: Incompatible input arguments #%d and #%d: matrix Aeq is empty, but the column vector beq is not empty"), "fminimax", 6, 7) + error(errmsg) + end + + if(minmaxAeq == [] & minmaxBeq <> []) then + errmsg = msprintf(gettext("%s: Incompatible input arguments #%d and #%d: matrix Aeq is not empty, but the column vector beq is empty"), "fminimax", 6, 7) + error(errmsg) + end + + minmaxNumrowAeq = size(minmaxAeq,"r") + if(minmaxAeq <> []) then + Checkdims("fminimax", minmaxAeq, "Aeq", 6, [minmaxNumrowAeq minmaxNumvar]) + Checkvector("fminimax", minmaxBeq, "beq", 7, minmaxNumrowAeq) + minmaxBeq = minmaxBeq(:) + end + + // Proper initialisation of minmaxLb and minmaxUb + if(minmaxRhs < 6) then // if minmaxLb and minmaxUb are not provided, declare as empty + minmaxLb = [] + minmaxUb = [] + else + minmaxLb = varargin(6) + minmaxUb = varargin(7) + end + + Checktype("fminimax", minmaxLb, "lb", 6, "constant") + Checktype("fminimax", minmaxUb, "ub", 7, "constant") + + // Check dimensions of minmaxLb and minmaxUb + if(minmaxLb <> []) then + Checkvector("fminimax", minmaxLb, "lb", 8, minmaxNumvar) + minmaxLb = minmaxLb(:) + end + + if(minmaxUb <> []) then + Checkvector("fminimax", minmaxUb, "ub", 9, minmaxNumvar) + minmaxUb = minmaxUb(:) + end + + // Proper Initialisation of minmaxNonlinfun + if(minmaxRhs < 10) then // if minmaxNonlinfun is not provided, declare as empty + minmaxNonlinfun = [] + else + minmaxNonlinfun = varargin(10) + end + + Checktype("fminimax", minmaxNonlinfun, "nonlinfun", 10, "function") + + //To check, Whether minimaxOptions is been entered by user + if ( minmaxRhs<11 ) then + minmaxUserOptions = list(); + else + minmaxUserOptions = varargin(11); //Storing the 3rd Input minmaxUserOptionseter in intermediate list named 'minmaxUserOptions' + end + + //If minimaxOptions is entered then checking its type for 'list' + if (type(minmaxUserOptions) ~= 15) then + errmsg = msprintf(gettext("%s: minimaxOptions (10th parameter) should be a list"), "fminimax"); + error(errmsg); + end + + //If minimaxOptions is entered then checking whether even number of entires are entered + if (modulo(size(minmaxUserOptions),2)) then + errmsg = msprintf(gettext("%s: Size of minimaxOptions (list) should be even"), "fminimax"); + error(errmsg); + end + + /////////////// To check integer ////////////////////// + for i=1:size(intcon,1) + if(intcon(i)>minmaxNumvar) then + errmsg = msprintf(gettext("%s: The values inside intcon should be less than the number of variables"), "intfminimax"); + error(errmsg); + end + + if (intcon(i)<0) then + errmsg = msprintf(gettext("%s: The values inside intcon should be greater than 0 "), "intfminimax"); + error(errmsg); + end + + if(modulo(intcon(i),1)) then + errmsg = msprintf(gettext("%s: The values inside intcon should be an integer "), "intfminimax"); + error(errmsg); + end + end + + //If minimaxOptions is entered then checking its type for 'list' + if (type(minmaxUserOptions) ~= 15) then + errmsg = msprintf(gettext("%s: minimaxOptions (10th parameter) should be a list"), "intfminimax"); + error(errmsg); + end + + //If minimaxOptions is entered then checking whether even number of entires are entered + if (modulo(size(minmaxUserOptions),2)) then + errmsg = msprintf(gettext("%s: Size of minimaxOptions (list) should be even"), "intfminimax"); + error(errmsg); + end + +minmaxoptions = list('integertolerance',1d-06,'maxnodes',2147483647,'cputime',1d10,'allowablegap',0,'maxiter',2147483647,'gradobj',"off",'gradcon',"off") + + //Pushing minmaxUserOptions into default value + + for i = 1:(size(minmaxUserOptions))/2 + select convstr(minmaxUserOptions(2*i-1),'l') + case 'integertolerance' then + Checktype("intfminimax_options", minmaxUserOptions(2*i), minmaxUserOptions(2*i-1), 2*i, "constant"); + minmaxoptions(2) = minmaxUserOptions(2*i); + case 'maxnodes' then + Checktype("intfminimax_options", minmaxUserOptions(2*i), minmaxUserOptions(2*i-1), 2*i, "constant"); + minmaxoptions(4) = minmaxUserOptions(2*i); + case 'cputime' then + Checktype("intfminimax_options", minmaxUserOptions(2*i), minmaxUserOptions(2*i-1), 2*i, "constant"); + minmaxoptions(6) = minmaxUserOptions(2*i); + case 'allowablegap' then + Checktype("intfminimax_options", minmaxUserOptions(2*i), minmaxUserOptions(2*i-1), 2*i, "constant"); + minmaxoptions(8) = minmaxUserOptions(2*i); + case 'maxiter' then + Checktype("intfminimax_options", minmaxUserOptions(2*i), minmaxUserOptions(2*i-1), 2*i, "constant"); + minmaxoptions(10) = minmaxUserOptions(2*i); + case 'gradobj' then + Checktype("intfminimax_options", minmaxUserOptions(2*i), minmaxUserOptions(2*i-1), 2*i, "string"); + if(convstr(minmaxUserOptions(2*i),'l') == "on") then + minmaxoptions(12) = "on" + elseif(convstr(minmaxUserOptions(2*i),'l') == "off") then + minmaxoptions(12) = "off" + else + error(999, 'Unknown string passed in gradobj.'); + end + case 'gradcon' then + Checktype("intfminimax_options", minmaxUserOptions(2*i), minmaxUserOptions(2*i-1), 2*i, "string"); + if(convstr(minmaxUserOptions(2*i),'l') == "on") then + minmaxoptions(14) = "on" + elseif(convstr(minmaxUserOptions(2*i),'l') == "off") then + minmaxoptions(14) = "off" + else + error(999, 'Unknown string passed in gradcon.'); + end + else + error(999, 'Unknown string argument passed.'); + end + end + + // Reformulating the problem fminimax to fmincon + minmaxObjfunval = minmaxObjfun(minmaxStartpoint) + minmaxStartpoint(minmaxNumvar+1) = max(minmaxObjfunval) + + if(minmaxA <> []) then + minmaxA = [minmaxA, zeros(minmaxNumrowA,1)] + end + if(minmaxAeq <> []) then + minmaxAeq = [minmaxAeq, zeros(minmaxNumrowAeq,1)] + end + if(minmaxLb <> []) then + minmaxLb(minmaxNumvar+1) = -%inf + end + if(minmaxUb <> []) then + minmaxUb(minmaxNumvar+1) = +%inf + end + + // function handle defining the additional inequalities + function temp = minmaxAddIneq(z) + temp = minmaxObjfun(z) - z(minmaxNumvar+1) + endfunction + + // function handle defining minmaxNonlinfun derivative using numderivative + function [dc,dceq] = minmaxNonlinDer(z) + // function handle extracting c and ceq components from minmaxNonlinfun + function foo = minmaxC(z) + [foo,tmp1] = minmaxNonlinfun(z) + foo = foo' + endfunction + + function foo = minmaxCEQ(z) + [tmp1,foo] = minmaxNonlinfun(z) + foo = foo' + endfunction + + dc = numderivative(minmaxC,z) + dceq = numderivative(minmaxCEQ,z) + endfunction + + // function handle defining new objective function + function newfunc = newObjfun(z) + newfunc = z(minmaxNumvar+1) + endfunction + + // function handle defining new minmaxNonlinfun function + function [nc,nceq,dnc,dnceq] = newNonlinfun(z) + dnc = []; + dnceq = []; + [nc,nceq] = minmaxNonlinfun(z) + // add inequalities of the form Fi(x) - y <= 0 + tmp = [minmaxObjfun(z) - z(minmaxNumvar+1)]' + nc = [nc, tmp] + if(options(14) =="on") then + [temp1,temp2,dnc, dnceq] = minmaxNonlinfun(z) + dnc = [dnc, zeros(size(dnc,'r'),1)] + dnceq = [dnceq, zeros(size(dnceq,'r'),1)] + else + // else use numderivative method to calculate gradient of constraints + [dnc, dnceq] = minmaxNonlinDer(z) + end + + if(options(12) =="on") then + [temp,derObjfun] = minmaxObjfun(z); + mderObjfun = [derObjfun, -1*ones(size(derObjfun,'r'),1)]; + dnc = [dnc; mderObjfun]; + else + // else use numderivative to calculate gradient of set of obj functions + derObjfun = numderivative(minmaxAddIneq,z) + dnc = [dnc; derObjfun] + end + endfunction + + if( minmaxoptions(12)=="on"| minmaxoptions(12)="on") then + options(14)="on"; + end + + options(12)="off"; + + [x,fval,exitflag,gradient,hessian] = ... + intfmincon(newObjfun,minmaxStartpoint,intcon,minmaxA,minmaxB,minmaxAeq,minmaxBeq,minmaxLb,minmaxUb,newNonlinfun,minmaxoptions) + + x = x(1:minmaxNumvar) + fval = minmaxObjun(x) + maxfval = max(fval) +endfunction |