summaryrefslogtreecommitdiff
path: root/sci_gateway/cpp
diff options
context:
space:
mode:
Diffstat (limited to 'sci_gateway/cpp')
-rw-r--r--sci_gateway/cpp/QuadNLP.hpp131
-rw-r--r--sci_gateway/cpp/builder_gateway_cpp.sce12
-rw-r--r--sci_gateway/cpp/builder_gateway_cpp.sce~150
-rw-r--r--sci_gateway/cpp/cleaner.sce8
-rw-r--r--sci_gateway/cpp/libFAMOS.c146
-rwxr-xr-xsci_gateway/cpp/libFAMOS.sobin0 -> 122770 bytes
-rw-r--r--sci_gateway/cpp/loader.sce9
-rw-r--r--sci_gateway/cpp/sci_QuadNLP.cpp248
-rw-r--r--sci_gateway/cpp/sci_ipopt.cpp194
9 files changed, 887 insertions, 11 deletions
diff --git a/sci_gateway/cpp/QuadNLP.hpp b/sci_gateway/cpp/QuadNLP.hpp
new file mode 100644
index 0000000..eff92da
--- /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 <sciprint.h>
+
+}
+using namespace Ipopt;
+
+class QuadNLP : public TNLP
+{
+ private:
+ Index numVars_; // Number of variables.
+
+ 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.
+
+ Number *lMatrix_; //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.
+
+ Number *conUB_; //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.
+
+ Number *varUB_; //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.
+
+ 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/builder_gateway_cpp.sce b/sci_gateway/cpp/builder_gateway_cpp.sce
index fb32d92..b42ac8e 100644
--- a/sci_gateway/cpp/builder_gateway_cpp.sce
+++ b/sci_gateway/cpp/builder_gateway_cpp.sce
@@ -12,8 +12,7 @@
mode(-1)
lines(0)
-WITHOUT_AUTO_PUTLHSVAR = %t;
-toolbox_title = "symphonytools"
+toolbox_title = "FAMOS"
[a, opt] = getversion();
Version = opt(2);
@@ -24,7 +23,7 @@ tools_path = path_builder + "../../thirdparty/linux/";
C_Flags=["-w -fpermissive -I"+tools_path+"include/coin -Wl,-rpath="+tools_path+"lib/"+Version+filesep()+" "]
-Linker_Flag = ["-L"+tools_path+"lib/"+Version+filesep()+"libSym"]
+Linker_Flag = ["-L"+tools_path+"lib/"+Version+filesep()+"libSym"+" "+"-L"+tools_path+"lib/"+Version+filesep()+"libipopt" ]
//Name of All the Functions
@@ -108,6 +107,9 @@ Function_Names = [
"sym_getObjVal","sci_sym_getObjVal";
"sym_getIterCount","sci_sym_get_iteration_count";
"sym_getConstrActivity","sci_sym_getRowActivity";
+
+ //QP function
+ "solveqp","sci_solveqp"
];
//Name of all the files to be compiled
@@ -136,6 +138,10 @@ Files = [
"sci_sym_getrowact.cpp",
"sci_sym_getobjsense.cpp",
"sci_sym_remove.cpp",
+ "sci_QuadNLP.cpp"
+ "QuadNLP.hpp"
+ "sci_ipopt.cpp"
+
]
tbx_build_gateway(toolbox_title,Function_Names,Files,get_absolute_file_path("builder_gateway_cpp.sce"), [], Linker_Flag, C_Flags, [], "g++");
diff --git a/sci_gateway/cpp/builder_gateway_cpp.sce~ b/sci_gateway/cpp/builder_gateway_cpp.sce~
new file mode 100644
index 0000000..2abfacc
--- /dev/null
+++ b/sci_gateway/cpp/builder_gateway_cpp.sce~
@@ -0,0 +1,150 @@
+// Copyright (C) 2015 - IIT Bombay - FOSSEE
+//
+// Author: Keyur Joshi, Sai Kiran, Iswarya and Harpreet Singh
+// Organization: FOSSEE, IIT Bombay
+// Email: harpreet.mertia@gmail.com
+// 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
+
+mode(-1)
+lines(0)
+
+WITHOUT_AUTO_PUTLHSVAR = %t;
+toolbox_title = "FAMOS"
+
+[a, opt] = getversion();
+Version = opt(2);
+
+path_builder = get_absolute_file_path('builder_gateway_cpp.sce');
+
+tools_path = path_builder + "../../thirdparty/linux/";
+
+C_Flags=["-w -fpermissive -I"+tools_path+"include/coin -Wl,-rpath="+tools_path+"lib/"+Version+filesep()+" "]
+
+Linker_Flag = ["-L"+tools_path+"lib/"+Version+filesep()+"libSym"+" "+"-L"+tools_path+"lib/"+Version+filesep()+"libipopt" ]
+
+
+//Name of All the Functions
+Function_Names = [
+ //for opening/closing environment and checking if it is open/close
+ "sym_open","sci_sym_open";
+ "sym_close","sci_sym_close";
+ "sym_isEnvActive","sci_sym_isEnvActive";
+
+ //run time parameters
+ "sym_resetParams","sci_sym_set_defaults";
+ "sym_setIntParam","sci_sym_set_int_param";
+ "sym_getIntParam","sci_sym_get_int_param";
+ "sym_setDblParam","sci_sym_set_dbl_param";
+ "sym_getDblParam","sci_sym_get_dbl_param";
+ "sym_setStrParam","sci_sym_set_str_param";
+ "sym_getStrParam","sci_sym_get_str_param";
+ "sym_getInfinity","sci_sym_getInfinity";
+
+ //problem loaders
+ "sym_loadProblemBasic","sci_sym_loadProblemBasic";
+ "sym_loadProblem","sci_sym_loadProblem";
+ "sym_loadMPS","sci_sym_load_mps";
+
+ //basic data
+ "sym_getNumConstr","sci_sym_get_num_int";
+ "sym_getNumVar","sci_sym_get_num_int";
+ "sym_getNumElements","sci_sym_get_num_int";
+
+ //variable and objective data
+ "sym_isContinuous","sci_sym_isContinuous";
+ "sym_isBinary","sci_sym_isBinary";
+ "sym_isInteger","sci_sym_isInteger";
+ "sym_setContinuous","sci_sym_set_continuous";
+ "sym_setInteger","sci_sym_set_integer";
+ "sym_getVarLower","sci_sym_get_dbl_arr";
+ "sym_getVarUpper","sci_sym_get_dbl_arr";
+ "sym_setVarLower","sci_sym_setVarBound";
+ "sym_setVarUpper","sci_sym_setVarBound";
+ "sym_getObjCoeff","sci_sym_get_dbl_arr";
+ "sym_setObjCoeff","sci_sym_setObjCoeff";
+ "sym_getObjSense","sci_sym_getObjSense";
+ "sym_setObjSense","sci_sym_setObjSense";
+
+ //constraint data
+ "sym_getRhs","sci_sym_get_dbl_arr";
+ "sym_getConstrRange","sci_sym_get_dbl_arr";
+ "sym_getConstrLower","sci_sym_get_dbl_arr";
+ "sym_getConstrUpper","sci_sym_get_dbl_arr";
+ "sym_setConstrLower","sci_sym_setConstrBound";
+ "sym_setConstrUpper","sci_sym_setConstrBound";
+ "sym_setConstrType","sci_sym_setConstrType";
+ "sym_getMatrix","sci_sym_get_matrix";
+ "sym_getConstrSense","sci_sym_get_row_sense";
+
+ //add/remove variables and constraints
+ "sym_addConstr","sci_sym_addConstr";
+ "sym_addVar","sci_sym_addVar";
+ "sym_deleteVars","sci_sym_delete_cols";
+ "sym_deleteConstrs","sci_sym_delete_rows";
+
+ //primal bound
+ "sym_getPrimalBound","sci_sym_getPrimalBound";
+ "sym_setPrimalBound","sci_sym_setPrimalBound";
+
+ //set preliminary solution
+ "sym_setVarSoln","sci_sym_setColSoln";
+
+ //solve
+ "sym_solve","sci_sym_solve";
+
+ //post solve functions
+ "sym_getStatus","sci_sym_get_status";
+ "sym_isOptimal","sci_sym_get_solver_status";
+ "sym_isInfeasible","sci_sym_get_solver_status";
+ "sym_isAbandoned","sci_sym_get_solver_status";
+ "sym_isIterLimitReached","sci_sym_get_solver_status";
+ "sym_isTimeLimitReached","sci_sym_get_solver_status";
+ "sym_isTargetGapAchieved","sci_sym_get_solver_status";
+ "sym_getVarSoln","sci_sym_getVarSoln";
+ "sym_getObjVal","sci_sym_getObjVal";
+ "sym_getIterCount","sci_sym_get_iteration_count";
+ "sym_getConstrActivity","sci_sym_getRowActivity";
+
+ //QP function
+ "solveqp","sci_solveqp"
+ ];
+
+//Name of all the files to be compiled
+Files = [
+ "globals.cpp",
+ "sci_iofunc.hpp",
+ "sci_iofunc.cpp",
+ "sci_sym_openclose.cpp",
+ "sci_solver_status_query_functions.cpp",
+ "sci_sym_solve.cpp",
+ "sci_sym_loadproblem.cpp",
+ "sci_sym_isenvactive.cpp",
+ "sci_sym_load_mps.cpp",
+ "sci_vartype.cpp",
+ "sci_sym_getinfinity.cpp",
+ "sci_sym_solution.cpp",
+ "sym_data_query_functions.cpp"
+ "sci_sym_set_variables.cpp",
+ "sci_sym_setobj.cpp",
+ "sci_sym_varbounds.cpp",
+ "sci_sym_rowmod.cpp",
+ "sci_sym_set_indices.cpp",
+ "sci_sym_addrowcol.cpp",
+ "sci_sym_primalbound.cpp",
+ "sci_sym_setcolsoln.cpp",
+ "sci_sym_getrowact.cpp",
+ "sci_sym_getobjsense.cpp",
+ "sci_sym_remove.cpp",
+ "sci_QuadNLP.cpp"
+ "QuadNLP.hpp"
+ "sci_ipopt.cpp"
+
+ ]
+
+tbx_build_gateway(toolbox_title,Function_Names,Files,get_absolute_file_path("builder_gateway_cpp.sce"), [], Linker_Flag, C_Flags, [], "g++");
+
+clear WITHOUT_AUTO_PUTLHSVAR toolbox_title Function_Names Files Linker_Flag C_Flags;
diff --git a/sci_gateway/cpp/cleaner.sce b/sci_gateway/cpp/cleaner.sce
index 45a256d..27b5409 100644
--- a/sci_gateway/cpp/cleaner.sce
+++ b/sci_gateway/cpp/cleaner.sce
@@ -10,12 +10,12 @@ if fileinfo('loader.sce') <> [] then
mdelete('loader.sce');
end
// ------------------------------------------------------
-if fileinfo('libsymphonytools.so') <> [] then
- mdelete('libsymphonytools.so');
+if fileinfo('libFAMOS.so') <> [] then
+ mdelete('libFAMOS.so');
end
// ------------------------------------------------------
-if fileinfo('libsymphonytools.c') <> [] then
- mdelete('libsymphonytools.c');
+if fileinfo('libFAMOS.c') <> [] then
+ mdelete('libFAMOS.c');
end
// ------------------------------------------------------
chdir(curdir);
diff --git a/sci_gateway/cpp/libFAMOS.c b/sci_gateway/cpp/libFAMOS.c
new file mode 100644
index 0000000..61990ad
--- /dev/null
+++ b/sci_gateway/cpp/libFAMOS.c
@@ -0,0 +1,146 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <mex.h>
+#include <sci_gateway.h>
+#include <api_scilab.h>
+#include <MALLOC.h>
+static int direct_gateway(char *fname,void F(void)) { F();return 0;};
+extern Gatefunc sci_sym_open;
+extern Gatefunc sci_sym_close;
+extern Gatefunc sci_sym_isEnvActive;
+extern Gatefunc sci_sym_set_defaults;
+extern Gatefunc sci_sym_set_int_param;
+extern Gatefunc sci_sym_get_int_param;
+extern Gatefunc sci_sym_set_dbl_param;
+extern Gatefunc sci_sym_get_dbl_param;
+extern Gatefunc sci_sym_set_str_param;
+extern Gatefunc sci_sym_get_str_param;
+extern Gatefunc sci_sym_getInfinity;
+extern Gatefunc sci_sym_loadProblemBasic;
+extern Gatefunc sci_sym_loadProblem;
+extern Gatefunc sci_sym_load_mps;
+extern Gatefunc sci_sym_get_num_int;
+extern Gatefunc sci_sym_get_num_int;
+extern Gatefunc sci_sym_get_num_int;
+extern Gatefunc sci_sym_isContinuous;
+extern Gatefunc sci_sym_isBinary;
+extern Gatefunc sci_sym_isInteger;
+extern Gatefunc sci_sym_set_continuous;
+extern Gatefunc sci_sym_set_integer;
+extern Gatefunc sci_sym_get_dbl_arr;
+extern Gatefunc sci_sym_get_dbl_arr;
+extern Gatefunc sci_sym_setVarBound;
+extern Gatefunc sci_sym_setVarBound;
+extern Gatefunc sci_sym_get_dbl_arr;
+extern Gatefunc sci_sym_setObjCoeff;
+extern Gatefunc sci_sym_getObjSense;
+extern Gatefunc sci_sym_setObjSense;
+extern Gatefunc sci_sym_get_dbl_arr;
+extern Gatefunc sci_sym_get_dbl_arr;
+extern Gatefunc sci_sym_get_dbl_arr;
+extern Gatefunc sci_sym_get_dbl_arr;
+extern Gatefunc sci_sym_setConstrBound;
+extern Gatefunc sci_sym_setConstrBound;
+extern Gatefunc sci_sym_setConstrType;
+extern Gatefunc sci_sym_get_matrix;
+extern Gatefunc sci_sym_get_row_sense;
+extern Gatefunc sci_sym_addConstr;
+extern Gatefunc sci_sym_addVar;
+extern Gatefunc sci_sym_delete_cols;
+extern Gatefunc sci_sym_delete_rows;
+extern Gatefunc sci_sym_getPrimalBound;
+extern Gatefunc sci_sym_setPrimalBound;
+extern Gatefunc sci_sym_setColSoln;
+extern Gatefunc sci_sym_solve;
+extern Gatefunc sci_sym_get_status;
+extern Gatefunc sci_sym_get_solver_status;
+extern Gatefunc sci_sym_get_solver_status;
+extern Gatefunc sci_sym_get_solver_status;
+extern Gatefunc sci_sym_get_solver_status;
+extern Gatefunc sci_sym_get_solver_status;
+extern Gatefunc sci_sym_get_solver_status;
+extern Gatefunc sci_sym_getVarSoln;
+extern Gatefunc sci_sym_getObjVal;
+extern Gatefunc sci_sym_get_iteration_count;
+extern Gatefunc sci_sym_getRowActivity;
+extern Gatefunc sci_solveqp;
+static GenericTable Tab[]={
+ {(Myinterfun)sci_gateway,sci_sym_open,"sym_open"},
+ {(Myinterfun)sci_gateway,sci_sym_close,"sym_close"},
+ {(Myinterfun)sci_gateway,sci_sym_isEnvActive,"sym_isEnvActive"},
+ {(Myinterfun)sci_gateway,sci_sym_set_defaults,"sym_resetParams"},
+ {(Myinterfun)sci_gateway,sci_sym_set_int_param,"sym_setIntParam"},
+ {(Myinterfun)sci_gateway,sci_sym_get_int_param,"sym_getIntParam"},
+ {(Myinterfun)sci_gateway,sci_sym_set_dbl_param,"sym_setDblParam"},
+ {(Myinterfun)sci_gateway,sci_sym_get_dbl_param,"sym_getDblParam"},
+ {(Myinterfun)sci_gateway,sci_sym_set_str_param,"sym_setStrParam"},
+ {(Myinterfun)sci_gateway,sci_sym_get_str_param,"sym_getStrParam"},
+ {(Myinterfun)sci_gateway,sci_sym_getInfinity,"sym_getInfinity"},
+ {(Myinterfun)sci_gateway,sci_sym_loadProblemBasic,"sym_loadProblemBasic"},
+ {(Myinterfun)sci_gateway,sci_sym_loadProblem,"sym_loadProblem"},
+ {(Myinterfun)sci_gateway,sci_sym_load_mps,"sym_loadMPS"},
+ {(Myinterfun)sci_gateway,sci_sym_get_num_int,"sym_getNumConstr"},
+ {(Myinterfun)sci_gateway,sci_sym_get_num_int,"sym_getNumVar"},
+ {(Myinterfun)sci_gateway,sci_sym_get_num_int,"sym_getNumElements"},
+ {(Myinterfun)sci_gateway,sci_sym_isContinuous,"sym_isContinuous"},
+ {(Myinterfun)sci_gateway,sci_sym_isBinary,"sym_isBinary"},
+ {(Myinterfun)sci_gateway,sci_sym_isInteger,"sym_isInteger"},
+ {(Myinterfun)sci_gateway,sci_sym_set_continuous,"sym_setContinuous"},
+ {(Myinterfun)sci_gateway,sci_sym_set_integer,"sym_setInteger"},
+ {(Myinterfun)sci_gateway,sci_sym_get_dbl_arr,"sym_getVarLower"},
+ {(Myinterfun)sci_gateway,sci_sym_get_dbl_arr,"sym_getVarUpper"},
+ {(Myinterfun)sci_gateway,sci_sym_setVarBound,"sym_setVarLower"},
+ {(Myinterfun)sci_gateway,sci_sym_setVarBound,"sym_setVarUpper"},
+ {(Myinterfun)sci_gateway,sci_sym_get_dbl_arr,"sym_getObjCoeff"},
+ {(Myinterfun)sci_gateway,sci_sym_setObjCoeff,"sym_setObjCoeff"},
+ {(Myinterfun)sci_gateway,sci_sym_getObjSense,"sym_getObjSense"},
+ {(Myinterfun)sci_gateway,sci_sym_setObjSense,"sym_setObjSense"},
+ {(Myinterfun)sci_gateway,sci_sym_get_dbl_arr,"sym_getRhs"},
+ {(Myinterfun)sci_gateway,sci_sym_get_dbl_arr,"sym_getConstrRange"},
+ {(Myinterfun)sci_gateway,sci_sym_get_dbl_arr,"sym_getConstrLower"},
+ {(Myinterfun)sci_gateway,sci_sym_get_dbl_arr,"sym_getConstrUpper"},
+ {(Myinterfun)sci_gateway,sci_sym_setConstrBound,"sym_setConstrLower"},
+ {(Myinterfun)sci_gateway,sci_sym_setConstrBound,"sym_setConstrUpper"},
+ {(Myinterfun)sci_gateway,sci_sym_setConstrType,"sym_setConstrType"},
+ {(Myinterfun)sci_gateway,sci_sym_get_matrix,"sym_getMatrix"},
+ {(Myinterfun)sci_gateway,sci_sym_get_row_sense,"sym_getConstrSense"},
+ {(Myinterfun)sci_gateway,sci_sym_addConstr,"sym_addConstr"},
+ {(Myinterfun)sci_gateway,sci_sym_addVar,"sym_addVar"},
+ {(Myinterfun)sci_gateway,sci_sym_delete_cols,"sym_deleteVars"},
+ {(Myinterfun)sci_gateway,sci_sym_delete_rows,"sym_deleteConstrs"},
+ {(Myinterfun)sci_gateway,sci_sym_getPrimalBound,"sym_getPrimalBound"},
+ {(Myinterfun)sci_gateway,sci_sym_setPrimalBound,"sym_setPrimalBound"},
+ {(Myinterfun)sci_gateway,sci_sym_setColSoln,"sym_setVarSoln"},
+ {(Myinterfun)sci_gateway,sci_sym_solve,"sym_solve"},
+ {(Myinterfun)sci_gateway,sci_sym_get_status,"sym_getStatus"},
+ {(Myinterfun)sci_gateway,sci_sym_get_solver_status,"sym_isOptimal"},
+ {(Myinterfun)sci_gateway,sci_sym_get_solver_status,"sym_isInfeasible"},
+ {(Myinterfun)sci_gateway,sci_sym_get_solver_status,"sym_isAbandoned"},
+ {(Myinterfun)sci_gateway,sci_sym_get_solver_status,"sym_isIterLimitReached"},
+ {(Myinterfun)sci_gateway,sci_sym_get_solver_status,"sym_isTimeLimitReached"},
+ {(Myinterfun)sci_gateway,sci_sym_get_solver_status,"sym_isTargetGapAchieved"},
+ {(Myinterfun)sci_gateway,sci_sym_getVarSoln,"sym_getVarSoln"},
+ {(Myinterfun)sci_gateway,sci_sym_getObjVal,"sym_getObjVal"},
+ {(Myinterfun)sci_gateway,sci_sym_get_iteration_count,"sym_getIterCount"},
+ {(Myinterfun)sci_gateway,sci_sym_getRowActivity,"sym_getConstrActivity"},
+ {(Myinterfun)sci_gateway,sci_solveqp,"solveqp"},
+};
+
+int C2F(libFAMOS)()
+{
+ Rhs = Max(0, Rhs);
+ if (*(Tab[Fin-1].f) != NULL)
+ {
+ if(pvApiCtx == NULL)
+ {
+ pvApiCtx = (StrCtx*)MALLOC(sizeof(StrCtx));
+ }
+ pvApiCtx->pstName = (char*)Tab[Fin-1].name;
+ (*(Tab[Fin-1].f))(Tab[Fin-1].name,Tab[Fin-1].F);
+ }
+ return 0;
+}
+#ifdef __cplusplus
+}
+#endif
diff --git a/sci_gateway/cpp/libFAMOS.so b/sci_gateway/cpp/libFAMOS.so
new file mode 100755
index 0000000..f148cca
--- /dev/null
+++ b/sci_gateway/cpp/libFAMOS.so
Binary files differ
diff --git a/sci_gateway/cpp/loader.sce b/sci_gateway/cpp/loader.sce
index 561a415..fe1d630 100644
--- a/sci_gateway/cpp/loader.sce
+++ b/sci_gateway/cpp/loader.sce
@@ -2,10 +2,10 @@
// Generated by builder.sce : Please, do not edit this file
// ----------------------------------------------------------------------------
//
-libsymphonytools_path = get_absolute_file_path('loader.sce');
+libFAMOS_path = get_absolute_file_path('loader.sce');
//
// ulink previous function with same name
-[bOK, ilib] = c_link('libsymphonytools');
+[bOK, ilib] = c_link('libFAMOS');
if bOK then
ulink(ilib);
end
@@ -68,10 +68,11 @@ list_functions = [ 'sym_open';
'sym_getObjVal';
'sym_getIterCount';
'sym_getConstrActivity';
+ 'solveqp';
];
-addinter(libsymphonytools_path + filesep() + 'libsymphonytools' + getdynlibext(), 'libsymphonytools', list_functions);
+addinter(libFAMOS_path + filesep() + 'libFAMOS' + getdynlibext(), 'libFAMOS', list_functions);
// remove temp. variables on stack
-clear libsymphonytools_path;
+clear libFAMOS_path;
clear bOK;
clear ilib;
clear list_functions;
diff --git a/sci_gateway/cpp/sci_QuadNLP.cpp b/sci_gateway/cpp/sci_QuadNLP.cpp
new file mode 100644
index 0000000..2c484b7
--- /dev/null
+++ b/sci_gateway/cpp/sci_QuadNLP.cpp
@@ -0,0 +1,248 @@
+/*
+ * Quadratic Programming Toolbox for Scilab using IPOPT library
+ * Authors :
+ Sai Kiran
+ Keyur Joshi
+ Iswarya
+ */
+
+#include "QuadNLP.hpp"
+#include "IpIpoptData.hpp"
+
+extern "C"{
+#include <api_scilab.h>
+#include <Scierror.h>
+#include <BOOL.h>
+#include <localization.h>
+#include <sciprint.h>
+
+
+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;i<n;i++){
+ x_l[i]=varLB_[i];
+ x_u[i]=varUB_[i];
+ }
+
+ for(i=0;i<m;i++){
+ g_l[i]=conLB_[i];
+ g_u[i]=conUB_[i];
+ }
+ return true;
+ }
+
+//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<n;++i){
+ for (j=0;j<n;++j){
+ obj_value+=x[i]*x[j]*qMatrix_[n*i+j];
+ }
+ obj_value+=x[i]*lMatrix_[i];
+ }
+ return true;
+ }
+
+//get value of gradient of objective function at vector x.
+bool QuadNLP::eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f){
+ unsigned int i,j;
+ for(i=0;i<n;i++){
+ grad_f[i]=lMatrix_[i];
+ for(j=0;j<n;j++)
+ grad_f[i]+=(qMatrix_[n*i+j]+qMatrix_[n*j+i])*x[j];
+ }
+ return true;
+ }
+
+//Get the values of constraints at vector x.
+bool QuadNLP::eval_g(Index n, const Number* x, bool new_x, Index m, Number* g){
+ unsigned int i,j;
+ for(i=0;i<m;i++){
+ g[i]=0;
+ for(j=0;j<n;j++)
+ g[i]+=x[j]*conMatrix_[n*i+j];
+ }
+ return true;
+ }
+
+// This method sets initial values for required vectors . For now we are assuming 0 to all values.
+bool QuadNLP::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){
+ if (init_x == true){ //we need to set initial values for vector x
+ for (Index var=0;var<n;++var)
+ x[var]=0.0;//initialize with 0 or we can change.
+ }
+
+ if (init_z == true){ //we need to provide initial values for vector bound multipliers
+ for (Index var=0;var<n;++var){
+ z_L[var]=0.0; //initialize with 0 or we can change.
+ z_U[var]=0.0;//initialize with 0 or we can change.
+ }
+ }
+
+ if (init_lambda == true){ //we need to provide initial values for lambda values.
+ for (Index var=0;var<m;++var){
+ lambda[var]=0.0; //initialize with 0 or we can change.
+ }
+ }
+
+ return true;
+ }
+/* Return either the sparsity structure of the Jacobian of the constraints, or the values for the Jacobian of the constraints at the point x.
+
+*/
+bool QuadNLP::eval_jac_g(Index n, const Number* x, bool new_x,
+ Index m, Index nele_jac, Index* iRow, Index *jCol,
+ Number* values){
+
+ //It asked for structure of jacobian.
+ if (values==NULL){ //Structure of jacobian (full structure)
+ int index=0;
+ for (int var=0;var<m;++var)//no. of constraints
+ for (int flag=0;flag<n;++flag){//no. of variables
+ iRow[index]=var;
+ jCol[index]=flag;
+ index++;
+ }
+ }
+ //It asked for values
+ else {
+ int index=0;
+ for (int var=0;var<m;++var)
+ for (int flag=0;flag<n;++flag)
+ values[index++]=conMatrix_[n*var+flag];
+ }
+ return true;
+ }
+
+/*
+ * Return either the sparsity structure of the Hessian of the Lagrangian,
+ * or the values of the Hessian of the Lagrangian for the given values for
+ * x,lambda,obj_factor.
+*/
+bool QuadNLP::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){
+
+ if (values==NULL){
+ Index idx=0;
+ for (Index row = 0; row < n; row++) {
+ for (Index col = 0; col <= row; col++) {
+ iRow[idx] = row;
+ jCol[idx] = col;
+ idx++;
+ }
+ }
+ }
+ else {
+ Index index=0;
+ for (Index row=0;row < n;++row){
+ for (Index col=0; col <= row; ++col){
+ values[index++]=obj_factor*(qMatrix_[n*row+col]+qMatrix_[n*col+row]);
+ }
+ }
+ }
+ return true;
+ }
+
+
+void QuadNLP::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){
+
+ finalX_ = (double*)malloc(sizeof(double) * numVars_ * 1);
+ for (Index i=0; i<n; i++)
+ {
+ finalX_[i] = x[i];
+ }
+
+ finalZl_ = (double*)malloc(sizeof(double) * numVars_ * 1);
+ for (Index i=0; i<n; i++)
+ {
+ finalZl_[i] = z_L[i];
+ }
+
+ finalZu_ = (double*)malloc(sizeof(double) * numVars_ * 1);
+ for (Index i=0; i<n; i++)
+ {
+ finalZu_[i] = z_U[i];
+ }
+
+ finalLambda_ = (double*)malloc(sizeof(double) * numConstr_ * 1);
+ for (Index i=0; i<m; i++)
+ {
+ finalLambda_[i] = lambda[i];
+ }
+
+ iter_ = ip_data->iter_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
new file mode 100644
index 0000000..a7ea33e
--- /dev/null
+++ b/sci_gateway/cpp/sci_ipopt.cpp
@@ -0,0 +1,194 @@
+/*
+ * 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 <api_scilab.h>
+#include <Scierror.h>
+#include <BOOL.h>
+#include <localization.h>
+#include <sciprint.h>
+
+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);
+
+ double *QItems=NULL,*PItems=NULL,*ConItems=NULL,*conUB=NULL,*conLB=NULL,*varUB=NULL,*varLB=NULL,x,f,iter;
+ unsigned int nVars,nCons;
+
+
+ unsigned int arg = 1,temp1,temp2;
+
+ 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){
+
+
+
+ using namespace Ipopt;
+ SmartPtr<QuadNLP> Prob = new QuadNLP(nVars,nCons,QItems,PItems,ConItems,conUB,conLB,varUB,varLB);
+ SmartPtr<IpoptApplication> 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 sciErr;
+ 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.
+
+
+ }
+ else {
+
+ sciprint("\nError:: check argument %d\n",arg);
+ return0toScilab();
+ return 1;
+ }
+
+ return 0;
+ }
+
+}
+
+/*
+hessian_constan
+jacobian _constant
+
+j_s_d constant : yes
+*/
+
generated by cgit (git 2.34.1) at 2024-12-20 06:12:02 +0000