- sym_addConstr — Add a new constraint diff --git a/help/en_US/scilab_en_US_help/index.html~ b/help/en_US/scilab_en_US_help/index.html~ new file mode 100644 index 0000000..3aaf941 --- /dev/null +++ b/help/en_US/scilab_en_US_help/index.html~ @@ -0,0 +1,283 @@ + + +
- Symphony Toolbox
+
- sym_addConstr — Add a new constraint + + + +
- sym_addVar — Add a new variable + + + +
- sym_close — Close the Symphony environment + + + +
- sym_deleteConstrs — This routine is used to delete rows from the original constraint matrix. + + + +
- sym_deleteVars — This routine is used to delete columns from the original problem description. + + + +
- sym_getConstrActivity — Get the activity of the constraints in the solution + + + +
- sym_getConstrLower — To get the lower bounds of the constraints. + + + +
- sym_getConstrRange — To to get the constraint ranges. + + + +
- sym_getConstrSense — To get the row senses. + + + +
- sym_getConstrUpper — To get the upper bounds of the constraints. + + + +
- sym_getDblParam — This routine is used to get the value of a double type parameter. + + + +
- sym_getInfinity — Get Symphony's infinity value + + + +
- sym_getIntParam — This routine is used to get the value of an integer type parameter. + + + +
- sym_getIterCount — To get the number of the analyzed nodes of the branching tree after solving the problem. + + + +
- sym_getMatrix — To get the constraint matrix. + + + +
- sym_getNumConstr — To get the number of the constraints of the current problem. + + + +
- sym_getNumElements — To get the number of non-zero entries of the constraint matrix of the current problem. + + + +
- sym_getNumVar — To get the number of the variables of the current problem. + + + +
- sym_getObjCoeff — To get the objective vector. + + + +
- sym_getObjSense — Get the objective sense + + + +
- sym_getObjVal — Get the optimized objective value + + + +
- sym_getPrimalBound — Get the primal bound of the problem + + + +
- sym_getRhs — To to get the right hand side vector(column vector). + + + +
- sym_getStatus — To get status of the problem solver. + + + +
- sym_getStrParam — This routine is used to get the value of a string type parameter. + + + +
- sym_getVarLower — To get the lower bounds of the variables. + + + +
- sym_getVarSoln — Get the solution for the problem + + + +
- sym_getVarUpper — To get the upper bounds of the variables. + + + +
- sym_isAbandoned — To check whether the problem was abandoned for some reason. + + + +
- sym_isBinary — Check if a variable is constrained to be binary + + + +
- sym_isContinuous — Check if a variable is continuous + + + +
- sym_isEnvActive — Check if Symphony environment is active + + + +
- sym_isInfeasible — To check whether the problem was proven to be infeasible. + + + +
- sym_isInteger — Check if a variable is constrained to be an integer + + + +
- sym_isIterLimitReached — To know whether the iteration limit (node limit) was reached. + + + +
- sym_isOptimal — To check whether the problem was solved to optimality. + + + +
- sym_isTargetGapAchieved — To know whether the target gap was reached. + + + +
- sym_isTimeLimitReached — To know whether the time limit was reached. + + + +
- sym_loadMPS — This routine is used to load an instance from an MPS file. + + + +
- sym_loadProblem — Load a problem into Symphony + + + +
- sym_loadProblemBasic — Load a problem into Symphony (basic version) + + + +
- sym_open — Open the Symphony environment + + + +
- sym_resetParams — This routine sets all the environment variables and parameters to their default values. + + + +
- sym_setConstrLower — Set the lower bound of a constraint + + + +
- sym_setConstrType — Set the type of a constraint + + + +
- sym_setConstrUpper — Set the upper bound of a constraint + + + +
- sym_setContinuous — This routine is used to set the type of a variable to be continuous. + + + +
- sym_setDblParam — This routine is used to set a double type parameter. + + + +
- sym_setIntParam — This routine is used to set an integer type parameter. + + + +
- sym_setInteger — This routine is used to set the type of a variable to be integer. + + + +
- sym_setObjCoeff — Set coefficient of a variable in the objective + + + +
- sym_setObjSense — Set the objective sense + + + +
- sym_setPrimalBound — Set the primal bound of the problem + + + +
- sym_setStrParam — This routine is used to set a string type parameter. + + + +
- sym_setVarLower — Set lower bound of a variable + + + +
- sym_setVarSoln — Set a solution for the problem + + + +
- sym_setVarUpper — Set upper bound of a variable + + + +
- sym_solve — To solve the currently loaded MILP problem from scratch.
- fun: +
a function, the function to minimize. See below for the complete specifications.
+ - x0: +
a nx1 or 1xn matrix of doubles, where n is the number of variables. The initial guess for the optimization algorithm.
+ - A: +
a nil x n matrix of doubles, where n is the number of variables and nil is the number of linear inequalities. If A==[] and b==[], it is assumed that there is no linear inequality constraints. If (A==[] & b<>[]), fmincon generates an error (the same happens if (A<>[] & b==[])).
+ - b: +
a nil x 1 matrix of doubles, where nil is the number of linear inequalities.
+ - Aeq: +
a nel x n matrix of doubles, where n is the number of variables and nel is the number of linear equalities. If A==[] and b==[], it is assumed that there is no linear equality constraints. If (Aeq==[] & beq<>[]), fmincon generates an error (the same happens if (Aeq<>[] & beq==[])).
+ - beq: +
a nel x 1 matrix of doubles, where nel is the number of linear inequalities.
+ - lb: +
a nx1 or 1xn matrix of doubles, where n is the number of variables. The lower bound for x. If lb==[], then the lower bound is automatically set to -inf.
+ - ub: +
a nx1 or 1xn matrix of doubles, where n is the number of variables. The upper bound for x. If lb==[], then the upper bound is automatically set to +inf.
+ - nonlcon: +
a function, the nonlinear constraints. See below for the complete specifications.
+ - x: +
a nx1 matrix of doubles, the computed solution of the optimization problem
+ - fval: +
a 1x1 matrix of doubles, the function value at x
+ - exitflag: +
a 1x1 matrix of floating point integers, the exit status. See below for details.
+ - output: +
a struct, the details of the optimization process. See below for details.
+ - lambda: +
a struct, the Lagrange multipliers at optimum. See below for details.
+ - grad: +
a nx1 matrix of doubles, the gradient of the objective function at optimum
+ - hessian: +
a nxn matrix of doubles, the Hessian of the objective function at optimum
+ - options: +
an optional struct, as provided by optimset
- exitflag=0 : Number of iterations exceeded options.MaxIter or number of function evaluations exceeded options.FunEvals. +
- exitflag=1 : First-order optimality measure was less than options.TolFun, and maximum constraint violation was less than options.TolCon. +
- exitflag=-1 : The output function terminated the algorithm. +
- exitflag=-2 : No feasible point was found. +
- exitflag=%nan : Other type of termination.
- output.iterations: the number of iterations performed during the search +
- output.funcCount: the number of function evaluations during the search +
- output.stepsize: an empty matrix +
- output.algorithm : the string containing the name of the algorithm. In the current version, algorithm="ipopt". +
- output.firstorderopt: the max-norm of the first-order KKT conditions. +
- output.constrviolation: the max-norm of the constraint violation. +
- output.cgiterations: the number of preconditionned conjugate gradient steps. In the current version, cgiterations=0. +
- output.message: a string containing a message describing the status of the optimization.
- lambda.lower: the Lagrange multipliers for the lower bound constraints. In the current version, an empty matrix. +
- lambda.upper: the Lagrange multipliers for the upper bound constraints. In the current version, an empty matrix. +
- lambda.eqlin: the Lagrange multipliers for the linear equality constraints. +
- lambda.eqnonlin: the Lagrange multipliers for the nonlinear equality constraints. +
- lambda.ineqlin: the Lagrange multipliers for the linear inequality constraints. +
- lambda.ineqnonlin: the Lagrange multipliers for the nonlinear inequality constraints.
- Michael Baudin, DIGITEO, 2010
+
Symphony Toolbox
+-
+
+
+ + + + diff --git a/help/en_US/scilab_en_US_help/symphony.html b/help/en_US/scilab_en_US_help/symphony.html new file mode 100644 index 0000000..e69de29 diff --git a/help/en_US/scilab_en_US_help/symphony.html~ b/help/en_US/scilab_en_US_help/symphony.html~ new file mode 100644 index 0000000..0b78b0d --- /dev/null +++ b/help/en_US/scilab_en_US_help/symphony.html~ @@ -0,0 +1,318 @@ + + +
+ + +
fmincon
Solves a nonlinearily constrained optimization problem.
Calling Sequence
+x = fmincon(fun,x0) +x = fmincon(fun,x0,A,b) +x = fmincon(fun,x0,A,b,Aeq,beq) +x = fmincon(fun,x0,A,b,Aeq,beq,lb,ub) +x = fmincon(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon) +x = fmincon(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon,options) +[x,fval,exitflag,output,lambda,grad,hessian] = fmincon ( ... )
Parameters
+Description
+Search the minimum of a constrained optimization problem specified by : +find the minimum of f(x) such that
+c(x)<=0, ceq(x)<=0, A*x<=b, Aeq*x=beq and lb<=x<=ub.
+
Currently, we use ipopt for the actual solver of fmincon.
+See the demonstrations for additionnal examples.
+The objective function must have header : +
f = objfun ( x ) |  |  |
By default, fmincon uses finite differences with order 2 formulas and +optimum step size in order to compute a numerical gradient of the +objective function. +If we can provide exact gradients, we should do so since it improves +the convergence speed of the optimization algorithm. +In order to use exact gradients, we must update the header of the +objective function to : +
[f,G] = objfungrad ( x ) | | |
options = optimset("GradObj","on"); | | |
The constraint function must have header : +
[c, ceq] = confun(x) | | |
By default, fmincon uses finite differences with order 2 formulas and +optimum step size in order to compute a numerical gradient of the +constraint function. +In order to use exact gradients, we must update the header of the +constraint function to : +
[c,ceq,DC,DCeq] = confungrad(x) | | |
options = optimset("GradConstr","on"); | | |
By default, fmincon uses a L-BFGS formula to compute an +approximation of the Hessian of the Lagrangian. +Notice that this is different from Matlab's fmincon, which +default is to use a BFGS.
+The exitflag variable allows to know the status of the optimization. +
The output data structure contains detailed informations about the +optimization process. +It has type "struct" and contains the following fields. +
The lambda data structure contains the Lagrange multipliers at the +end of optimization. +It has type "struct" and contains the following +fields. +
TODO : exitflag=2 : Change in x was less than options.TolX and maximum constraint violation was less than options.TolCon. +TODO : exitflag=-3 : Current point x went below options.ObjectiveLimit and maximum constraint violation was less than options.TolCon. +TODO : fill lambda.lower and lambda.upper consistently. See ticket #111 : http://forge.scilab.org/index.php/p/sci-ipopt/issues/111/ +TODO : test with A, b +TODO : test with Aeq, beq +TODO : test with ceq +TODO : avoid using global for ipopt_data +TODO : implement Display option +TODO : implement FinDiffType option +TODO : implement MaxFunEvals option +TODO : implement DerivativeCheck option +TODO : implement MaxIter option +TODO : implement OutputFcn option +TODO : implement PlotFcns option +TODO : implement TolFun option +TODO : implement TolCon option +TODO : implement TolX option +TODO : implement Hessian option +TODO : check that the hessian output argument is Hessian of f only +TODO : test all exitflag values
+Examples
+// A basic case : +// we provide only the objective function and the nonlinear constraint +// function : we let fmincon compute the gradients by numerical +// derivatives. +function f=objfun(x) +f = exp(x(1))*(4*x(1)^2 + 2*x(2)^2 + 4*x(1)*x(2) + 2*x(2) + 1) +endfunction +function [c, ceq]=confun(x) +// Nonlinear inequality constraints +c = [ +1.5 + x(1)*x(2) - x(1) - x(2) +-x(1)*x(2) - 10 +] +// Nonlinear equality constraints +ceq = [] +endfunction +// The initial guess +x0 = [-1,1]; +// The expected solution : only 4 digits are guaranteed +xopt = [-9.547345885974547 1.047408305349257] +fopt = 0.023551460139148 +// Run fmincon +[x,fval,exitflag,output,lambda,grad,hessian] = .. +fmincon ( objfun,x0,[],[],[],[],[],[], confun ) | | |
Examples
+// A case where we provide the gradient of the objective +// function and the Jacobian matrix of the constraints. +// The objective function and its gradient +function [f, G]=objfungrad(x) +[lhs,rhs]=argn() +f = exp(x(1))*(4*x(1)^2+2*x(2)^2+4*x(1)*x(2)+2*x(2)+1) +if ( lhs > 1 ) then +G = [ +f + exp(x(1)) * (8*x(1) + 4*x(2)) +exp(x(1))*(4*x(1)+4*x(2)+2) +] +end +endfunction +// The nonlinear constraints and the Jacobian +// matrix of the constraints +function [c, ceq, DC, DCeq]=confungrad(x) +// Inequality constraints +c(1) = 1.5 + x(1) * x(2) - x(1) - x(2) +c(2) = -x(1) * x(2)-10 +// No nonlinear equality constraints +ceq=[] +[lhs,rhs]=argn() +if ( lhs > 2 ) then +// DC(:,i) = gradient of the i-th constraint +// DC = [ +// Dc1/Dx1 Dc2/Dx1 +// Dc1/Dx2 Dc2/Dx2 +// ] +DC= [ +x(2)-1, -x(2) +x(1)-1, -x(1) +] +DCeq = [] +end +endfunction +// Test with both gradient of objective and gradient of constraints +options = optimset("GradObj","on","GradConstr","on"); +// The initial guess +x0 = [-1,1]; +// The expected solution : only 4 digits are guaranteed +xopt = [-9.547345885974547 1.047408305349257] +fopt = 0.023551460139148 +// Run fmincon +[x,fval,exitflag,output] = .. +fmincon(objfungrad,x0,[],[],[],[],[],[], confungrad,options) | | |
Examples
+// A case where we set the bounds of the optimization. +// By default, the bounds are set to infinity. +function f=objfun(x) +f = exp(x(1))*(4*x(1)^2 + 2*x(2)^2 + 4*x(1)*x(2) + 2*x(2) + 1) +endfunction +function [c, ceq]=confun(x) +// Nonlinear inequality constraints +c = [ +1.5 + x(1)*x(2) - x(1) - x(2) +-x(1)*x(2) - 10 +] +// Nonlinear equality constraints +ceq = [] +endfunction +// The initial guess +x0 = [-1,1]; +// The expected solution +xopt = [0 1.5] +fopt = 8.5 +// Make sure that x(1)>=0, and x(2)>=0 +lb = [0,0]; +ub = [ ]; +// Run fmincon +[x,fval] = fmincon ( objfun , x0,[],[],[],[],lb,ub,confun) | | |
Authors
++ + + + -- cgit