From e4b59ea62dd9903445375c2aa1f52a52c5eab99f Mon Sep 17 00:00:00 2001 From: Harpreet Date: Tue, 20 Oct 2015 14:23:25 +0530 Subject: qpipopt_mat added --- sci_gateway/cpp/QuadNLP.hpp | 56 +++--- sci_gateway/cpp/QuadNLP.hpp~ | 131 +++++++++++++ sci_gateway/cpp/libFAMOS.so | Bin 122770 -> 122834 bytes sci_gateway/cpp/sci_QuadNLP.cpp | 31 +-- sci_gateway/cpp/sci_QuadNLP.cpp~ | 255 +++++++++++++++++++++++++ sci_gateway/cpp/sci_ipopt.cpp | 222 ++++++++++++++++++++-- sci_gateway/cpp/sci_ipopt.cpp~ | 400 +++++++++++++++++++++++++++++++++++++++ 7 files changed, 1034 insertions(+), 61 deletions(-) create mode 100644 sci_gateway/cpp/QuadNLP.hpp~ create mode 100644 sci_gateway/cpp/sci_QuadNLP.cpp~ create mode 100644 sci_gateway/cpp/sci_ipopt.cpp~ (limited to 'sci_gateway/cpp') diff --git a/sci_gateway/cpp/QuadNLP.hpp b/sci_gateway/cpp/QuadNLP.hpp index eff92da..6f01241 100644 --- a/sci_gateway/cpp/QuadNLP.hpp +++ b/sci_gateway/cpp/QuadNLP.hpp @@ -23,48 +23,48 @@ using namespace Ipopt; class QuadNLP : public TNLP { private: - Index numVars_; // Number of variables. + Index numVars_; // Number of variables. - Index numConstr_; // Number of constraints. + Index numConstr_; // Number of constraints. - Number *qMatrix_; //qMatrix_ is a pointer to matrix of size numVars X numVars_ - // with coefficents of quadratic terms in objective function. + const Number *qMatrix_ = NULL; //qMatrix_ is a pointer to matrix of size numVars X numVars_ + // with coefficents of quadratic terms in objective function. - Number *lMatrix_; //lMatrix_ is a pointer to matrix of size 1*numVars_ - // with coefficents of linear terms in objective function. + const Number *lMatrix_ = NULL;//lMatrix_ is a pointer to matrix of size 1*numVars_ + // with coefficents of linear terms in objective function. - Number *conMatrix_; //conMatrix_ is a pointer to matrix of size numConstr X numVars - // with coefficients of terms in a each objective in each row. + const Number *conMatrix_ = NULL;//conMatrix_ is a pointer to matrix of size numConstr X numVars + // with coefficients of terms in a each objective in each row. - Number *conUB_; //conUB_ is a pointer to a matrix of size of 1*numConstr_ - // with upper bounds of all constraints. + const Number *conUB_= NULL; //conUB_ is a pointer to a matrix of size of 1*numConstr_ + // with upper bounds of all constraints. - Number *conLB_; //conLB_ is a pointer to a matrix of size of 1*numConstr_ - // with lower bounds of all constraints. + const Number *conLB_ = NULL; //conLB_ is a pointer to a matrix of size of 1*numConstr_ + // with lower bounds of all constraints. - Number *varUB_; //varUB_ is a pointer to a matrix of size of 1*numVar_ - // with upper bounds of all variables. + const Number *varUB_= NULL; //varUB_ is a pointer to a matrix of size of 1*numVar_ + // with upper bounds of all variables. - Number *varLB_; //varLB_ is a pointer to a matrix of size of 1*numVar_ - // with lower bounds of all variables. - - Number *finalX_; //finalX_ is a pointer to a matrix of size of 1*numVar_ - // with final value for the primal variables. + const Number *varLB_= NULL; //varLB_ is a pointer to a matrix of size of 1*numVar_ + // with lower bounds of all variables. + + Number *finalX_= NULL; //finalX_ is a pointer to a matrix of size of 1*numVar_ + // with final value for the primal variables. - Number *finalZl_; //finalZl_ is a pointer to a matrix of size of 1*numVar_ - // with final values for the lower bound multipliers + Number *finalZl_= NULL; //finalZl_ is a pointer to a matrix of size of 1*numVar_ + // with final values for the lower bound multipliers - Number *finalZu_; //finalZu_ is a pointer to a matrix of size of 1*numVar_ - // with final values for the upper bound multipliers + Number *finalZu_= NULL; //finalZu_ is a pointer to a matrix of size of 1*numVar_ + // with final values for the upper bound multipliers - Number *finalLambda_; //finalLambda_ is a pointer to a matrix of size of 1*numConstr_ - // with final values for the upper bound multipliers + Number *finalLambda_= NULL; //finalLambda_ is a pointer to a matrix of size of 1*numConstr_ + // with final values for the upper bound multipliers - Number finalObjVal_; //finalObjVal_ is a scalar with the final value of the objective. + Number finalObjVal_; //finalObjVal_ is a scalar with the final value of the objective. - int iter_; //Number of iteration. + int iter_; //Number of iteration. - int status_; //Solver return status + int status_; //Solver return status QuadNLP(const QuadNLP&); QuadNLP& operator=(const QuadNLP&); diff --git a/sci_gateway/cpp/QuadNLP.hpp~ b/sci_gateway/cpp/QuadNLP.hpp~ new file mode 100644 index 0000000..f47ab4d --- /dev/null +++ b/sci_gateway/cpp/QuadNLP.hpp~ @@ -0,0 +1,131 @@ +/* + * Quadratic Programming Toolbox for Scilab using IPOPT library + * Authors : + Sai Kiran + Keyur Joshi + Iswarya + + + * Optimizing (minimizing) the quadratic objective function having any number of variables and linear constraints. + * +*/ + +#ifndef __QuadNLP_HPP__ +#define __QuadNLP_HPP__ + +#include "IpTNLP.hpp" +extern "C"{ +#include + +} +using namespace Ipopt; + +class QuadNLP : public TNLP +{ + private: + Index numVars_; // Number of variables. + + Index numConstr_; // Number of constraints. + + const Number *qMatrix_ = NULL; //qMatrix_ is a pointer to matrix of size numVars X numVars_ + // with coefficents of quadratic terms in objective function. + + const Number *lMatrix_ = NULL;//lMatrix_ is a pointer to matrix of size 1*numVars_ + // with coefficents of linear terms in objective function. + + const Number *conMatrix_ = NULL;//conMatrix_ is a pointer to matrix of size numConstr X numVars + // with coefficients of terms in a each objective in each row. + + const Number *conUB_= NULL; //conUB_ is a pointer to a matrix of size of 1*numConstr_ + // with upper bounds of all constraints. + + const Number *conLB_; //conLB_ is a pointer to a matrix of size of 1*numConstr_ + // with lower bounds of all constraints. + + const Number *varUB_; //varUB_ is a pointer to a matrix of size of 1*numVar_ + // with upper bounds of all variables. + + const Number *varLB_; //varLB_ is a pointer to a matrix of size of 1*numVar_ + // with lower bounds of all variables. + + Number *finalX_; //finalX_ is a pointer to a matrix of size of 1*numVar_ + // with final value for the primal variables. + + Number *finalZl_; //finalZl_ is a pointer to a matrix of size of 1*numVar_ + // with final values for the lower bound multipliers + + Number *finalZu_; //finalZu_ is a pointer to a matrix of size of 1*numVar_ + // with final values for the upper bound multipliers + + Number *finalLambda_; //finalLambda_ is a pointer to a matrix of size of 1*numConstr_ + // with final values for the upper bound multipliers + + Number finalObjVal_; //finalObjVal_ is a scalar with the final value of the objective. + + int iter_; //Number of iteration. + + int status_; //Solver return status + + QuadNLP(const QuadNLP&); + QuadNLP& operator=(const QuadNLP&); + public: + /* + * Constructor + */ + QuadNLP(Index nV, Index nC, Number *qM, Number *lM, Number *cM, Number *cUB, Number *cLB, Number *vUB, Number *vLB): + numVars_(nV),numConstr_(nC),qMatrix_(qM),lMatrix_(lM),conMatrix_(cM),conUB_(cUB),conLB_(cLB),varUB_(vUB),varLB_(vLB),finalX_(0), finalZl_(0), finalZu_(0), finalObjVal_(1e20){ } + + + /* Go to : + + http://www.coin-or.org/Ipopt/documentation/node23.html#SECTION00053130000000000000 + For details about these below methods. + */ + virtual ~QuadNLP(); + virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g, + Index& nnz_h_lag, IndexStyleEnum& index_style); + virtual bool get_bounds_info(Index n, Number* x_l, Number* x_u, + Index m, Number* g_l, Number* g_u); + virtual bool get_starting_point(Index n, bool init_x, Number* x, + bool init_z, Number* z_L, Number* z_U, + Index m, bool init_lambda, + Number* lambda); + virtual bool eval_f(Index n, const Number* x, bool new_x, Number& obj_value); + virtual bool eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f); + virtual bool eval_g(Index n, const Number* x, bool new_x, Index m, Number* g); + virtual bool eval_jac_g(Index n, const Number* x, bool new_x, + Index m, Index nele_jac, Index* iRow, Index *jCol, + Number* values); + virtual bool eval_h(Index n, const Number* x, bool new_x, + Number obj_factor, Index m, const Number* lambda, + bool new_lambda, Index nele_hess, Index* iRow, + Index* jCol, Number* values); + virtual void finalize_solution(SolverReturn status, + Index n, const Number* x, const Number* z_L, const Number* z_U, + Index m, const Number* g, const Number* lambda, Number obj_value, + const IpoptData* ip_data, + IpoptCalculatedQuantities* ip_cq); + + const double * getX(); //Returns a pointer to a matrix of size of 1*numVar + // with final value for the primal variables. + + const double * getZu(); //Returns a pointer to a matrix of size of 1*numVars + // with final values for the upper bound multipliers + + const double * getZl(); //Returns a pointer to a matrix of size of 1*numVars + // with final values for the upper bound multipliers + + const double * getLambda(); //Returns a pointer to a matrix of size of 1*numConstr + // with final values for the constraint multipliers + + + double getObjVal(); //Returns the output of the final value of the objective. + + double iterCount(); //Returns the iteration count + + int returnStatus(); //Returns the status count + + +}; + +#endif __QuadNLP_HPP__ diff --git a/sci_gateway/cpp/libFAMOS.so b/sci_gateway/cpp/libFAMOS.so index f148cca..5e885f4 100755 Binary files a/sci_gateway/cpp/libFAMOS.so and b/sci_gateway/cpp/libFAMOS.so differ diff --git a/sci_gateway/cpp/sci_QuadNLP.cpp b/sci_gateway/cpp/sci_QuadNLP.cpp index 2c484b7..ddca7cf 100644 --- a/sci_gateway/cpp/sci_QuadNLP.cpp +++ b/sci_gateway/cpp/sci_QuadNLP.cpp @@ -56,12 +56,11 @@ bool QuadNLP::get_bounds_info(Index n, Number* x_l, Number* x_u, Index m, Number //get value of objective function at vector x bool QuadNLP::eval_f(Index n, const Number* x, bool new_x, Number& obj_value){ unsigned int i,j; - Number temp; obj_value=0; - for (i=0;i +#include +#include +#include +#include + + +double x_static,i, *op_obj_x = NULL,*op_obj_value = NULL; + +using namespace Ipopt; + +QuadNLP::~QuadNLP() + { + free(finalX_); + free(finalZl_); + free(finalZu_);} + +//get NLP info such as number of variables,constraints,no.of elements in jacobian and hessian to allocate memory +bool QuadNLP::get_nlp_info(Index& n, Index& m, Index& nnz_jac_g, Index& nnz_h_lag, IndexStyleEnum& index_style){ + n=numVars_; // Number of variables + m=numConstr_; // Number of constraints + nnz_jac_g = n*m; // No. of elements in Jacobian of constraints + nnz_h_lag = n*(n+1)/2; // No. of elements in lower traingle of Hessian of the Lagrangian. + index_style=C_STYLE; // Index style of matrices + return true; + } + +//get variable and constraint bound info +bool QuadNLP::get_bounds_info(Index n, Number* x_l, Number* x_u, Index m, Number* g_l, Number* g_u){ + + unsigned int i; + for(i=0;iiter_count(); + finalObjVal_ = obj_value; + status_ = status; + + } + + const double * QuadNLP::getX() + { + return finalX_; + } + + const double * QuadNLP::getZl() + { + return finalZl_; + } + + const double * QuadNLP::getZu() + { + return finalZu_; + } + + const double * QuadNLP::getLambda() + { + return finalLambda_; + } + + double QuadNLP::getObjVal() + { + return finalObjVal_; + } + + double QuadNLP::iterCount() + { + return (double)iter_; + } + + int QuadNLP::returnStatus() + { + return status_; + } + +} diff --git a/sci_gateway/cpp/sci_ipopt.cpp b/sci_gateway/cpp/sci_ipopt.cpp index a7ea33e..06796a9 100644 --- a/sci_gateway/cpp/sci_ipopt.cpp +++ b/sci_gateway/cpp/sci_ipopt.cpp @@ -53,25 +53,216 @@ int sci_solveqp(char *fname) CheckInputArgument(pvApiCtx, 9, 9); // We need total 9 input arguments. CheckOutputArgument(pvApiCtx, 7, 7); - + + // Error management variable + SciErr sciErr; + int retVal=0, *piAddressVarQ = NULL,*piAddressVarP = NULL,*piAddressVarCM = NULL,*piAddressVarCUB = NULL,*piAddressVarCLB = NULL, *piAddressVarLB = NULL,*piAddressVarUB = NULL; double *QItems=NULL,*PItems=NULL,*ConItems=NULL,*conUB=NULL,*conLB=NULL,*varUB=NULL,*varLB=NULL,x,f,iter; - unsigned int nVars,nCons; + static unsigned int nVars = 0,nCons = 0; + unsigned int temp1 = 0,temp2 = 0; + + + ////////// Manage the input argument ////////// + + + //Number of Variables + getIntFromScilab(1,&nVars); + + //Number of Constraints + getIntFromScilab(2,&nCons); + + temp1 = nVars; + temp2 = nCons; + + //Q matrix from scilab + /* get Address of inputs */ + sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddressVarQ); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + /* Check that the first input argument is a real matrix (and not complex) */ + if ( !isDoubleType(pvApiCtx, piAddressVarQ) || isVarComplex(pvApiCtx, piAddressVarQ) ) + { + Scierror(999, "%s: Wrong type for input argument #%d: A real matrix expected.\n", fname, 3); + return 0; + } + + /* get matrix */ + sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarQ, &temp1, &temp1, &QItems); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + //P matrix from scilab + /* get Address of inputs */ + sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddressVarP); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + /* Check that the first input argument is a real matrix (and not complex) */ + if ( !isDoubleType(pvApiCtx, piAddressVarP) || isVarComplex(pvApiCtx, piAddressVarP) ) + { + Scierror(999, "%s: Wrong type for input argument #%d: A real matrix expected.\n", fname, 4); + return 0; + } + + temp1 = 1; + temp2 = nVars; + /* get matrix */ + sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarP, &temp1,&temp2, &PItems); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + if (nCons!=0) + { + //conMatrix matrix from scilab + /* get Address of inputs */ + sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddressVarCM); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + /* Check that the first input argument is a real matrix (and not complex) */ + if ( !isDoubleType(pvApiCtx, piAddressVarCM) || isVarComplex(pvApiCtx, piAddressVarCM) ) + { + Scierror(999, "%s: Wrong type for input argument #%d: A real matrix expected.\n", fname, 5); + return 0; + } + temp1 = nCons; + temp2 = nVars; + + /* get matrix */ + sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarCM,&temp1, &temp2, &ConItems); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + + //conLB matrix from scilab + /* get Address of inputs */ + sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddressVarCLB); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + /* Check that the first input argument is a real matrix (and not complex) */ + if ( !isDoubleType(pvApiCtx, piAddressVarCLB) || isVarComplex(pvApiCtx, piAddressVarCLB) ) + { + Scierror(999, "%s: Wrong type for input argument #%d: A real matrix expected.\n", fname, 6); + return 0; + } + temp1 = nCons; + temp2 = 1; - unsigned int arg = 1,temp1,temp2; + /* get matrix */ + sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarCLB,&temp1, &temp2, &conLB); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + //conUB matrix from scilab + /* get Address of inputs */ + sciErr = getVarAddressFromPosition(pvApiCtx, 7, &piAddressVarCUB); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } - if ( !getIntFromScilab(arg,&nVars) && arg++ && !getIntFromScilab(arg,&nCons) && arg++ && - !getDoubleMatrixFromScilab(arg,&temp1,&temp2,&QItems) && temp1 == nVars && temp2 == nVars && arg++ && - !getDoubleMatrixFromScilab(arg,&temp1,&temp2,&PItems) && temp2 == nVars && arg++ && - !getDoubleMatrixFromScilab(arg,&temp1,&temp2,&ConItems) && temp1 == nCons &&((nCons !=0 && temp2 == nVars)||(temp2==0)) && arg++ && - !getDoubleMatrixFromScilab(arg,&temp1,&temp2,&conLB) && temp2 == nCons && arg++ && - !getDoubleMatrixFromScilab(arg,&temp1,&temp2,&conUB) && temp2 == nCons && arg++ && - !getDoubleMatrixFromScilab(arg,&temp1,&temp2,&varLB) && temp2 == nVars && arg++ && - !getDoubleMatrixFromScilab(arg,&temp1,&temp2,&varUB) && temp2 == nVars){ + /* Check that the first input argument is a real matrix (and not complex) */ + if ( !isDoubleType(pvApiCtx, piAddressVarCUB) || isVarComplex(pvApiCtx, piAddressVarCUB) ) + { + Scierror(999, "%s: Wrong type for input argument #%d: A real matrix expected.\n", fname, 7); + return 0; + } + temp1 = nCons; + temp2 = 1; + /* get matrix */ + sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarCUB,&temp1, &temp2, &conUB); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + } + + //varLB matrix from scilab + /* get Address of inputs */ + sciErr = getVarAddressFromPosition(pvApiCtx, 8, &piAddressVarLB); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + /* Check that the first input argument is a real matrix (and not complex) */ + if ( !isDoubleType(pvApiCtx, piAddressVarLB) || isVarComplex(pvApiCtx, piAddressVarLB) ) + { + Scierror(999, "%s: Wrong type for input argument #%d: A real matrix expected.\n", fname, 8); + return 0; + } + temp1 = 1; + temp2 = nVars; + + /* get matrix */ + sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarLB, &temp1,&temp2, &varLB); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + //varUB matrix from scilab + /* get Address of inputs */ + sciErr = getVarAddressFromPosition(pvApiCtx, 9, &piAddressVarUB); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + /* Check that the first input argument is a real matrix (and not complex) */ + if ( !isDoubleType(pvApiCtx, piAddressVarUB) || isVarComplex(pvApiCtx, piAddressVarUB) ) + { + Scierror(999, "%s: Wrong type for input argument #%d: A real matrix expected.\n", fname, 9); + return 0; + } + + temp1 = 1; + temp2 = nVars; + + /* get matrix */ + sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarUB, &temp1,&temp2, &varUB); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + using namespace Ipopt; + SmartPtr Prob = new QuadNLP(nVars,nCons,QItems,PItems,ConItems,conUB,conLB,varUB,varLB); SmartPtr app = IpoptApplicationFactory(); app->RethrowNonIpoptException(true); @@ -108,7 +299,6 @@ int sci_solveqp(char *fname) double *Lambda = Prob->getLambda(); double iteration = Prob->iterCount(); int stats = Prob->returnStatus(); - SciErr sciErr; sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, nVars, fX); if (sciErr.iErr) { @@ -171,14 +361,6 @@ int sci_solveqp(char *fname) // will be decremented and the objects will automatically // be deleted. - - } - else { - - sciprint("\nError:: check argument %d\n",arg); - return0toScilab(); - return 1; - } return 0; } diff --git a/sci_gateway/cpp/sci_ipopt.cpp~ b/sci_gateway/cpp/sci_ipopt.cpp~ new file mode 100644 index 0000000..12cbf81 --- /dev/null +++ b/sci_gateway/cpp/sci_ipopt.cpp~ @@ -0,0 +1,400 @@ +/* + * Quadratic Programming Toolbox for Scilab using IPOPT library + * Authors : + Sai Kiran + Keyur Joshi + Iswarya + */ + + +#include "sci_iofunc.hpp" +#include "IpIpoptApplication.hpp" +#include "QuadNLP.hpp" + +extern "C"{ +#include +#include +#include +#include +#include + +int j; +double *op_x, *op_obj,*p; + +bool readSparse(int arg,int *iRows,int *iCols,int *iNbItem,int** piNbItemRow, int** piColPos, double** pdblReal){ + SciErr sciErr; + int* piAddr = NULL; + int iType = 0; + int iRet = 0; + sciErr = getVarAddressFromPosition(pvApiCtx, arg, &piAddr); + if(sciErr.iErr) { + printError(&sciErr, 0); + return false; + } + sciprint("\ndone\n"); + if(isSparseType(pvApiCtx, piAddr)){ + sciprint("done\n"); + sciErr =getSparseMatrix(pvApiCtx, piAddr, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal); + if(sciErr.iErr) { + printError(&sciErr, 0); + return false; + } + } + + else { + sciprint("\nSparse matrix required\n"); + return false; + } + return true; + } + +int sci_solveqp(char *fname) +{ + + CheckInputArgument(pvApiCtx, 9, 9); // We need total 9 input arguments. + CheckOutputArgument(pvApiCtx, 7, 7); + + // Error management variable + SciErr sciErr; + int retVal=0, *piAddressVarQ = NULL,*piAddressVarP = NULL,*piAddressVarCM = NULL,*piAddressVarCUB = NULL,*piAddressVarCLB = NULL, *piAddressVarLB = NULL,*piAddressVarUB = NULL; + double *QItems=NULL,*PItems=NULL,*ConItems=NULL,*conUB=NULL,*conLB=NULL,*varUB=NULL,*varLB=NULL,x,f,iter; + static unsigned int nVars = 0,nCons = 0; + unsigned int temp1 = 0,temp2 = 0; + + + ////////// Manage the input argument ////////// + + + //Number of Variables + getIntFromScilab(1,&nVars); + + //Number of Constraints + getIntFromScilab(2,&nCons); + + temp1 = nVars; + temp2 = nCons; + + //Q matrix from scilab + /* get Address of inputs */ + sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddressVarQ); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + /* Check that the first input argument is a real matrix (and not complex) */ + if ( !isDoubleType(pvApiCtx, piAddressVarQ) || isVarComplex(pvApiCtx, piAddressVarQ) ) + { + Scierror(999, "%s: Wrong type for input argument #%d: A real matrix expected.\n", fname, 3); + return 0; + } + + /* get matrix */ + sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarQ, &temp1, &temp1, &QItems); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + + for(int i=0;i Prob = new QuadNLP(nVars,nCons,QItems,PItems,ConItems,conUB,conLB,varUB,varLB); + SmartPtr app = IpoptApplicationFactory(); + app->RethrowNonIpoptException(true); + + // Change some options + // Note: The following choices are only examples, they might not be + // suitable for your optimization problem. + app->Options()->SetNumericValue("tol", 1e-7); + app->Options()->SetStringValue("mu_strategy", "adaptive"); + + // Indicates whether all equality constraints are linear + app->Options()->SetStringValue("jac_c_constant", "yes"); + // Indicates whether all inequality constraints are linear + app->Options()->SetStringValue("jac_d_constant", "yes"); + // Indicates whether the problem is a quadratic problem + app->Options()->SetStringValue("hessian_constant", "yes"); + + // Initialize the IpoptApplication and process the options + ApplicationReturnStatus status; + status = app->Initialize(); + if (status != Solve_Succeeded) { + sciprint("\n*** Error during initialization!\n"); + return0toScilab(); + return (int) status; + } + // Ask Ipopt to solve the problem + + status = app->OptimizeTNLP(Prob); + + double *fX = Prob->getX(); + double ObjVal = Prob->getObjVal(); + double *Zl = Prob->getZl(); + double *Zu = Prob->getZu(); + double *Lambda = Prob->getLambda(); + double iteration = Prob->iterCount(); + int stats = Prob->returnStatus(); + sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, nVars, fX); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2,1,1,&ObjVal); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 3,1,1,&stats); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 4,1,1,&iteration); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 5, 1, nVars, Zl); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 6, 1, nVars, Zu); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 7, 1, nCons, Lambda); + if (sciErr.iErr) + { + printError(&sciErr, 0); + return 0; + } + + + AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; + AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2; + AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3; + AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx) + 4; + AssignOutputVariable(pvApiCtx, 5) = nbInputArgument(pvApiCtx) + 5; + AssignOutputVariable(pvApiCtx, 6) = nbInputArgument(pvApiCtx) + 6; + AssignOutputVariable(pvApiCtx, 7) = nbInputArgument(pvApiCtx) + 7; + + // As the SmartPtrs go out of scope, the reference count + // will be decremented and the objects will automatically + // be deleted. + + + return 0; + } + +} + +/* +hessian_constan +jacobian _constant + +j_s_d constant : yes +*/ + -- cgit