void LrDpleToDple::init() {
// Initialize the base classes
LrDpleInternal::init();
MX As = MX::sym("As", input(LR_DPLE_A).sparsity());
MX Vs = MX::sym("Vs", input(LR_DPLE_V).sparsity());
MX Cs = MX::sym("Cs", input(LR_DPLE_C).sparsity());
MX Hs = MX::sym("Hs", input(LR_DPLE_H).sparsity());
int n_ = A_[0].size1();
// Chop-up the arguments
std::vector<MX> As_ = horzsplit(As, n_);
std::vector<MX> Vs_ = horzsplit(Vs, V_[0].size2());
std::vector<MX> Cs_ = horzsplit(Cs, V_[0].size2());
std::vector<MX> Hss_ = horzsplit(Hs, Hsi_);
std::vector<MX> V_(Vs_.size());
for (int k=0;k<V_.size();++k) {
V_[k] = mul(Cs_[k], mul(Vs_[k], Cs_[k].T()));
}
std::vector<Sparsity> Vsp(Vs_.size());
for (int k=0;k<V_.size();++k) {
Vsp[k] = V_[k].sparsity();
}
// Solver options
Dict options;
if (hasSetOption(optionsname())) {
options = getOption(optionsname());
}
// Create an dplesolver instance
std::map<std::string, std::vector<Sparsity> > tmp;
tmp["a"] = A_;
tmp["v"] = Vsp;
solver_ = DpleSolver("solver", getOption(solvername()), tmp, options);
MX P = solver_(make_map("a", horzcat(As_), "v", horzcat(V_))).at("p");
std::vector<MX> Ps_ = horzsplit(P, n_);
std::vector<MX> HPH(K_);
for (int k=0;k<K_;++k) {
std::vector<MX> hph = horzsplit(Hss_[k], cumsum0(Hs_[k]));
for (int kk=0;kk<hph.size();++kk) {
hph[kk] = mul(hph[kk].T(), mul(Ps_[k], hph[kk]));
}
HPH[k] = diagcat(hph);
}
f_ = MXFunction(name_, lrdpleIn("a", As, "v", Vs, "c", Cs, "h", Hs),
lrdpleOut("y", horzcat(HPH)));
Wrapper<LrDpleToDple>::checkDimensions();
}
void LiftingLrDpleInternal::init() {
form_ = getOptionEnumValue("form");
// Initialize the base classes
LrDpleInternal::init();
casadi_assert_message(!pos_def_,
"pos_def option set to True: Solver only handles the indefinite case.");
casadi_assert_message(const_dim_,
"const_dim option set to False: Solver only handles the True case.");
// We will construct an MXFunction to facilitate the calculation of derivatives
MX As = MX::sym("As", input(LR_DLE_A).sparsity());
MX Vs = MX::sym("Vs", input(LR_DLE_V).sparsity());
MX Cs = MX::sym("Cs", input(LR_DLE_C).sparsity());
MX Hs = MX::sym("Hs", input(LR_DLE_H).sparsity());
n_ = A_[0].size1();
// Chop-up the arguments
std::vector<MX> As_ = horzsplit(As, n_);
std::vector<MX> Vs_ = horzsplit(Vs, V_[0].size2());
std::vector<MX> Cs_ = horzsplit(Cs, V_[0].size2());
std::vector<MX> Hs_;
if (with_H_) {
Hs_ = horzsplit(Hs, Hsi_);
}
MX A;
if (K_==1) {
A = As;
} else {
if (form_==0) {
MX AL = diagcat(vector_slice(As_, range(As_.size()-1)));
MX AL2 = horzcat(AL, MX::sparse(AL.size1(), As_[0].size2()));
MX AT = horzcat(MX::sparse(As_[0].size1(), AL.size2()), As_.back());
A = vertcat(AT, AL2);
} else {
MX AL = diagcat(reverse(vector_slice(As_, range(As_.size()-1))));
MX AL2 = horzcat(MX::sparse(AL.size1(), As_[0].size2()), AL);
MX AT = horzcat(As_.back(), MX::sparse(As_[0].size1(), AL.size2()));
A = vertcat(AL2, AT);
}
}
MX V;
MX C;
MX H;
if (form_==0) {
V = diagcat(Vs_.back(), diagcat(vector_slice(Vs_, range(Vs_.size()-1))));
if (with_C_) {
C = diagcat(Cs_.back(), diagcat(vector_slice(Cs_, range(Cs_.size()-1))));
}
} else {
V = diagcat(diagcat(reverse(vector_slice(Vs_, range(Vs_.size()-1)))), Vs_.back());
if (with_C_) {
C = diagcat(diagcat(reverse(vector_slice(Cs_, range(Cs_.size()-1)))), Cs_.back());
}
}
if (with_H_) {
H = diagcat(form_==0? Hs_ : reverse(Hs_));
}
// Create an LrDleSolver instance
solver_ = LrDleSolver(getOption(solvername()),
lrdleStruct("a", A.sparsity(),
"v", V.sparsity(),
"c", C.sparsity(),
"h", H.sparsity()));
solver_.setOption("Hs", Hss_);
if (hasSetOption(optionsname())) solver_.setOption(getOption(optionsname()));
solver_.init();
std::vector<MX> v_in(LR_DPLE_NUM_IN);
v_in[LR_DLE_A] = As;
v_in[LR_DLE_V] = Vs;
if (with_C_) {
v_in[LR_DLE_C] = Cs;
}
if (with_H_) {
v_in[LR_DLE_H] = Hs;
}
std::vector<MX> Pr = solver_.call(lrdpleIn("a", A, "v", V, "c", C, "h", H));
MX Pf = Pr[0];
std::vector<MX> Ps = with_H_ ? diagsplit(Pf, Hsi_) : diagsplit(Pf, n_);
if (form_==1) {
Ps = reverse(Ps);
}
f_ = MXFunction(v_in, dpleOut("p", horzcat(Ps)));
f_.setInputScheme(SCHEME_LR_DPLEInput);
f_.setOutputScheme(SCHEME_LR_DPLEOutput);
f_.init();
Wrapper::checkDimensions();
}
