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()}});
}
