void QpToNlp::init(const Dict& opts) { // Initialize the base classes Qpsol::init(opts); // Default options string nlpsol_plugin; Dict nlpsol_options; // Read user options for (auto&& op : opts) { if (op.first=="nlpsol") { nlpsol_plugin = op.second.to_string(); } else if (op.first=="nlpsol_options") { nlpsol_options = op.second; } } // Create a symbolic matrix for the decision variables SX X = SX::sym("X", n_, 1); // Parameters to the problem SX H = SX::sym("H", sparsity_in(QPSOL_H)); SX G = SX::sym("G", sparsity_in(QPSOL_G)); SX A = SX::sym("A", sparsity_in(QPSOL_A)); // Put parameters in a vector std::vector<SX> par; par.push_back(H.nonzeros()); par.push_back(G.nonzeros()); par.push_back(A.nonzeros()); // The nlp looks exactly like a mathematical description of the NLP SXDict nlp = {{"x", X}, {"p", vertcat(par)}, {"f", mtimes(G.T(), X) + 0.5*mtimes(mtimes(X.T(), H), X)}, {"g", mtimes(A, X)}}; // Create an Nlpsol instance casadi_assert_message(!nlpsol_plugin.empty(), "'nlpsol' option has not been set"); solver_ = nlpsol("nlpsol", nlpsol_plugin, nlp, nlpsol_options); alloc(solver_); // Allocate storage for NLP solver parameters alloc_w(solver_.nnz_in(NLPSOL_P), true); }
void Callback::eval(const double** arg, double** res, int* iw, double* w, int mem) { // Allocate input matrices int n_in = this->n_in(); std::vector<DM> argv(n_in); for (int i=0; i<n_in; ++i) { argv[i] = DM(sparsity_in(i)); casadi_copy(arg[i], argv[i].nnz(), argv[i].ptr()); } // Evaluate std::vector<DM> resv = eval(argv); // Get the outputs int n_out = this->n_out(); for (int i=0; i<n_out; ++i) { casadi_copy(resv[i].ptr(), resv[i].nnz(), res[i]); } }
void GurobiInterface:: eval(void* mem, const double** arg, double** res, int* iw, double* w) const { auto m = static_cast<GurobiMemory*>(mem); // Inputs const double *h=arg[CONIC_H], *g=arg[CONIC_G], *a=arg[CONIC_A], *lba=arg[CONIC_LBA], *uba=arg[CONIC_UBA], *lbx=arg[CONIC_LBX], *ubx=arg[CONIC_UBX], *x0=arg[CONIC_X0], *lam_x0=arg[CONIC_LAM_X0]; // Outputs double *x=res[CONIC_X], *cost=res[CONIC_COST], *lam_a=res[CONIC_LAM_A], *lam_x=res[CONIC_LAM_X]; // Temporary memory double *val=w; w+=nx_; int *ind=iw; iw+=nx_; int *ind2=iw; iw+=nx_; int *tr_ind=iw; iw+=nx_; // Greate an empty model GRBmodel *model = 0; try { int flag = GRBnewmodel(m->env, &model, name_.c_str(), 0, 0, 0, 0, 0, 0); casadi_assert_message(!flag, GRBgeterrormsg(m->env)); // Add variables for (int i=0; i<nx_; ++i) { // Get bounds double lb = lbx ? lbx[i] : 0., ub = ubx ? ubx[i] : 0.; if (isinf(lb)) lb = -GRB_INFINITY; if (isinf(ub)) ub = GRB_INFINITY; // Get variable type char vtype; if (!vtype_.empty()) { // Explicitly set 'vtype' takes precedence vtype = vtype_.at(i); } else if (!discrete_.empty() && discrete_.at(i)) { // Variable marked as discrete (integer or binary) vtype = lb==0 && ub==1 ? GRB_BINARY : GRB_INTEGER; } else { // Continious variable vtype = GRB_CONTINUOUS; } // Pass to model flag = GRBaddvar(model, 0, 0, 0, g ? g[i] : 0., lb, ub, vtype, 0); casadi_assert_message(!flag, GRBgeterrormsg(m->env)); } flag = GRBupdatemodel(model); casadi_assert_message(!flag, GRBgeterrormsg(m->env)); // Add quadratic terms const int *H_colind=sparsity_in(CONIC_H).colind(), *H_row=sparsity_in(CONIC_H).row(); for (int i=0; i<nx_; ++i) { // Quadratic term nonzero indices int numqnz = H_colind[1]-H_colind[0]; casadi_copy(H_row, numqnz, ind); H_colind++; H_row += numqnz; // Corresponding column casadi_fill(ind2, numqnz, i); // Quadratic term nonzeros if (h) { casadi_copy(h, numqnz, val); casadi_scal(numqnz, 0.5, val); h += numqnz; } else { casadi_fill(val, numqnz, 0.); } // Pass to model flag = GRBaddqpterms(model, numqnz, ind, ind2, val); casadi_assert_message(!flag, GRBgeterrormsg(m->env)); } // Add constraints const int *A_colind=sparsity_in(CONIC_A).colind(), *A_row=sparsity_in(CONIC_A).row(); casadi_copy(A_colind, nx_, tr_ind); for (int i=0; i<na_; ++i) { // Get bounds double lb = lba ? lba[i] : 0., ub = uba ? uba[i] : 0.; // if (isinf(lb)) lb = -GRB_INFINITY; // if (isinf(ub)) ub = GRB_INFINITY; // Constraint nonzeros int numnz = 0; for (int j=0; j<nx_; ++j) { if (tr_ind[j]<A_colind[j+1] && A_row[tr_ind[j]]==i) { ind[numnz] = j; val[numnz] = a ? a[tr_ind[j]] : 0; numnz++; tr_ind[j]++; } } // Pass to model if (isinf(lb)) { if (isinf(ub)) { // Neither upper or lower bounds, skip } else { // Only upper bound flag = GRBaddconstr(model, numnz, ind, val, GRB_LESS_EQUAL, ub, 0); casadi_assert_message(!flag, GRBgeterrormsg(m->env)); } } else { if (isinf(ub)) { // Only lower bound flag = GRBaddconstr(model, numnz, ind, val, GRB_GREATER_EQUAL, lb, 0); casadi_assert_message(!flag, GRBgeterrormsg(m->env)); } else if (lb==ub) { // Upper and lower bounds equal flag = GRBaddconstr(model, numnz, ind, val, GRB_EQUAL, lb, 0); casadi_assert_message(!flag, GRBgeterrormsg(m->env)); } else { // Both upper and lower bounds flag = GRBaddrangeconstr(model, numnz, ind, val, lb, ub, 0); casadi_assert_message(!flag, GRBgeterrormsg(m->env)); } } } // Solve the optimization problem flag = GRBoptimize(model); casadi_assert_message(!flag, GRBgeterrormsg(m->env)); int optimstatus; flag = GRBgetintattr(model, GRB_INT_ATTR_STATUS, &optimstatus); casadi_assert_message(!flag, GRBgeterrormsg(m->env)); // Get the objective value, if requested if (cost) { flag = GRBgetdblattr(model, GRB_DBL_ATTR_OBJVAL, cost); casadi_assert_message(!flag, GRBgeterrormsg(m->env)); } // Get the optimal solution, if requested if (x) { flag = GRBgetdblattrarray(model, GRB_DBL_ATTR_X, 0, nx_, x); casadi_assert_message(!flag, GRBgeterrormsg(m->env)); } // Free memory GRBfreemodel(model); } catch (...) { // Free memory if (model) GRBfreemodel(model); throw; } }