int execute_tool2(const wchar_t* script_path, IArray* pParameters) { if (pParameters == 0) return 0; //gp_connect_impl connect; //if (!connect.init()) // return 1; if (pParameters == 0) return 0; _bstr_t file_path(script_path); long nParams = 0; pParameters->get_Count(&nParams); //CComQIPtr<IGPScriptTool>(pGPTool)->get_FileName(file_path.GetAddress()); bool ok = true; int errorOccurred = 0; if (file_path.length() && nParams) { std::vector< CAdapt<CComPtr<IGPParameter> > > return_params; //ipParameters->get_Count(&n); SEXP arc_env = Rf_findVar(Rf_install("arc"), R_GlobalEnv); { std::vector<SEXP> in_params; std::vector<std::string> in_params_names; std::vector<SEXP> out_params; std::vector<std::string> out_params_names; tools::protect pt; for (int i = 0; i < nParams; i++) { CComPtr<IUnknown> ipUnk; pParameters->get_Element(i, &ipUnk); CComQIPtr<IGPParameter> ipParam(ipUnk); esriGPParameterDirection eD; ipParam->get_Direction(&eD); std::pair<SEXP, std::string> p = param2r(ipParam); if (eD == esriGPParameterDirectionInput) { in_params.push_back(pt.add(p.first)); in_params_names.push_back(p.second); } else { out_params.push_back(pt.add(p.first)); out_params_names.push_back(p.second); return_params.push_back(ipParam); } } SEXP p1 = tools::newVal(in_params, pt); tools::nameIt(p1, in_params_names); SEXP p2 = tools::newVal(out_params, pt); tools::nameIt(p2, out_params_names); Rf_defineVar(Rf_install(".file"), tools::newVal(file_path, pt), arc_env); Rf_defineVar(Rf_install(".in"), p1, arc_env); Rf_defineVar(Rf_install(".out"), p2, arc_env); } const static wchar_t eval_str[] = L"arc$.ret<-local({" L"en<-new.env(hash=TRUE);" L"eval(parse(file=arc$.file), envir=en);" L"tool_exec<-get('tool_exec',en);" L"tool_exec(in_param, out_param)" L"},envir=list('in_param'=arc$.in,'out_param'=arc$.out))"; ok = current_connect->eval_one(eval_str) == 1; current_connect->print_out(NULL, -1); Rf_defineVar(Rf_install(".file"), R_NilValue, arc_env); Rf_defineVar(Rf_install(".in"), R_NilValue, arc_env); Rf_defineVar(Rf_install(".out"), R_NilValue, arc_env); R_gc(); //TODO: handle ok if (ok) { /*CComPtr<IGPMessages> ipMsgs; if (connect.m_ipGeoProcessor) connect.m_ipGeoProcessor->GetReturnMessages(&ipMsgs); if (ipMsgs) { VARIANT_BOOL bErr = VARIANT_FALSE; CComQIPtr<IGPMessage>(ipMsgs)->IsError(&bErr); if (bErr != VARIANT_FALSE) ok = false; }*/ if (!return_params.empty()) { //connect.m_ipGeoProcessor->Is SEXP ret = Rf_findVar(Rf_install(".ret"), arc_env); tools::vectorGeneric ret_out(ret); //tools::vectorGeneric ret_out(ret.get()); for (size_t i = 0, n = return_params.size(); i < n; i++) { _bstr_t name; return_params[i].m_T->get_Name(name.GetAddress()); size_t idx = ret_out.idx(std::string(name)); if (idx != (size_t)-1) { if (!r2param(ret_out.at(idx), return_params[i].m_T)) { std::wstring msg(L"failed to set output parameter - "); msg += name; current_connect->print_out(msg.c_str(), 2); } } } //TODO list } Rf_defineVar(Rf_install(".ret"), R_NilValue, arc_env); } } return ok ? 0 : 1; }
Function qpsol_nlp(const std::string& name, const std::string& solver, const std::map<std::string, M>& qp, const Dict& opts) { // We have: minimize f(x) = 1/2 * x' H x + c'x // subject to lbx <= x <= ubx // lbg <= g(x) = A x + b <= ubg M x, p, f, g; for (auto&& i : qp) { if (i.first=="x") { x = i.second; } else if (i.first=="p") { p = i.second; } else if (i.first=="f") { f = i.second; } else if (i.first=="g") { g = i.second; } else { casadi_error("No such field: " + i.first); } } if (g.is_empty(true)) g = M(0, 1); // workaround // Gradient of the objective: gf == Hx + g M gf = M::gradient(f, x); // Identify the linear term in the objective M c = substitute(gf, x, M::zeros(x.sparsity())); // Identify the quadratic term in the objective M H = M::jacobian(gf, x, true); // Identify the constant term in the constraints M b = substitute(g, x, M::zeros(x.sparsity())); // Identify the linear term in the constraints M A = M::jacobian(g, x); // Create a function for calculating the required matrices vectors Function prob(name + "_qp", {x, p}, {H, c, A, b}); // Create the QP solver Function conic_f = conic(name + "_qpsol", solver, {{"h", H.sparsity()}, {"a", A.sparsity()}}, opts); // Create an MXFunction with the right signature vector<MX> ret_in(NLPSOL_NUM_IN); ret_in[NLPSOL_X0] = MX::sym("x0", x.sparsity()); ret_in[NLPSOL_P] = MX::sym("p", p.sparsity()); ret_in[NLPSOL_LBX] = MX::sym("lbx", x.sparsity()); ret_in[NLPSOL_UBX] = MX::sym("ubx", x.sparsity()); ret_in[NLPSOL_LBG] = MX::sym("lbg", g.sparsity()); ret_in[NLPSOL_UBG] = MX::sym("ubg", g.sparsity()); ret_in[NLPSOL_LAM_X0] = MX::sym("lam_x0", x.sparsity()); ret_in[NLPSOL_LAM_G0] = MX::sym("lam_g0", g.sparsity()); vector<MX> ret_out(NLPSOL_NUM_OUT); // Get expressions for the QP matrices and vectors vector<MX> v(NL_NUM_IN); v[NL_X] = ret_in[NLPSOL_X0]; v[NL_P] = ret_in[NLPSOL_P]; v = prob(v); // Call the QP solver vector<MX> w(CONIC_NUM_IN); w[CONIC_H] = v.at(0); w[CONIC_G] = v.at(1); w[CONIC_A] = v.at(2); w[CONIC_LBX] = ret_in[NLPSOL_LBX]; w[CONIC_UBX] = ret_in[NLPSOL_UBX]; w[CONIC_LBA] = ret_in[NLPSOL_LBG] - v.at(3); w[CONIC_UBA] = ret_in[NLPSOL_UBG] - v.at(3); w[CONIC_X0] = ret_in[NLPSOL_X0]; w[CONIC_LAM_X0] = ret_in[NLPSOL_LAM_X0]; w[CONIC_LAM_A0] = ret_in[NLPSOL_LAM_G0]; w = conic_f(w); // Get expressions for the solution ret_out[NLPSOL_X] = w[CONIC_X]; ret_out[NLPSOL_F] = w[CONIC_COST]; ret_out[NLPSOL_G] = mtimes(v.at(2), w[CONIC_X]) + v.at(3); ret_out[NLPSOL_LAM_X] = w[CONIC_LAM_X]; ret_out[NLPSOL_LAM_G] = w[CONIC_LAM_A]; ret_out[NLPSOL_LAM_P] = MX::nan(p.sparsity()); return Function(name, ret_in, ret_out, nlpsol_in(), nlpsol_out(), {{"default_in", nlpsol_default_in()}}); }