A simplified interface for NLP modeling/solving. More...

#include <optistack_internal.hpp>

Detailed Description

Date: 2017

Author: Joris Gillis, Erik Lambrechts

Extra doc: https://github.com/casadi/casadi/wiki/L_172

Definition at line 55 of file optistack_internal.hpp.

Inheritance diagram for casadi::OptiNode:

[legend]

Collaboration diagram for casadi::OptiNode:

[legend]

Public Types
using	weak_ref_type = WeakRefInternal

Public Member Functions
	OptiNode (const std::string &problem_type)
	Create Opti Context. More...

	~OptiNode ()
	Destructor. More...

MX	variable (casadi_int n=1, casadi_int m=1, const std::string &attribute="full")
	Create a decision variable (symbol) More...

MX	variable (const Sparsity &sp, const std::string &attribute="full")

MX	variable (const MX &symbol, const std::string &attribute="full")

MX	parameter (casadi_int n=1, casadi_int m=1, const std::string &attribute="full")
	Create a parameter (symbol); fixed during optimization. More...

MX	parameter (const Sparsity &sp, const std::string &attribute="full")
	Create a parameter (symbol); fixed during optimization. More...

MX	parameter (const MX &symbol, const std::string &attribute="full")

void	minimize (const MX &f, double linear_scale=1)
	Set objective. More...

void	subject_to (const MX &g, const DM &linear_scale=1, const Dict &options=Dict())
	brief Add constraints More...

void	subject_to ()
	Clear constraints. More...

void	solver (const std::string &solver, const Dict &plugin_options=Dict(), const Dict &solver_options=Dict())
	Solver. More...

void	set_domain (const MX &x, const std::string &domain)
	Set domain of variable. More...

void	set_linear_scale (const MX &x, const DM &scale, const DM &offset)
	Set scale of a decision variable. More...

OptiSol	solve (bool accept_limit)
	Crunch the numbers; solve the problem. More...

Opti	copy () const
	Copy. More...

Dict	stats () const
	Get statistics. More...

std::string	return_status () const
	Get return status of solver. More...

bool	return_success (bool accept_limit) const
	Did the solver return successfully? More...

Function	casadi_solver () const
	Get the underlying CasADi solver of the Opti stack. More...

Function	scale_helper (const Function &h) const
	Scale a helper function constructed via opti.x, opti.g, ... More...

std::vector< MX >	initial () const
	get assignment expressions for initial values More...

std::vector< MX >	value_variables () const
	get assignment expressions for latest values More...

std::vector< MX >	value_parameters () const

void	callback_class (OptiCallback *callback)

void	callback_class ()

bool	has_callback_class () const

bool	is_parametric (const MX &expr) const
	return true if expression is only dependant on Opti parameters, not variables More...

MetaCon	canon_expr (const MX &expr, const DM &linear_scale=1) const
	Interpret an expression (for internal use only) More...

MetaVar	get_meta (const MX &m) const
	Get meta-data of symbol (for internal use only) More...

MetaCon	get_meta_con (const MX &m) const
	Get meta-data of symbol (for internal use only) More...

void	set_meta (const MX &m, const MetaVar &meta)
	Set meta-data of an expression. More...

void	set_meta_con (const MX &m, const MetaCon &meta)
	Set meta-data of an expression. More...

void	update_user_dict (const MX &m, const Dict &meta)
	add meta-data of an expression More...

Dict	user_dict (const MX &m) const

MX	dual (const MX &m) const
	get the dual variable More...

void	assert_active_symbol (const MX &m) const

std::vector< MX >	symvar (VariableType type) const

std::vector< MX >	active_symvar (VariableType type) const

std::vector< DM >	active_values (VariableType type) const

std::vector< DM >	active_values (VariableType type, const std::map< VariableType, std::vector< DM > > &store) const

MX	x_lookup (casadi_int i) const

MX	g_lookup (casadi_int i) const

std::string	x_describe (casadi_int i, const Dict &opts=Dict()) const

std::string	g_describe (casadi_int i, const Dict &opts=Dict()) const

std::string	describe (const MX &x, casadi_int indent=0, const Dict &opts=Dict()) const

void	solve_prepare ()

Function	solver_construct (bool callback=true)

DMDict	solve_actual (const DMDict &args)

DMDict	arg () const

void	res (const DMDict &res)

DMDict	res () const

std::vector< MX >	constraints () const

MX	objective () const

OptiAdvanced	baked_copy () const

std::string	class_name () const override
	Readable name of the internal class. More...

casadi_int	nx () const
	Number of (scalarised) decision variables. More...

casadi_int	np () const
	Number of (scalarised) parameters. More...

casadi_int	ng () const
	Number of (scalarised) constraints. More...

MX	x () const
	Get all (scalarised) decision variables as a symbolic column vector. More...

MX	p () const
	Get all (scalarised) parameters as a symbolic column vector. More...

MX	g () const
	Get all (scalarised) constraint expressions as a column vector. More...

MX	f () const
	Get objective expression. More...

MX	lbg () const

MX	ubg () const

MX	lam_g () const
	Get dual variables as a symbolic column vector. More...

DM	x_linear_scale () const

DM	x_linear_scale_offset () const

DM	g_linear_scale () const

double	f_linear_scale () const

void	assert_empty () const

void	show_infeasibilities (double tol=0, const Dict &opts=Dict()) const

Function	to_function (const std::string &name, const std::vector< MX > &args, const std::vector< MX > &res, const std::vector< std::string > &name_in, const std::vector< std::string > &name_out, const Dict &opts)
	Create a CasADi Function from the Opti solver. More...

void	disp (std::ostream &stream, bool more=false) const override
	Print representation. More...

void	bake ()
	Fix the structure of the optimization problem. More...

casadi_int	instance_number () const

void	mark_problem_dirty (bool flag=true)

bool	problem_dirty () const

void	mark_solver_dirty (bool flag=true)

bool	solver_dirty () const

void	mark_solved (bool flag=true)

bool	solved () const

void	assert_solved () const

void	assert_baked () const

casadi_int	g_index_reduce_g (casadi_int i) const

casadi_int	g_index_reduce_x (casadi_int i) const

casadi_int	g_index_unreduce_g (casadi_int i) const

casadi_int	getCount () const
	Get the reference count. More...

std::string	debug_repr (const SharedObjectInternal *) const

GenericWeakRef< SharedObject, SharedObjectInternal > *	weak ()
	Get a weak reference to the object. More...


void	set_initial (const MX &x, const DM &v)

void	set_initial (const std::vector< MX > &assignments)


void	set_value (const MX &x, const DM &v)
	Set value of parameter. More...

void	set_value (const std::vector< MX > &assignments)
	Set value of parameter. More...


DM	value (const MX &x, const std::vector< MX > &values=std::vector< MX >(), bool scaled=false) const

DM	value (const DM &x, const std::vector< MX > &values=std::vector< MX >(), bool scaled=false) const

DM	value (const SX &x, const std::vector< MX > &values=std::vector< MX >(), bool scaled=false) const


std::vector< MX >	symvar () const

std::vector< MX >	symvar (const MX &expr) const

std::vector< MX >	symvar (const MX &expr, VariableType type) const

Static Public Member Functions
static OptiNode *	create (const std::string &problem_type)

Public Attributes
bool	problem_dirty_

bool	solver_dirty_

bool	solved_

Protected Member Functions
void	initSingleton ()

void	destroySingleton ()

B	shared_from_this ()
	Get a shared object from the current internal object. More...

const B	shared_from_this () const
	Get a shared object from the current internal object. More...

Friends
class	InternalOptiCallback

Member Typedef Documentation

◆ weak_ref_type

using casadi::SharedObjectInternal::weak_ref_type = WeakRefInternal

inherited

Definition at line 152 of file shared_object.hpp.

Constructor & Destructor Documentation

◆ OptiNode()

casadi::OptiNode::OptiNode ( const std::string & problem_type )

Definition at line 256 of file optistack_internal.cpp.

                                                 :
     count_(0), count_var_(0), count_par_(0), count_dual_(0) {
   f_ = 0;
   f_linear_scale_ = 1;
   instance_number_ = instance_count_++;
   user_callback_ = nullptr;
   store_initial_[OPTI_VAR] = {};
   store_initial_[OPTI_PAR] = {};
   store_initial_[OPTI_DUAL_G] = {};
   store_latest_[OPTI_VAR] = {};
   store_latest_[OPTI_DUAL_G] = {};
   casadi_assert(problem_type=="nlp" || problem_type=="conic",
     "Specified problem type '" + problem_type + "'unknown. "
     "Choose 'nlp' (default) or 'conic'.");
   problem_type_ = problem_type;
   mark_problem_dirty();
   helpers_ = std::make_shared<ValueCache>();
 }

References mark_problem_dirty(), casadi::OPTI_DUAL_G, casadi::OPTI_PAR, and casadi::OPTI_VAR.

Referenced by copy(), and create().

◆ ~OptiNode()

casadi::OptiNode::~OptiNode ( )

Definition at line 275 of file optistack_internal.cpp.

275 {

276 }

Member Function Documentation

◆ active_symvar()

std::vector< MX > casadi::OptiNode::active_symvar ( VariableType type ) const

Definition at line 1641 of file optistack_internal.cpp.

                                                              {
   if (symbol_active_.empty()) return std::vector<MX>{};
   std::vector<MX> ret;
   for (const auto& s : symbols_) {
     if (symbol_active_[meta(s).count] && meta(s).type==type)
       ret.push_back(s);
   }
   return ret;
 }

Referenced by bake(), res(), solve_prepare(), to_function(), and x_lookup().

◆ active_values() [1/2]

std::vector< DM > casadi::OptiNode::active_values ( VariableType type ) const

Definition at line 1661 of file optistack_internal.cpp.

                                                              {
   return active_values(type, store_initial_);
 }

Referenced by bake(), solve_prepare(), and to_function().

◆ active_values() [2/2]

std::vector< DM > casadi::OptiNode::active_values	(	VariableType	type,
		const std::map< VariableType, std::vector< DM > > &	store
	)		const

Definition at line 1665 of file optistack_internal.cpp.

                                                               {
   if (symbol_active_.empty()) return std::vector<DM>{};
   std::vector<DM> ret;
   for (const auto& s : symbols_) {
     if (symbol_active_[meta(s).count] && meta(s).type==type) {
       ret.push_back(store.at(meta(s).type)[meta(s).i]);
     }
   }
   return ret;
 }

◆ arg()

DMDict casadi::OptiNode::arg ( ) const

inline

Definition at line 210 of file optistack_internal.hpp.

210 { return arg_; }

Referenced by scale_helper(), solve_actual(), solve_prepare(), to_function(), and value().

◆ assert_active_symbol()

void casadi::OptiNode::assert_active_symbol ( const MX & m ) const

Definition at line 1483 of file optistack_internal.cpp.

                                                      {
   assert_has(m);
   assert_baked();
   casadi_assert(symbol_active_[meta(m).count], "Opti symbol is not used in Solver."
     " It does not make sense to assign a value to it:\n" + describe(m, 1));
 }

References assert_baked(), and describe().

◆ assert_baked()

void casadi::OptiNode::assert_baked ( ) const

Definition at line 1175 of file optistack_internal.cpp.

                                   {
   casadi_assert(!problem_dirty(),
     "This action is forbidden since you have not baked the Opti stack yet "
     "(with calling 'solve').");
 }

References problem_dirty().

Referenced by assert_active_symbol().

◆ assert_empty()

void casadi::OptiNode::assert_empty ( ) const

Definition at line 1181 of file optistack_internal.cpp.

                                   {
   casadi_assert_dev(g_.empty());
   casadi_assert_dev(f_.is_empty());
 }

References casadi::GenericMatrix< MatType >::is_empty().

◆ assert_solved()

void casadi::OptiNode::assert_solved ( ) const

Definition at line 1169 of file optistack_internal.cpp.

                                    {
   casadi_assert(solved(),
     "This action is forbidden since you have not solved the Opti stack yet "
     "(with calling 'solve').");
 }

References solved().

Referenced by stats(), and value().

◆ bake()

void casadi::OptiNode::bake ( )

Definition at line 727 of file optistack_internal.cpp.

                     {
   casadi_assert(!f_.is_empty() || !g_.empty(),
     "You need to specify at least an objective (y calling 'minimize'), "
     "or a constraint (by calling 'subject_to').");
  
   symbol_active_.clear();
   symbol_active_.resize(symbols_.size());
   helpers_ = std::make_shared<ValueCache>();
  
   // Gather all expressions
   MX total_expr = vertcat(f_, veccat(g_));
  
   // Categorize the symbols appearing in those expressions
   for (const auto& d : symvar(total_expr))
     symbol_active_[meta(d).count] = true;
  
   std::vector<MX> x = active_symvar(OPTI_VAR);
   for (casadi_int i=0;i<x.size();++i) meta(x[i]).active_i = i;
  
   casadi_int offset = 0;
   for (const auto& v : x) {
     meta(v).start = offset;
     offset+= v.nnz();
     meta(v).stop = offset;
   }
   std::vector<MX> p = active_symvar(OPTI_PAR);
   for (casadi_int i=0;i<p.size();++i) meta(p[i]).active_i = i;
  
   // Fill the nlp definition
   nlp_["x"] = veccat(x);
   nlp_["p"] = veccat(p);
  
   nlp_unscaled_["x"] = veccat(x);
   nlp_unscaled_["p"] = veccat(p);
  
   discrete_.clear();
   for (const MX& e : x) {
     discrete_.insert(discrete_.end(), e.nnz(), meta(e).domain == OPTI_DOMAIN_INTEGER);
   }
  
   nlp_["f"] = f_;
   nlp_unscaled_["f"] = f_;
  
   offset = 0;
   for (casadi_int i=0;i<g_.size();++i) {
     MetaCon& r = meta_con(g_[i]);
     MetaVar& r2 = meta(r.dual_canon);
     symbol_active_[r2.count] = true;
  
     // Compute offsets for this constraint:
     // location into the global constraint variable
     r.start = offset;
     offset+= r.canon.nnz();
     r.stop = offset;
  
     r2.start = r.start;
     r2.stop  = r.stop;
  
   }
   index_all_to_g_.resize(offset);
   offset = 0;
   casadi_int offset_g = 0;
   for (const auto& g : g_) {
     const MetaCon& r = meta_con(g);
     if (r.type==OPTI_PSD) {
       for (casadi_int i=0;i<r.stop-r.start;++i) {
         index_all_to_g_[r.start+i] = -1;
       }
     } else {
       for (casadi_int i=0;i<r.stop-r.start;++i) {
         index_all_to_g_[r.start+i] = offset_g+i;
       }
       offset_g += r.canon.nnz();
     }
   }
  
   std::vector<MX> lam = active_symvar(OPTI_DUAL_G);
   for (casadi_int i=0;i<lam.size();++i) meta(lam[i]).active_i = i;
  
   lam_ = veccat(lam);
  
   // Collect bounds and canonical form of constraints
   std::vector<MX> g_all, g_unscaled_all;
   std::vector<MX> h_all, h_unscaled_all;
   std::vector<MX> lbg_all, lbg_unscaled_all;
   std::vector<MX> ubg_all, ubg_unscaled_all;
  
   g_linear_scale_.clear();
   h_linear_scale_.clear();
   std::vector<DM> g_linear_scale, h_linear_scale;
  
   equality_.clear();
   for (const auto& g : g_) {
     if (meta_con(g).type==OPTI_PSD) {
       h_all.push_back(meta_con(g).canon/meta_con(g).linear_scale);
       if (meta_con(g).canon.numel()==meta_con(g).linear_scale.numel()) {
         h_linear_scale.push_back(meta_con(g).linear_scale);
       } else {
         casadi_assert_dev(meta_con(g).linear_scale.numel()==1);
         h_linear_scale.push_back(DM::ones(meta_con(g).canon.sparsity())*meta_con(g).linear_scale);
       }
       h_unscaled_all.push_back(meta_con(g).canon);
     } else {
       g_all.push_back(meta_con(g).canon/meta_con(g).linear_scale);
       if (meta_con(g).canon.numel()==meta_con(g).linear_scale.numel()) {
         g_linear_scale.push_back(meta_con(g).linear_scale);
       } else {
         casadi_assert_dev(meta_con(g).linear_scale.numel()==1);
         g_linear_scale.push_back(DM::ones(meta_con(g).canon.sparsity())*meta_con(g).linear_scale);
       }
       g_unscaled_all.push_back(meta_con(g).canon);
       lbg_all.push_back(meta_con(g).lb/meta_con(g).linear_scale);
       lbg_unscaled_all.push_back(meta_con(g).lb);
       ubg_all.push_back(meta_con(g).ub/meta_con(g).linear_scale);
       ubg_unscaled_all.push_back(meta_con(g).ub);
  
       equality_.insert(equality_.end(),
         meta_con(g).canon.numel(),
         meta_con(g).type==OPTI_EQUALITY || meta_con(g).type==OPTI_GENERIC_EQUALITY);
     }
   }
  
   nlp_["g"] = veccat(g_all);
   g_linear_scale_ = veccat(g_linear_scale).nonzeros();
   nlp_unscaled_["g"] = veccat(g_unscaled_all);
   if (problem_type_=="conic") {
     nlp_["h"] = diagcat(h_all);
     nlp_unscaled_["h"] = diagcat(h_unscaled_all);
     h_linear_scale_ = veccat(h_linear_scale).nonzeros();
   }
  
   // Get scaling data
   std::vector<DM> linear_scale = active_values(OPTI_VAR, store_linear_scale_);
   std::vector<DM> linear_scale_offset = active_values(OPTI_VAR, store_linear_scale_offset_);
  
   linear_scale_ = veccat(linear_scale).nonzeros();
   linear_scale_offset_ = veccat(linear_scale_offset).nonzeros();
  
   // Unscaled version of x
   std::vector<MX> x_unscaled(x.size());
   for (casadi_int i=0;i<x.size();++i) {
     x_unscaled[i] = x[i]*linear_scale[i] + linear_scale_offset[i];
   }
  
   // Perform substitution
   std::vector<MX> expr = {nlp_["f"], nlp_["g"]};
   if (problem_type_=="conic") expr.push_back(nlp_["h"]);
   std::vector<MX> fgh = substitute(expr, x, x_unscaled);
   nlp_["f"] = fgh[0];
   nlp_["g"] = fgh[1];
   if (problem_type_=="conic") {
     nlp_["h"] = fgh[2];
   }
  
   // Scale of objective
   nlp_["f"] = nlp_["f"]/f_linear_scale_;
  
   // Create bounds helper function
   MXDict bounds;
   bounds["p"] = nlp_["p"];
   bounds_lbg_ = veccat(lbg_all);
   bounds_ubg_ = veccat(ubg_all);
   bounds_unscaled_lbg_ = veccat(lbg_unscaled_all);
   bounds_unscaled_ubg_ = veccat(ubg_unscaled_all);
  
   bounds["lbg"] = bounds_lbg_;
   bounds["ubg"] = bounds_ubg_;
  
   bounds_ = Function("bounds", bounds, {"p"}, {"lbg", "ubg"});
   mark_problem_dirty(false);
 }

References casadi::MetaVar::active_i, active_symvar(), active_values(), casadi::MetaCon::canon, casadi::MetaVar::count, casadi::MetaCon::dual_canon, g(), g_linear_scale(), casadi::GenericMatrix< MatType >::is_empty(), mark_problem_dirty(), casadi::GenericMatrix< MatType >::nnz(), casadi::GenericMatrix< MatType >::ones(), casadi::OPTI_DOMAIN_INTEGER, casadi::OPTI_DUAL_G, casadi::OPTI_EQUALITY, casadi::OPTI_GENERIC_EQUALITY, casadi::OPTI_PAR, casadi::OPTI_PSD, casadi::OPTI_VAR, p(), casadi::GenericMatrix< MatType >::size(), casadi::IndexAbstraction::start, casadi::IndexAbstraction::stop, symvar(), casadi::MetaCon::type, and x().

Referenced by solve(), and solver_construct().

◆ baked_copy()

OptiAdvanced casadi::OptiNode::baked_copy ( ) const

inline

Definition at line 216 of file optistack_internal.hpp.

                                   {
     OptiAdvanced s = copy();
     if (s.problem_dirty()) s.bake();
     return s;
   }

References casadi::OptiAdvanced::bake(), casadi::copy(), and casadi::OptiAdvanced::problem_dirty().

Referenced by casadi::OptiAdvanced::baked_copy(), describe(), g_describe(), g_lookup(), scale_helper(), to_function(), x_describe(), and x_lookup().

◆ callback_class() [1/2]

void casadi::OptiNode::callback_class ( )

Definition at line 104 of file optistack_internal.cpp.

                               {
   user_callback_ = nullptr;
 }

◆ callback_class() [2/2]

void casadi::OptiNode::callback_class ( OptiCallback * callback )

Definition at line 100 of file optistack_internal.cpp.

                                                     {
   user_callback_ = callback;
 }

◆ canon_expr()

MetaCon casadi::OptiNode::canon_expr	(	const MX &	expr,
		const DM &	linear_scale = `1`
	)		const

Definition at line 1035 of file optistack_internal.cpp.

                                                                          {
   MX c = expr;
  
   MetaCon con;
   con.original = expr;
   casadi_assert(linear_scale.is_scalar() || linear_scale.size()==expr.size(),
     "Linear scale must have the same size as the expression. "
     "You got linear_scale " + con.linear_scale.dim() + " while " + expr.dim() + " is expected.");
   con.linear_scale = linear_scale;
  
   if (c.is_op(OP_LE) || c.is_op(OP_LT)) { // Inequalities
     std::vector<MX> ret;
     bool flipped;
     std::vector<MX> args = ineq_unchain(c, flipped);
     std::vector<bool> parametric;
     for (auto &a : args) parametric.push_back(is_parametric(a));
  
     if (args.size()==2 && (parametric[0] || parametric[1])) {
       // case: g(x,p) <= bound(p)
       MX e = args[0]-args[1];
       if (e.is_vector()) {
         casadi_assert(!parametric[0] || !parametric[1],
           "Constraint must contain decision variables.");
         if (problem_type_=="conic") {
           if (args[0].op()==OP_NORMF || args[0].op()==OP_NORM2) {
             args[0] = -soc(args[0].dep(), args[1]);
             args[1] = 0;
           }
         } else {
           con.type = OPTI_INEQUALITY;
           if (parametric[0]) {
             con.lb = args[0]*DM::ones(e.sparsity());
             con.ub = inf*DM::ones(e.sparsity());
             con.canon = args[1]*DM::ones(e.sparsity());
           } else {
             con.lb = -inf*DM::ones(e.sparsity());
             con.ub = args[1]*DM::ones(e.sparsity());
             con.canon = args[0]*DM::ones(e.sparsity());
           }
           return con;
         }
       }
       // Fall through to generic inequalities
     } else if (args.size()==3 && parametric[0] && parametric[2]) {
       // lb(p) <= g(x,p) <= ub(p)
       con.type = OPTI_DOUBLE_INEQUALITY;
       con.lb = args[0]*DM::ones(args[1].sparsity());
       con.ub = args[2]*DM::ones(args[1].sparsity());
       con.canon = args[1]*DM::ones(args[1].sparsity());
       con.flipped = flipped;
       con.n = 2;
       return con;
     }
  
     bool type_known = false;
     for (casadi_int j=0;j<args.size()-1;++j) {
       MX e = args[j]-args[j+1];
       if (problem_type_=="conic") {
         if (args[j].op()==OP_NORMF || args[j].op()==OP_NORM2) {
           args[j] = -soc(args[j].dep(), args[j+1]);
           args[j+1] = 0;
           e = args[j]-args[j+1];
         }
       }
       if (e.is_vector()) {
         // g1(x,p) <= g2(x,p)
         ret.push_back(e);
         casadi_assert_dev(!type_known || con.type==OPTI_GENERIC_INEQUALITY);
         type_known = true;
         con.type = OPTI_GENERIC_INEQUALITY;
         con.flipped = flipped;
       } else {
         // A(x,p) >= b(p)
         MX a = args[j+1];
         MX b = args[j];
         e = a-b;
  
         casadi_assert(e.size1()==e.size2(),
           "Matrix inequalities must be square. Did you mean element-wise inequality instead?");
         if (a.is_scalar()) a*= MX::eye(e.size1());
         if (b.is_scalar()) b*= MX::eye(e.size1());
         e = a-b;
  
         ret.push_back(e);
         casadi_assert_dev(!type_known || con.type==OPTI_PSD);
         type_known = true;
         con.type = OPTI_PSD;
       }
     }
  
     if (con.type==OPTI_GENERIC_INEQUALITY) {
       con.canon = veccat(ret);
       con.lb = -inf*DM::ones(con.canon.sparsity());
       con.ub = DM::zeros(con.canon.sparsity());
       con.n = ret.size();
       if (!con.linear_scale.is_scalar()) {
         con.linear_scale = repmat(con.linear_scale, ret.size(), 1);
       }
     } else {
       con.canon = diagcat(ret);
       con.n = ret.size();
     }
     return con;
   } else if (c.is_op(OP_EQ)) { // Inequalities
     casadi_assert(!is_parametric(c.dep(0)) || !is_parametric(c.dep(1)),
       "Constraint must contain decision variables.");
     MX e = c.dep(0)-c.dep(1);
     if (is_parametric(c.dep(0))) {
       con.canon = c.dep(1)*DM::ones(e.sparsity());
       con.lb = c.dep(0)*DM::ones(e.sparsity());
       con.type = OPTI_EQUALITY;
       casadi_assert(c.dep(0).size1()<=c.dep(1).size1() && c.dep(0).size2()<=c.dep(1).size2(),
         "Constraint shape mismatch.");
     } else if (is_parametric(c.dep(1))) {
       con.canon = c.dep(0)*DM::ones(e.sparsity());
       con.lb = c.dep(1)*DM::ones(e.sparsity());
       con.type = OPTI_EQUALITY;
       casadi_assert(c.dep(1).size1()<=c.dep(0).size1() && c.dep(1).size2()<=c.dep(0).size2(),
         "Constraint shape mismatch.");
     } else {
       con.lb = DM::zeros(e.sparsity());
       con.canon = e;
       con.type = OPTI_GENERIC_EQUALITY;
     }
     con.ub = con.lb;
     return con;
   } else { // Something else
     con.type = OPTI_UNKNOWN;
     con.canon = c;
     return con;
   }
  
 }

Referenced by subject_to().

◆ casadi_solver()

Function casadi::OptiNode::casadi_solver ( ) const

Definition at line 562 of file optistack_internal.cpp.

                                        {
   return solver_;
 }

◆ class_name()

std::string casadi::OptiNode::class_name ( ) const

inlineoverridevirtual

Implements casadi::SharedObjectInternal.

Definition at line 222 of file optistack_internal.hpp.

222 { return "OptiNode"; }

◆ constraints()

std::vector<MX> casadi::OptiNode::constraints ( ) const

inline

Definition at line 213 of file optistack_internal.hpp.

213 { return g_; }

◆ copy()

Opti casadi::OptiNode::copy ( ) const

Definition at line 365 of file optistack_internal.cpp.

                           {
     return Opti::create(new OptiNode(*this));
 }

References casadi::Opti::create(), and OptiNode().

Referenced by casadi::Opti::copy(), and solve().

◆ create()

OptiNode * casadi::OptiNode::create ( const std::string & problem_type )

static

Definition at line 95 of file optistack_internal.cpp.

                                                         {
 return new OptiNode(problem_type);
 }

References OptiNode().

Referenced by casadi::Opti::Opti().

◆ debug_repr()

std::string casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::debug_repr ( const Internal * i ) const

inherited

Definition at line 62 of file generic_shared_internal.hpp.

                                                                                        {
     // Note: i != this because of something something multiple inheritance
     return str( (casadi_int)(i)) + "/" + static_cast<const Internal*>(this)->class_name();
   }

◆ describe()

std::string casadi::OptiNode::describe	(	const MX &	x,
		casadi_int	indent = `0`,
		const Dict &	opts = `Dict()`
	)		const

Definition at line 141 of file optistack_internal.cpp.

                                                                                       {
   if (problem_dirty()) return baked_copy().describe(expr, indent, opts);
   casadi_int max_stacktrace_depth = 1;
   for (const auto& op : opts) {
     if (op.first=="max_stacktrace_depth") {
       max_stacktrace_depth = op.second.as_int();
     } else {
       casadi_warning("Unknown option '" + op.first + "'");
     }
   }
   std::string s_indent;
   for (casadi_int i=0;i<indent;++i) {
     s_indent+= "  ";
   }
   std::string description = s_indent;
   if (expr.is_symbolic()) {
     if (has(expr)) {
       description += "Opti " + variable_type_to_string(meta(expr).type) + " '" + expr.name() +
         "' of shape " + expr.dim();
       const Dict& extra = meta(expr).extra;
       auto it = extra.find("stacktrace");
       if (it!=extra.end()) {
         for (const Dict& stacktrace : it->second.as_dict_vector()) {
           description += ", " + format_stacktrace(stacktrace, indent+1);
           if (--max_stacktrace_depth==0) break;
         }
       }
     } else {
       VariableType vt;
       if (parse_opti_name(expr.name(), vt)) {
         description += "Opti " + variable_type_to_string(vt) + " '" + expr.name() +
           "' of shape " + expr.dim()+
           ", belonging to a different instance of Opti.";
       } else {
         description += "MX symbol '" + expr.name() + "' of shape " + expr.dim();
         description += ", declared outside of Opti.";
       }
     }
   } else {
     if (has_con(expr)) {
       description = "Opti constraint of shape " + expr.dim();
       const Dict& extra = meta_con(expr).extra;
       auto it = extra.find("stacktrace");
       if (it!=extra.end()) {
         for (const Dict& stacktrace : it->second.as_dict_vector()) {
           description += ", " + format_stacktrace(stacktrace, indent+1);
           if (--max_stacktrace_depth==0) break;
         }
       }
     } else {
       std::vector<MX> s = symvar(expr);
       if (s.empty()) {
         description+= "Constant epxression.";
       } else {
         description+= "General expression, dependent on " + str(s.size()) + " symbols:";
         for (casadi_int i=0;i<s.size();++i) {
           description+= "\n"+describe(s[i], indent+1);
           if (i>5) {
             description+= "\n...";
             break;
           }
         }
       }
     }
   }
  
   return description;
 }

References baked_copy(), casadi::OptiAdvanced::describe(), casadi::description(), casadi::GenericMatrix< MatType >::dim(), casadi::MetaCon::extra, casadi::MetaVar::extra, casadi::MX::is_symbolic(), casadi::MX::name(), problem_dirty(), casadi::str(), and symvar().

Referenced by assert_active_symbol(), g_describe(), solve_prepare(), value(), and x_describe().

◆ destroySingleton()

void casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::destroySingleton ( )

inlineprotectedinherited

Called in the destructor of singletons

Definition at line 77 of file generic_shared_internal.hpp.

                             {
       static_cast<Internal*>(this)->count--;
     }

◆ disp()

void casadi::OptiNode::disp	(	std::ostream &	stream,
		bool	more = `false`
	)		const

overridevirtual

Implements casadi::SharedObjectInternal.

Definition at line 1733 of file optistack_internal.cpp.

                                                        {
  
 }

◆ dual()

MX casadi::OptiNode::dual ( const MX & m ) const

Definition at line 604 of file optistack_internal.cpp.

                                    {
   return meta_con(m).dual;
 }

References casadi::MetaCon::dual.

◆ f()

MX casadi::OptiNode::f ( ) const

inline

Definition at line 261 of file optistack_internal.hpp.

                {
     if (problem_dirty()) return baked_copy().f();
     return nlp_unscaled_.at("f");
   }

Referenced by minimize().

◆ f_linear_scale()

double casadi::OptiNode::f_linear_scale ( ) const

inline

Definition at line 294 of file optistack_internal.hpp.

                                 {
     if (problem_dirty()) return baked_copy().f_linear_scale();
     return f_linear_scale_;
   }

Referenced by scale_helper().

◆ g()

MX casadi::OptiNode::g ( ) const

inline

Definition at line 255 of file optistack_internal.hpp.

                {
     if (problem_dirty()) return baked_copy().g();
     return nlp_unscaled_.at("g");
   }

Referenced by bake(), show_infeasibilities(), solve_prepare(), solver_construct(), and subject_to().

◆ g_describe()

std::string casadi::OptiNode::g_describe	(	casadi_int	i,
		const Dict &	opts = `Dict()`
	)		const

Definition at line 210 of file optistack_internal.cpp.

                                                                    {
   if (problem_dirty()) return baked_copy().g_describe(i, opts);
   MX expr = g_lookup(i);
   casadi_int local_i = i-meta_con(expr).start + GlobalOptions::start_index;
   std::string description = describe(expr, 0, opts);
   if (expr.numel()>1)
     description += "\nAt nonzero " + str(local_i % expr.numel()) +
                    ", part " + str((casadi_int) local_i / expr.numel()) + ".";
   return description;
 }

References baked_copy(), describe(), casadi::description(), casadi::OptiAdvanced::g_describe(), g_lookup(), casadi::GenericMatrix< MatType >::numel(), problem_dirty(), casadi::IndexAbstraction::start, casadi::GlobalOptions::start_index, and casadi::str().

Referenced by show_infeasibilities().

◆ g_index_reduce_g()

casadi_int casadi::OptiNode::g_index_reduce_g ( casadi_int i ) const

Definition at line 517 of file optistack_internal.cpp.

                                                         {
   stats();
   return g_index_reduce_g_[i];
 }

References stats().

◆ g_index_reduce_x()

casadi_int casadi::OptiNode::g_index_reduce_x ( casadi_int i ) const

Definition at line 525 of file optistack_internal.cpp.

                                                         {
   stats();
   return g_index_reduce_x_[i];
 }

References stats().

◆ g_index_unreduce_g()

casadi_int casadi::OptiNode::g_index_unreduce_g ( casadi_int i ) const

Definition at line 521 of file optistack_internal.cpp.

                                                           {
   stats();
   return g_index_unreduce_g_[i];
 }

References stats().

◆ g_linear_scale()

DM casadi::OptiNode::g_linear_scale ( ) const

inline

Definition at line 290 of file optistack_internal.hpp.

                             {
     if (problem_dirty()) return baked_copy().g_linear_scale();
     return DM(g_linear_scale_);
   }

Referenced by bake(), and scale_helper().

◆ g_lookup()

MX casadi::OptiNode::g_lookup ( casadi_int i ) const

Definition at line 244 of file optistack_internal.cpp.

                                         {
   if (problem_dirty()) return baked_copy().g_lookup(i);
   casadi_assert_dev(i>=0);
   casadi_assert_dev(i<ng());
   for (const auto& e : g_) {
     const MetaCon& m = meta_con(e);
     if (i>=m.start && i<m.stop) return e;
   }
   casadi_error("Internal error");
   return MX();
 }

References baked_copy(), casadi::OptiAdvanced::g_lookup(), ng(), problem_dirty(), casadi::IndexAbstraction::start, and casadi::IndexAbstraction::stop.

Referenced by g_describe().

◆ get_meta()

MetaVar casadi::OptiNode::get_meta ( const MX & m ) const

Definition at line 632 of file optistack_internal.cpp.

                                             {
   return meta(m);
 }

Referenced by update_user_dict(), and user_dict().

◆ get_meta_con()

MetaCon casadi::OptiNode::get_meta_con ( const MX & m ) const

Definition at line 636 of file optistack_internal.cpp.

                                                 {
   return meta_con(m);
 }

Referenced by update_user_dict(), and user_dict().

◆ getCount()

casadi_int casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::getCount

inherited

Definition at line 60 of file generic_shared_internal.hpp.

                                                                      {
     return static_cast<const Internal*>(this)->count;
   }

◆ has_callback_class()

bool casadi::OptiNode::has_callback_class ( ) const

Definition at line 108 of file optistack_internal.cpp.

                                         {
   return user_callback_ != 0;
 }

◆ initial()

std::vector< MX > casadi::OptiNode::initial ( ) const

Definition at line 700 of file optistack_internal.cpp.

                                       {
   std::vector<MX> ret;
   for (const auto& e : symvar()) {
     if (meta(e).type==OPTI_VAR || meta(e).type==OPTI_DUAL_G)
       ret.push_back(e==store_initial_.at(meta(e).type)[meta(e).i]);
   }
   return ret;
 }

References casadi::OPTI_DUAL_G, casadi::OPTI_VAR, and symvar().

◆ initSingleton()

void casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::initSingleton ( )

inlineprotectedinherited

Called in the constructor of singletons to avoid that the counter reaches zero

Definition at line 71 of file generic_shared_internal.hpp.

                          {
       casadi_assert_dev(static_cast<Internal*>(this)->count==0);
       static_cast<Internal*>(this)->count++;
     }

◆ instance_number()

casadi_int casadi::OptiNode::instance_number ( ) const

Definition at line 1737 of file optistack_internal.cpp.

                                            {
     return instance_number_;
 }

◆ is_parametric()

bool casadi::OptiNode::is_parametric ( const MX & expr ) const

Definition at line 1031 of file optistack_internal.cpp.

                                                  {
   return symvar(expr, OPTI_VAR).empty();
 }

References casadi::OPTI_VAR, and symvar().

Referenced by canon_expr().

◆ lam_g()

MX casadi::OptiNode::lam_g ( ) const

inline

Definition at line 277 of file optistack_internal.hpp.

                    {
     if (problem_dirty()) return baked_copy().lam_g();
     return lam_;
   }

Referenced by to_function().

◆ lbg()

MX casadi::OptiNode::lbg ( ) const

inline

Definition at line 266 of file optistack_internal.hpp.

                  {
     if (problem_dirty()) return baked_copy().lbg();
     return bounds_unscaled_lbg_;
   }

Referenced by show_infeasibilities().

◆ mark_problem_dirty()

void casadi::OptiNode::mark_problem_dirty ( bool flag = true )

inline

Definition at line 322 of file optistack_internal.hpp.

322 { problem_dirty_=flag; mark_solver_dirty(); }

casadi::OptiNode::problem_dirty_

bool problem_dirty_

Definition: optistack_internal.hpp:321

casadi::OptiNode::mark_solver_dirty

void mark_solver_dirty(bool flag=true)

Definition: optistack_internal.hpp:326

Referenced by bake(), minimize(), OptiNode(), set_domain(), and subject_to().

◆ mark_solved()

void casadi::OptiNode::mark_solved ( bool flag = true )

inline

Definition at line 330 of file optistack_internal.hpp.

330 { solved_ = flag;}

casadi::OptiNode::solved_

bool solved_

Definition: optistack_internal.hpp:329

Referenced by res(), and set_domain().

◆ mark_solver_dirty()

void casadi::OptiNode::mark_solver_dirty ( bool flag = true )

inline

Definition at line 326 of file optistack_internal.hpp.

326 { solver_dirty_=flag; mark_solved(false); }

casadi::OptiNode::solver_dirty_

bool solver_dirty_

Definition: optistack_internal.hpp:325

casadi::OptiNode::mark_solved

void mark_solved(bool flag=true)

Definition: optistack_internal.hpp:330

Referenced by solve(), and solver().

◆ minimize()

void casadi::OptiNode::minimize	(	const MX &	f,
		double	linear_scale = `1`
	)

Definition at line 1186 of file optistack_internal.cpp.

                                                         {
   assert_only_opti_nondual(f);
   mark_problem_dirty();
   casadi_assert(f.is_scalar(), "Objective must be scalar, got " + f.dim() + ".");
   f_ = f;
   f_linear_scale_ = linear_scale;
 }

References casadi::GenericMatrix< MatType >::dim(), f(), casadi::GenericMatrix< MatType >::is_scalar(), and mark_problem_dirty().

◆ ng()

casadi_int casadi::OptiNode::ng ( ) const

inline

Definition at line 237 of file optistack_internal.hpp.

                         {
     if (problem_dirty()) return baked_copy().ng();
     return nlp_.at("g").size1();
   }

Referenced by g_lookup(), scale_helper(), and stats().

◆ np()

casadi_int casadi::OptiNode::np ( ) const

inline

Definition at line 231 of file optistack_internal.hpp.

                         {
     if (problem_dirty()) return baked_copy().np();
     return nlp_.at("p").size1();
   }

Referenced by scale_helper().

◆ nx()

casadi_int casadi::OptiNode::nx ( ) const

inline

Definition at line 225 of file optistack_internal.hpp.

                         {
     if (problem_dirty()) return baked_copy().nx();
     return nlp_.at("x").size1();
   }

Referenced by scale_helper(), and x_lookup().

◆ objective()

MX casadi::OptiNode::objective ( ) const

inline

Definition at line 214 of file optistack_internal.hpp.

214 { return f_; }

◆ p()

MX casadi::OptiNode::p ( ) const

inline

Definition at line 249 of file optistack_internal.hpp.

                {
     if (problem_dirty()) return baked_copy().p();
     return nlp_.at("p");
   }

Referenced by bake(), to_function(), and value().

◆ parameter() [1/3]

MX casadi::OptiNode::parameter	(	casadi_int	n = `1`,
		casadi_int	m = `1`,
		const std::string &	attribute = `"full"`
	)

Definition at line 461 of file optistack_internal.cpp.

                                                                              {
   casadi_assert_dev(attribute=="full");
  
   // Prepare metadata
   MetaVar meta_data;
   meta_data.attribute = attribute;
   meta_data.n = n;
   meta_data.m = m;
   meta_data.type = OPTI_PAR;
   meta_data.count = count_++;
   meta_data.i = count_par_++;
  
   MX symbol = MX::sym(name_prefix() + "p_" + str(count_par_), n, m);
   symbols_.push_back(symbol);
   store_initial_[OPTI_PAR].push_back(DM::nan(symbol.sparsity()));
  
   set_meta(symbol, meta_data);
   return symbol;
 }

References casadi::MetaVar::attribute, casadi::MetaVar::count, casadi::MetaVar::i, casadi::MetaVar::m, casadi::MetaVar::n, casadi::Matrix< double >::nan(), casadi::OPTI_PAR, set_meta(), casadi::MX::sparsity(), casadi::str(), casadi::GenericMatrix< MX >::sym(), and casadi::MetaVar::type.

◆ parameter() [2/3]

MX casadi::OptiNode::parameter	(	const MX &	symbol,
		const std::string &	attribute = `"full"`
	)

Definition at line 422 of file optistack_internal.cpp.

                                                                    {
   casadi_assert_dev(attribute=="full");
  
   // Prepare metadata
   MetaVar meta_data;
   meta_data.attribute = attribute;
   meta_data.n = symbol.size1();
   meta_data.m = symbol.size2();
   meta_data.type = OPTI_PAR;
   meta_data.count = count_++;
   meta_data.i = count_par_++;
  
   symbols_.push_back(symbol);
   store_initial_[OPTI_PAR].push_back(DM::nan(symbol.sparsity()));
  
   set_meta(symbol, meta_data);
   return symbol;
 }

References casadi::MetaVar::attribute, casadi::MetaVar::count, casadi::MetaVar::i, casadi::MetaVar::m, casadi::MetaVar::n, casadi::Matrix< double >::nan(), casadi::OPTI_PAR, set_meta(), casadi::GenericMatrix< MatType >::size1(), casadi::GenericMatrix< MatType >::size2(), casadi::MX::sparsity(), and casadi::MetaVar::type.

◆ parameter() [3/3]

MX casadi::OptiNode::parameter	(	const Sparsity &	sp,
		const std::string &	attribute = `"full"`
	)

Definition at line 441 of file optistack_internal.cpp.

                                                                      {
   casadi_assert_dev(attribute=="full");
  
   // Prepare metadata
   MetaVar meta_data;
   meta_data.attribute = attribute;
   meta_data.n = sp.size1();
   meta_data.m = sp.size2();
   meta_data.type = OPTI_PAR;
   meta_data.count = count_++;
   meta_data.i = count_par_++;
  
   MX symbol = MX::sym(name_prefix() + "p_" + str(count_par_), sp);
   symbols_.push_back(symbol);
   store_initial_[OPTI_PAR].push_back(DM::nan(symbol.sparsity()));
  
   set_meta(symbol, meta_data);
   return symbol;
 }

References casadi::MetaVar::attribute, casadi::MetaVar::count, casadi::MetaVar::i, casadi::MetaVar::m, casadi::MetaVar::n, casadi::Matrix< double >::nan(), casadi::OPTI_PAR, set_meta(), casadi::Sparsity::size1(), casadi::Sparsity::size2(), casadi::MX::sparsity(), casadi::str(), casadi::GenericMatrix< MX >::sym(), and casadi::MetaVar::type.

◆ problem_dirty()

bool casadi::OptiNode::problem_dirty ( ) const

inline

Definition at line 323 of file optistack_internal.hpp.

323 { return problem_dirty_; }

Referenced by assert_baked(), describe(), g_describe(), g_lookup(), scale_helper(), solve(), solver_construct(), to_function(), x_describe(), and x_lookup().

◆ res() [1/2]

DMDict casadi::OptiNode::res ( ) const

inline

Definition at line 212 of file optistack_internal.hpp.

212 { return res_; }

Referenced by res(), scale_helper(), solve(), solve_prepare(), and to_function().

◆ res() [2/2]

void casadi::OptiNode::res ( const DMDict & res )

Definition at line 1241 of file optistack_internal.cpp.

                                     {
   const std::vector<double> & x_v = res.at("x").nonzeros();
   for (const auto &v : active_symvar(OPTI_VAR)) {
     casadi_int i = meta(v).i;
     std::vector<double> & data_v = store_latest_[OPTI_VAR][i].nonzeros();
     for (casadi_int i=0;i<data_v.size();++i) {
       casadi_int j = meta(v).start+i;
       data_v[i] = x_v[j]*linear_scale_[j] + linear_scale_offset_[j];
     }
   }
   if (res.find("lam_g")!=res.end()) {
     const std::vector<double> & lam_v = res.at("lam_g").nonzeros();
     for (const auto &v : active_symvar(OPTI_DUAL_G)) {
       casadi_int i = meta(v).i;
       std::vector<double> & data_v = store_latest_[OPTI_DUAL_G][i].nonzeros();
       for (casadi_int i=0;i<data_v.size();++i) {
         casadi_int j = meta(v).start+i;
         j = index_all_to_g_.at(j);
         if (j<0) continue;
         data_v[i] = lam_v.at(j)/g_linear_scale_.at(j)*f_linear_scale_;
       }
     }
   }
   res_ = res;
   mark_solved();
 }

References active_symvar(), casadi::MetaVar::i, mark_solved(), casadi::OPTI_DUAL_G, casadi::OPTI_VAR, res(), and casadi::IndexAbstraction::start.

◆ return_status()

std::string casadi::OptiNode::return_status ( ) const

Definition at line 530 of file optistack_internal.cpp.

                                         {
   Dict mystats;
   try {
     mystats = stats();
   } catch (...) {
     //
   }
   if (mystats.find("return_status")!=mystats.end()) {
     std::stringstream ss;
     ss << mystats.at("return_status");
     return ss.str();
   }
   return "unknown";
 }

References stats().

Referenced by solve().

◆ return_success()

bool casadi::OptiNode::return_success ( bool accept_limit ) const

Definition at line 545 of file optistack_internal.cpp.

                                                      {
   Dict mystats;
   try {
     mystats = stats();
   } catch (...) {
     //
   }
   bool success = false;
   if (mystats.find("success")!=mystats.end()) success = mystats.at("success");
   if (!accept_limit) return success;
  
   bool limited = false;
   if (mystats.find("unified_return_status")!=mystats.end())
     limited = mystats.at("unified_return_status")=="SOLVER_RET_LIMITED";
   return success || limited;
 }

References stats().

Referenced by solve().

◆ scale_helper()

Function casadi::OptiNode::scale_helper ( const Function & h ) const

Extra doc: https://github.com/casadi/casadi/wiki/L_2cd

Definition at line 899 of file optistack_internal.cpp.

                                                        {
   if (problem_dirty()) return baked_copy().scale_helper(h);
   std::string name = h.name();
   MX g_linear_scale_mx = g_linear_scale();
   MX g_linear_scale_inv = 1/g_linear_scale();
   MX f_linear_scale_mx = f_linear_scale();
   MX x_linear_scale_mx = x_linear_scale();
   MX x_linear_scale_offset_mx = x_linear_scale_offset();
   if (name=="nlp_jac_g") {
     MXDict arg;
     arg["x"] = MX::sym("x", nx());
     arg["p"] = MX::sym("p", np());
     MXDict args;
     args["x"] = arg["x"]*x_linear_scale_mx+x_linear_scale_offset_mx;
     args["p"] = arg["p"];
     MXDict res = h(args);
     for (const auto & it : res) {
       if (it.first=="g") {
         arg[it.first] = it.second*g_linear_scale_inv;
       } else if (it.first=="jac_g_x") {
         arg[it.first] = mtimes(
                           mtimes(diag(g_linear_scale_inv), it.second),
                           diag(x_linear_scale_mx));
       } else {
         casadi_error("Unknown output '" + it.first + "'. Expecting g, jac_g_x.");
       }
     }
     Function ret(name, arg, h.name_in(), h.name_out());
     return ret;
   } else if (name=="nlp_hess_l") {
     MXDict arg;
     arg["x"] = MX::sym("x", nx());
     arg["p"] = MX::sym("p", np());
     arg["lam_f"] = MX::sym("lam_f");
     arg["lam_g"] = MX::sym("lam_g", ng());
     MXDict args;
     args["x"] = arg["x"]*x_linear_scale_mx+x_linear_scale_offset_mx;
     args["p"] = arg["p"];
     args["lam_f"] = arg["lam_f"]/f_linear_scale_mx;
     args["lam_g"] = arg["lam_g"]/g_linear_scale_mx;
     MXDict res = h(args);
     for (const auto & it : res) {
       if (it.first=="triu_hess_gamma_x_x" ||
           it.first=="hess_gamma_x_x" ||
           (it.second.size1()==nx() && it.second.is_square())) {
         MX D = diag(x_linear_scale_mx);
         arg[it.first] = mtimes(mtimes(D, it.second), D);
       } else {
         casadi_error("Unknown output '" + it.first + "'. Expecting triu_hess_gamma_x_x");
       }
     }
     Function ret(name, arg, h.name_in(), h.name_out());
     return ret;
   } else {
     casadi_error("Unknown helper function '" + name + "'");
   }
 }

References arg(), baked_copy(), casadi::D, f_linear_scale(), g_linear_scale(), casadi::Function::name(), casadi::Function::name_in(), casadi::Function::name_out(), ng(), np(), nx(), problem_dirty(), res(), casadi::Opti::scale_helper(), casadi::GenericMatrix< MX >::sym(), x_linear_scale(), and x_linear_scale_offset().

◆ set_domain()

void casadi::OptiNode::set_domain	(	const MX &	x,
		const std::string &	domain
	)

Definition at line 1499 of file optistack_internal.cpp.

                                                               {
   mark_solved(false);
   mark_problem_dirty();
   casadi_assert(x.is_valid_input(), "First argument to set_domain should be a variable.");
   DomainType type;
   if (domain=="real") {
     type = OPTI_DOMAIN_REAL;
   } else if (domain=="integer") {
     type = OPTI_DOMAIN_INTEGER;
   } else {
     casadi_error("Unknown domain '" + domain + "'. Known values are 'real', 'integer'.");
   }
   for (const auto& prim : x.primitives()) {
     MetaVar& m = meta(prim);
     m.domain = type;
   }
 }

References casadi::MetaVar::domain, casadi::MX::is_valid_input(), mark_problem_dirty(), mark_solved(), casadi::OPTI_DOMAIN_INTEGER, casadi::OPTI_DOMAIN_REAL, casadi::MX::primitives(), and x().

◆ set_initial() [1/2]

void casadi::OptiNode::set_initial	(	const MX &	x,
		const DM &	v
	)

Set initial value for decision variables

Definition at line 1614 of file optistack_internal.cpp.

                                                    {
   for (const auto & s : MX::symvar(x))
     casadi_assert(meta(s).type!=OPTI_PAR,
       "You cannot set an initial value for a parameter. Did you mean 'set_value'?");
   set_value_internal(x, v, store_initial_);
 }

References casadi::OPTI_PAR, casadi::MX::symvar(), and x().

Referenced by set_initial().

◆ set_initial() [2/2]

void casadi::OptiNode::set_initial ( const std::vector< MX > & assignments )

Set initial value for decision variables

Definition at line 1490 of file optistack_internal.cpp.

                                                            {
   for (const auto& v : assignments) {
     casadi_assert_dev(v.is_op(OP_EQ));
     casadi_assert_dev(v.dep(0).is_constant());
     if (has(v.dep(1)))
       set_initial(v.dep(1), static_cast<DM>(v.dep(0)));
   }
 }

References casadi::OP_EQ, and set_initial().

◆ set_linear_scale()

void casadi::OptiNode::set_linear_scale	(	const MX &	x,
		const DM &	scale,
		const DM &	offset
	)

Definition at line 1628 of file optistack_internal.cpp.

                                                                               {
   for (const auto & s : MX::symvar(x))
     casadi_assert(meta(s).type!=OPTI_PAR,
       "You cannot set a scale value for a parameter.");
   casadi_assert(scale.is_scalar() || scale.size()==x.size(),
       "Dimension mismatch in linear_scale. Expected " + x.dim() + ", got " + scale.dim()+ ".");
   set_value_internal(x, scale, store_linear_scale_);
   casadi_assert(offset.is_scalar() || offset.size()==x.size(),
       "Dimension mismatch in linear_scale offset. Expected " + x.dim() +
       ", got " + scale.dim()+ ".");
   set_value_internal(x, offset, store_linear_scale_offset_);
 }

References casadi::GenericMatrix< MatType >::dim(), casadi::GenericMatrix< MatType >::is_scalar(), casadi::OPTI_PAR, casadi::GenericMatrix< MatType >::size(), casadi::MX::symvar(), and x().

◆ set_meta()

void casadi::OptiNode::set_meta	(	const MX &	m,
		const MetaVar &	meta
	)

Definition at line 566 of file optistack_internal.cpp.

                                                         {
   meta_[m.get()] = meta;
 }

References casadi::MX::get().

Referenced by parameter(), update_user_dict(), and variable().

◆ set_meta_con()

void casadi::OptiNode::set_meta_con	(	const MX &	m,
		const MetaCon &	meta
	)

Definition at line 570 of file optistack_internal.cpp.

                                                             {
   meta_con_[m.get()] = meta;
 }

References casadi::MX::get().

Referenced by subject_to(), and update_user_dict().

◆ set_value() [1/2]

void casadi::OptiNode::set_value	(	const MX &	x,
		const DM &	v
	)

Each parameter must be given a value before 'solve' can be called

Extra doc: https://github.com/casadi/casadi/wiki/L_173

Definition at line 1621 of file optistack_internal.cpp.

                                                  {
   for (const auto & s : MX::symvar(x))
     casadi_assert(meta(s).type!=OPTI_VAR,
       "You cannot set a value for a variable. Did you mean 'set_initial'?");
   set_value_internal(x, v, store_initial_);
 }

References casadi::OPTI_VAR, casadi::MX::symvar(), and x().

Referenced by set_value().

◆ set_value() [2/2]

void casadi::OptiNode::set_value ( const std::vector< MX > & assignments )

Each parameter must be given a value before 'solve' can be called

Extra doc: https://github.com/casadi/casadi/wiki/L_173

Definition at line 1517 of file optistack_internal.cpp.

                                                          {
   for (const auto& v : assignments) {
     casadi_assert_dev(v.is_op(OP_EQ));
     casadi_assert_dev(v.dep(0).is_constant());
     if (has(v.dep(1)))
       set_value(v.dep(1), static_cast<DM>(v.dep(0)));
   }
 }

References casadi::OP_EQ, and set_value().

◆ shared_from_this() [1/2]

B casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::shared_from_this ( )

inlineprotectedinherited

Definition at line 83 of file generic_shared_internal.hpp.

                          {
       casadi_assert_dev(B::test_cast(static_cast<Internal*>(this)));
       B ret;
       ret.own(static_cast<Internal*>(this));
       return ret;
     }

◆ shared_from_this() [2/2]

const B casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::shared_from_this ( ) const

inlineprotectedinherited

Definition at line 92 of file generic_shared_internal.hpp.

                                      {
       casadi_assert_dev(B::test_cast(static_cast<const Internal*>(this)));
       B ret;
       ret.own(const_cast<Internal*>(static_cast<const Internal*>(this)));
       return ret;
     }

◆ show_infeasibilities()

void casadi::OptiNode::show_infeasibilities	(	double	tol = `0`,
		const Dict &	opts = `Dict()`
	)		const

Definition at line 1741 of file optistack_internal.cpp.

                                                                       {
   stats();
   std::vector<double> lbg_ = value(lbg()).get_elements();
   std::vector<double> ubg_ = value(ubg()).get_elements();
   std::vector<double> g_scaled_ = value(nlp_.at("g"), std::vector<MX>(), true).get_elements();
   std::vector<double> lbg_scaled_ = value(bounds_lbg_, std::vector<MX>(), true).get_elements();
   std::vector<double> ubg_scaled_ = value(bounds_ubg_, std::vector<MX>(), true).get_elements();
  
  
   std::vector<double> g_ = value(g()).get_elements();
   uout() << "Violated constraints (tol " << tol << "), in order of declaration:" << std::endl;
  
   for (casadi_int i=0;i<g_.size();++i) {
     double err = std::max(g_[i]-ubg_[i], lbg_[i]-g_[i]);
     double err_scaled = std::max(g_scaled_[i]-ubg_scaled_[i], lbg_scaled_[i]-g_scaled_[i]);
     if (err>=tol) {
       uout() << "------- i = " << i+GlobalOptions::start_index;
       uout() << "/" << g_.size();
  
       if (reduced_) {
         if (is_simple_[i]) {
           if (GlobalOptions::start_index==0) {
             uout() << "  reduced to bound on x[" << g_index_reduce_x_.at(i) << "]";
           } else {
             uout() << "  reduced to bound on x(" << g_index_reduce_x_.at(i)+1 << ")";
           }
         } else {
           uout() << "  reduced to g[" << g_index_reduce_g_.at(i) << "]";
         }
       }
  
       uout() << " ------ " << std::endl;
       uout() << lbg_[i] << " <= " << g_[i] << " <= " << ubg_[i];
       uout() << " (viol " << err << ")" << std::endl;
       if (g_[i]!=g_scaled_[i]) {
         uout() << lbg_scaled_[i] << " <= " << g_scaled_[i] << " <= " << ubg_scaled_[i];
         uout() << " (scaled) (viol " << err_scaled << ")" << std::endl;
       }
       uout() << g_describe(i, opts) << std::endl;
     }
   }
 }

References g(), g_describe(), casadi::Matrix< Scalar >::get_elements(), lbg(), casadi::GlobalOptions::start_index, stats(), ubg(), casadi::uout(), and value().

◆ solve()

OptiSol casadi::OptiNode::solve ( bool accept_limit )

Definition at line 1320 of file optistack_internal.cpp.

                                          {
  
   if (problem_dirty()) {
     bake();
   }
  
   bool solver_update =  solver_dirty() || old_callback() || (user_callback_ && callback_.is_null());
  
   if (solver_update) {
     solver_ = solver_construct(true);
     mark_solver_dirty(false);
   }
  
   solve_prepare();
   res(solve_actual(arg_));
  
   std::string ret = return_status();
  
   casadi_assert(return_success(accept_limit),
     "Solver failed. You may use opti.debug.value to investigate the latest values of variables."
     " return_status is '" + ret + "'");
  
   return copy();
 }

References bake(), copy(), casadi::GenericShared< Shared, Internal >::is_null(), mark_solver_dirty(), problem_dirty(), res(), return_status(), return_success(), solve_actual(), solve_prepare(), solver_construct(), and solver_dirty().

◆ solve_actual()

DMDict casadi::OptiNode::solve_actual ( const DMDict & args )

Definition at line 1385 of file optistack_internal.cpp.

                                                {
   return solver_(arg);
 }

References arg().

Referenced by solve().

◆ solve_prepare()

void casadi::OptiNode::solve_prepare ( )

Definition at line 1346 of file optistack_internal.cpp.

                              {
  
  
   // Verify the constraint types
   for (const auto& g : g_) {
     if (meta_con(g).type==OPTI_UNKNOWN)
      casadi_error("Constraint type unknown. Use ==, >= or <= .");
   }
  
   if (user_callback_) {
     InternalOptiCallback* cb = static_cast<InternalOptiCallback*>(callback_.get());
     cb->reset();
   }
  
   // Get initial guess and parameter values
   arg_["x0"]     = (veccat(active_values(OPTI_VAR))-linear_scale_offset_)/linear_scale_;
   arg_["p"]      = veccat(active_values(OPTI_PAR));
   arg_["lam_g0"] = veccat(active_values(OPTI_DUAL_G));
   if (!arg_["p"].is_regular()) {
     std::vector<MX> s = active_symvar(OPTI_PAR);
     std::vector<DM> v = active_values(OPTI_PAR);
     for (casadi_int i=0;i<s.size();++i) {
       casadi_assert(v[i].is_regular(),
         "You have forgotten to assign a value to a parameter ('set_value'), "
         "or have set it to NaN/Inf:\n" + describe(s[i], 1));
     }
   }
  
  
   // Evaluate bounds for given parameter values
   DMDict arg;
   arg["p"] = arg_["p"];
   DMDict res = bounds_(arg);
   arg_["lbg"] = res["lbg"];
   arg_["ubg"] = res["ubg"];
  
   stats_.clear();
 }

References active_symvar(), active_values(), arg(), describe(), g(), casadi::Function::get(), InternalOptiCallback, casadi::is_regular(), casadi::OPTI_DUAL_G, casadi::OPTI_PAR, casadi::OPTI_UNKNOWN, casadi::OPTI_VAR, and res().

Referenced by solve().

◆ solved()

bool casadi::OptiNode::solved ( ) const

inline

Definition at line 331 of file optistack_internal.hpp.

331 { return solved_; }

Referenced by assert_solved().

◆ solver()

void casadi::OptiNode::solver	(	const std::string &	solver,
		const Dict &	plugin_options = `Dict()`,
		const Dict &	solver_options = `Dict()`
	)

Definition at line 957 of file optistack_internal.cpp.

                                                    {
   solver_name_ = solver_name;
   solver_options_ = plugin_options;
   if (!solver_options.empty())
     solver_options_[solver_name] = solver_options;
   mark_solver_dirty();
 }

References mark_solver_dirty().

Referenced by to_function().

◆ solver_construct()

Function casadi::OptiNode::solver_construct ( bool callback = true )

Definition at line 1274 of file optistack_internal.cpp.

                                                  {
   if (problem_dirty()) {
     bake();
   }
  
   // Verify the constraint types
   for (const auto& g : g_) {
     if (problem_type_!="conic") {
       if (meta_con(g).type==OPTI_PSD)
         casadi_error("Psd constraints not implemented yet. "
         "Perhaps you intended an element-wise inequality? "
         "In that case, make sure that the matrix is flattened (e.g. mat(:)).");
     }
   }
  
   Dict solver_options_all = solver_options_;
  
   if (solver_options_all.find("equality")==solver_options_all.end()) {
     solver_options_all["equality"] = equality_;
   }
  
   if (solver_options_all.find("discrete")==solver_options_all.end()) {
     solver_options_all["discrete"] = discrete_;
   }
  
   Dict opts = solver_options_all;
  
   // Handle callbacks
   if (callback && user_callback_) {
     callback_ = Function::create(new InternalOptiCallback(*this), Dict());
     opts["iteration_callback"] = callback_;
   }
  
   casadi_assert(!solver_name_.empty(),
     "You must call 'solver' on the Opti stack to select a solver. "
     "Suggestion: opti.solver('ipopt')");
  
   if (problem_type_=="conic") {
     return qpsol("solver", solver_name_, nlp_, opts);
   } else {
     return nlpsol("solver", solver_name_, nlp_, opts);
   }
  
 }

References bake(), casadi::Function::create(), g(), InternalOptiCallback, casadi::nlpsol(), casadi::OPTI_PSD, problem_dirty(), and casadi::qpsol().

Referenced by solve(), and to_function().

◆ solver_dirty()

bool casadi::OptiNode::solver_dirty ( ) const

inline

Definition at line 327 of file optistack_internal.hpp.

327 { return solver_dirty_; }

Referenced by solve().

◆ stats()

Dict casadi::OptiNode::stats ( ) const

Definition at line 481 of file optistack_internal.cpp.

                            {
   assert_solved();
   if (stats_.empty()) {
     stats_ = solver_.stats();
     is_simple_ = get_from_dict(stats_,
       "detect_simple_bounds_is_simple",
       std::vector<bool>(ng(), false));
     target_x_ = get_from_dict(stats_,
       "detect_simple_bounds_target_x",
       std::vector<casadi_int>{});
     casadi_assert_dev(is_simple_.size()==ng());
  
     g_index_reduce_g_.resize(ng());
     g_index_reduce_x_.resize(ng(), -1);
     g_index_unreduce_g_.resize(ng(), -1);
  
     casadi_int* target_x_ptr = target_x_.data();
  
     casadi_int k=0;
     for (casadi_int i=0;i<is_simple_.size();++i) {
       if (!is_simple_[i]) {
         g_index_reduce_g_[i] = k;
         g_index_unreduce_g_[k] = i;
         k++;
       } else {
         g_index_reduce_g_[i] = -1;
         g_index_reduce_x_[i] = *target_x_ptr;
         target_x_ptr++;
       }
     }
  
     reduced_ = any(is_simple_);
   }
   return stats_;
 }

References casadi::any(), assert_solved(), casadi::get_from_dict(), ng(), and casadi::Function::stats().

Referenced by g_index_reduce_g(), g_index_reduce_x(), g_index_unreduce_g(), return_status(), return_success(), and show_infeasibilities().

◆ subject_to() [1/2]

void casadi::OptiNode::subject_to ( )

Definition at line 1224 of file optistack_internal.cpp.

                           {
   mark_problem_dirty();
   g_.clear();
   store_initial_[OPTI_DUAL_G].clear();
   store_latest_[OPTI_DUAL_G].clear();
   count_dual_ = 0;
 }

References mark_problem_dirty(), and casadi::OPTI_DUAL_G.

◆ subject_to() [2/2]

void casadi::OptiNode::subject_to	(	const MX &	g,
		const DM &	linear_scale = `1`,
		const Dict &	options = `Dict()`
	)

Definition at line 1194 of file optistack_internal.cpp.

                                                                                   {
   assert_only_opti_nondual(g);
   mark_problem_dirty();
   g_.push_back(g);
  
   casadi_assert(!g.is_empty(),    "You passed an empty expression to `subject_to`. "
                                   "Make sure the number of rows and columns is non-zero. "
                                   "Got " + g.dim(true) + ".");
   casadi_assert(g.nnz()>0,        "You passed a fully sparse expression to `subject_to`. "
                                   "Make sure the expression has at least one nonzero. "
                                   "Got " + g.dim(true) + ".");
   casadi_assert(!g.is_constant(), "You passed a constant to `subject_to`. "
                                   "You need a symbol to form a constraint.");
  
   // Store the meta-data
   set_meta_con(g, canon_expr(g, linear_scale));
   register_dual(meta_con(g));
  
   for (auto && it : options) {
     if (it.first=="stacktrace") {
       meta_con(g).extra["stacktrace"] = it.second.to_dict_vector();
       meta(meta_con(g).dual_canon).extra["stacktrace"] = it.second.to_dict_vector();
     } else if (it.first=="meta") {
       update_user_dict(g, it.second.to_dict());
     } else {
       casadi_error("Unknown option: " + it.first);
     }
   }
 }

References canon_expr(), casadi::GenericMatrix< MatType >::dim(), casadi::MetaCon::extra, casadi::MetaVar::extra, g(), casadi::MX::is_constant(), casadi::GenericMatrix< MatType >::is_empty(), mark_problem_dirty(), casadi::GenericMatrix< MatType >::nnz(), set_meta_con(), and update_user_dict().

◆ symvar() [1/4]

std::vector< MX > casadi::OptiNode::symvar ( ) const

Get symbols present in expression

Definition at line 981 of file optistack_internal.cpp.

                                      {
   return symbols_;
 }

Referenced by bake(), describe(), initial(), is_parametric(), symvar(), value(), value_parameters(), and value_variables().

◆ symvar() [2/4]

std::vector< MX > casadi::OptiNode::symvar ( const MX & expr ) const

Get symbols present in expression

Definition at line 985 of file optistack_internal.cpp.

                                                    {
   return sort(MX::symvar(expr));
 }

References casadi::MX::symvar().

◆ symvar() [3/4]

std::vector< MX > casadi::OptiNode::symvar	(	const MX &	expr,
		VariableType	type
	)		const

Get symbols present in expression

Definition at line 1232 of file optistack_internal.cpp.

                                                                       {
   std::vector<MX> ret;
   for (const auto& d : symvar(expr)) {
     if (meta(d).type==type) ret.push_back(d);
   }
  
   return ret;
 }

References symvar().

◆ symvar() [4/4]

std::vector< MX > casadi::OptiNode::symvar ( VariableType type ) const

Definition at line 1651 of file optistack_internal.cpp.

                                                       {
   if (symbols_.empty()) return std::vector<MX>{};
   std::vector<MX> ret;
   for (const auto& s : symbols_) {
     if (meta(s).type==type)
       ret.push_back(s);
   }
   return ret;
 }

◆ to_function()

Function casadi::OptiNode::to_function	(	const std::string &	name,
		const std::vector< MX > &	args,
		const std::vector< MX > &	res,
		const std::vector< std::string > &	name_in,
		const std::vector< std::string > &	name_out,
		const Dict &	opts
	)

Extra doc: https://github.com/casadi/casadi/wiki/L_174

Definition at line 1677 of file optistack_internal.cpp.

                       {
   if (problem_dirty()) return baked_copy().to_function(name, args, res, name_in, name_out, opts);
  
   Function solver = solver_construct(false);
  
   // Get initial guess and parameter values
   std::vector<MX> x0, p, lam_g;
   assign_vector(active_values(OPTI_VAR), x0);
   assign_vector(active_values(OPTI_PAR), p);
   assign_vector(active_values(OPTI_DUAL_G), lam_g);
  
   casadi_int k = 0;
   for (const auto& a : args) {
     casadi_assert(a.is_valid_input(), "Argument " + str(k) + " is not purely symbolic.");
     k++;
     for (const auto& prim : a.primitives()) {
       if (!symbol_active_[meta(prim).count]) continue;
       casadi_int i = meta(prim).active_i;
       if (meta(prim).type==OPTI_VAR) {
         x0.at(i) = prim;
       } else if (meta(prim).type==OPTI_PAR) {
         p.at(i) = prim;
       } else if (meta(prim).type==OPTI_DUAL_G) {
         lam_g.at(i) = prim;
       } else {
         casadi_error("Unknown");
       }
     }
   }
   MXDict arg;
   arg["p"] = veccat(p);
  
   // Evaluate bounds for given parameter values
   MXDict r = bounds_(arg);
   arg["x0"] = veccat(x0);
   arg["lam_g0"] = veccat(lam_g);
   arg["lbg"] = r["lbg"];
   arg["ubg"] = r["ubg"];
  
   r = solver(arg);
  
   std::vector<MX> helper_in = {veccat(active_symvar(OPTI_VAR)),
                                veccat(active_symvar(OPTI_PAR)),
                                veccat(active_symvar(OPTI_DUAL_G))};
   Function helper("helper", helper_in, {res});
  
   std::vector<MX> arg_in = helper(std::vector<MX>{r.at("x"), arg["p"], r.at("lam_g")});
  
   return Function(name, args, arg_in, name_in, name_out, opts);
  
 }

References casadi::MetaVar::active_i, active_symvar(), active_values(), arg(), casadi::assign_vector(), baked_copy(), casadi::MX::is_valid_input(), lam_g(), casadi::OPTI_DUAL_G, casadi::OPTI_PAR, casadi::OPTI_VAR, p(), casadi::MX::primitives(), problem_dirty(), res(), solver(), solver_construct(), casadi::str(), and casadi::Opti::to_function().

◆ ubg()

MX casadi::OptiNode::ubg ( ) const

inline

Definition at line 271 of file optistack_internal.hpp.

                  {
     if (problem_dirty()) return baked_copy().ubg();
     return bounds_unscaled_ubg_;
   }

Referenced by show_infeasibilities().

◆ update_user_dict()

void casadi::OptiNode::update_user_dict	(	const MX &	m,
		const Dict &	meta
	)

Definition at line 574 of file optistack_internal.cpp.

                                                              {
   if (has_con(m)) {
     MetaCon m_update = get_meta_con(m);
     MetaVar m_update2 = get_meta(m_update.dual_canon);
     for (const auto & it : meta) {
         m_update.extra[it.first] = it.second;
         m_update2.extra[it.first] = it.second;
     }
     set_meta_con(m, m_update);
     set_meta(m_update.dual_canon, m_update2);
   } else {
     for (const auto & s : MX::symvar(m)) {
       MetaVar m_update = get_meta(s);
       for (const auto & it : meta)
           m_update.extra[it.first] = it.second;
       set_meta(s, m_update);
     }
   }
 }

References casadi::MetaCon::dual_canon, casadi::MetaCon::extra, casadi::MetaVar::extra, get_meta(), get_meta_con(), set_meta(), set_meta_con(), and casadi::MX::symvar().

Referenced by subject_to().

◆ user_dict()

Dict casadi::OptiNode::user_dict ( const MX & m ) const

Definition at line 594 of file optistack_internal.cpp.

                                           {
   if (has_con(m)) {
     MetaCon meta = get_meta_con(m);
     return meta.extra;
   } else {
     MetaVar meta = get_meta(m);
     return meta.extra;
   }
 }

References casadi::MetaCon::extra, casadi::MetaVar::extra, get_meta(), and get_meta_con().

◆ value() [1/3]

DM casadi::OptiNode::value	(	const DM &	x,
		const std::vector< MX > &	values = `std::vector<MX>()`,
		bool	scaled = `false`
	)		const

inline

Obtain value of expression at the current value

Definition at line 121 of file optistack_internal.hpp.

122 { return x; }

◆ value() [2/3]

DM casadi::OptiNode::value	(	const MX &	x,
		const std::vector< MX > &	values = `std::vector<MX>()`,
		bool	scaled = `false`
	)		const

Obtain value of expression at the current value

Definition at line 1403 of file optistack_internal.cpp.

                                                                                  {
  
   std::shared_ptr<ValueHelper> vh;
   if (!helpers_->incache(expr, vh)) {
     vh = std::make_shared<ValueHelper>();
     std::vector<MX> x   = symvar(expr, OPTI_VAR);
     std::vector<MX> p   = symvar(expr, OPTI_PAR);
     std::vector<MX> lam = symvar(expr, OPTI_DUAL_G);
     vh->x = x;
     vh->p = p;
     vh->lam = lam;
     vh->helper = Function("helper", std::vector<MX>{veccat(x), veccat(p), veccat(lam)}, {expr});
     if (vh->helper.has_free())
       casadi_error("This expression has symbols that are not defined "
         "within Opti using variable/parameter.");
     helpers_->tocache_if_missing(expr, vh);
   }
  
   const std::vector<MX>& x = vh->x;
   const std::vector<MX>& p = vh->p;
   const std::vector<MX>& lam = vh->lam;
   const Function& helper = vh->helper;
  
   std::map<VariableType, std::map<casadi_int, MX> > temp;
   temp[OPTI_DUAL_G] = std::map<casadi_int, MX>();
   for (const auto& v : values) {
     casadi_assert_dev(v.is_op(OP_EQ));
     casadi_int i = meta(v.dep(1)).i;
     casadi_assert_dev(v.dep(0).is_constant());
     temp[meta(v.dep(1)).type][i] = v.dep(0);
   }
  
   bool undecided_vars = false;
   std::vector<DM> x_num;
   for (const auto& e : x) {
     casadi_int i = meta(e).i;
     x_num.push_back(store_latest_.at(OPTI_VAR).at(i));
     undecided_vars |= override_num(temp[OPTI_VAR], x_num, i);
     if (scaled) {
       x_num.back() = x_num.back()/store_linear_scale_.at(OPTI_VAR)[meta(e).i] -
                      store_linear_scale_offset_.at(OPTI_VAR)[meta(e).i];
     }
   }
  
   std::vector<DM> lam_num;
   for (const auto& e : lam) {
     casadi_int i = meta(e).i;
     casadi_assert(i<store_latest_.at(OPTI_DUAL_G).size(),
       "This expression has a dual for a constraint that is not given to Opti:\n" +
       describe(e, 1));
     lam_num.push_back(store_latest_.at(OPTI_DUAL_G).at(i));
     undecided_vars |= override_num(temp[OPTI_DUAL_G], lam_num, i);
   }
  
   std::vector<DM> p_num;
   for (const auto& e : p) {
     casadi_int i = meta(e).i;
     p_num.push_back(store_initial_.at(OPTI_PAR).at(i));
     override_num(temp[OPTI_PAR], p_num, i);
     casadi_assert(p_num.back().is_regular(),
       "This expression depends on a parameter with unset value:\n"+
       describe(e, 1));
   }
  
   if (undecided_vars) {
     assert_solved();
     for (const auto& e : x)
       casadi_assert(symbol_active_[meta(e).count],
         "This expression has symbols that do not appear in the constraints and objective:\n" +
         describe(e, 1));
     for (const auto& e : lam)
       casadi_assert(symbol_active_[meta(e).count],
         "This expression has a dual for a constraint that is not given to Opti:\n" +
         describe(e, 1));
   }
  
   std::vector<DM> arg = helper(std::vector<DM>{veccat(x_num), veccat(p_num), veccat(lam_num)});
   return arg[0];
 }

References arg(), assert_solved(), describe(), casadi::MetaVar::i, casadi::OP_EQ, casadi::OPTI_DUAL_G, casadi::OPTI_PAR, casadi::OPTI_VAR, casadi::override_num(), p(), symvar(), casadi::MetaVar::type, and x().

Referenced by show_infeasibilities().

◆ value() [3/3]

DM casadi::OptiNode::value	(	const SX &	x,
		const std::vector< MX > &	values = `std::vector<MX>()`,
		bool	scaled = `false`
	)		const

inline

Obtain value of expression at the current value

Definition at line 123 of file optistack_internal.hpp.

                                                                           {
     return DM::nan(x.sparsity());
   }

References casadi::Matrix< double >::nan(), and casadi::Matrix< Scalar >::sparsity().

◆ value_parameters()

std::vector< MX > casadi::OptiNode::value_parameters ( ) const

Definition at line 718 of file optistack_internal.cpp.

                                                {
   std::vector<MX> ret;
   for (const auto& e : symvar()) {
     if (meta(e).type==OPTI_PAR)
       ret.push_back(e==store_initial_.at(meta(e).type)[meta(e).i]);
   }
   return ret;
 }

References casadi::OPTI_PAR, and symvar().

◆ value_variables()

std::vector< MX > casadi::OptiNode::value_variables ( ) const

Definition at line 709 of file optistack_internal.cpp.

                                               {
   std::vector<MX> ret;
   for (const auto& e : symvar()) {
     if (meta(e).type==OPTI_VAR)
       ret.push_back(e==store_latest_.at(meta(e).type)[meta(e).i]);
   }
   return ret;
 }

References casadi::OPTI_VAR, and symvar().

◆ variable() [1/3]

MX casadi::OptiNode::variable	(	casadi_int	n = `1`,
		casadi_int	m = `1`,
		const std::string &	attribute = `"full"`
	)

Definition at line 278 of file optistack_internal.cpp.

                                                                             {
  
   // Prepare metadata
   MetaVar meta_data;
   meta_data.attribute = attribute;
   meta_data.n = n;
   meta_data.m = m;
   meta_data.type = OPTI_VAR;
   meta_data.count = count_++;
   meta_data.i = count_var_++;
   meta_data.domain = OPTI_DOMAIN_REAL;
  
   MX symbol, ret;
  
   if (attribute=="symmetric") {
     casadi_assert(n==m, "You specified attribute 'symmetric', "
       "while matrix is not even square, but " + str(n) + "-by-" + str(m) + ".");
     symbol = MX::sym(name_prefix() + "x_" + str(count_var_), n*(n+1)/2);
     ret = tril2symm(MX(Sparsity::lower(n), symbol));
   } else if (attribute=="full") {
     symbol = MX::sym(name_prefix() + "x_" + str(count_var_), n, m);
     ret = symbol;
   } else {
     casadi_error("Unknown attribute '" + attribute + "'. Choose from 'full' or 'symmetric'.");
   }
  
   // Store the symbol; preventing it from going ut of scope
   symbols_.push_back(symbol);
   store_initial_[OPTI_VAR].push_back(DM::zeros(symbol.sparsity()));
   store_latest_[OPTI_VAR].push_back(DM::nan(symbol.sparsity()));
   store_linear_scale_[OPTI_VAR].push_back(DM::ones(symbol.sparsity()));
   store_linear_scale_offset_[OPTI_VAR].push_back(DM::zeros(symbol.sparsity()));
  
   set_meta(symbol, meta_data);
   return ret;
 }

References casadi::MetaVar::attribute, casadi::MetaVar::count, casadi::MetaVar::domain, casadi::MetaVar::i, casadi::Sparsity::lower(), casadi::MetaVar::m, casadi::MetaVar::n, casadi::Matrix< double >::nan(), casadi::GenericMatrix< MatType >::ones(), casadi::OPTI_DOMAIN_REAL, casadi::OPTI_VAR, set_meta(), casadi::MX::sparsity(), casadi::str(), casadi::GenericMatrix< MX >::sym(), casadi::MetaVar::type, and casadi::GenericMatrix< MatType >::zeros().

◆ variable() [2/3]

MX casadi::OptiNode::variable	(	const MX &	symbol,
		const std::string &	attribute = `"full"`
	)

Definition at line 315 of file optistack_internal.cpp.

                                                                   {
  
   // Prepare metadata
   MetaVar meta_data;
   meta_data.attribute = attribute;
   meta_data.n = symbol.size1();
   meta_data.m = symbol.size2();
   meta_data.type = OPTI_VAR;
   meta_data.count = count_++;
   meta_data.i = count_var_++;
  
   // Store the symbol; preventing it from going ut of scope
   symbols_.push_back(symbol);
   store_initial_[OPTI_VAR].push_back(DM::zeros(symbol.sparsity()));
   store_latest_[OPTI_VAR].push_back(DM::nan(symbol.sparsity()));
   store_linear_scale_[OPTI_VAR].push_back(DM::ones(symbol.sparsity()));
   store_linear_scale_offset_[OPTI_VAR].push_back(DM::zeros(symbol.sparsity()));
  
   set_meta(symbol, meta_data);
   return symbol;
 }

References casadi::MetaVar::attribute, casadi::MetaVar::count, casadi::MetaVar::i, casadi::MetaVar::m, casadi::MetaVar::n, casadi::Matrix< double >::nan(), casadi::GenericMatrix< MatType >::ones(), casadi::OPTI_VAR, set_meta(), casadi::GenericMatrix< MatType >::size1(), casadi::GenericMatrix< MatType >::size2(), casadi::MX::sparsity(), casadi::MetaVar::type, and casadi::GenericMatrix< MatType >::zeros().

◆ variable() [3/3]

MX casadi::OptiNode::variable	(	const Sparsity &	sp,
		const std::string &	attribute = `"full"`
	)

Definition at line 337 of file optistack_internal.cpp.

                                                                     {
  
   // Prepare metadata
   MetaVar meta_data;
   meta_data.attribute = attribute;
   meta_data.n = sp.size1();
   meta_data.m = sp.size2();
   meta_data.type = OPTI_VAR;
   meta_data.count = count_++;
   meta_data.i = count_var_++;
  
   MX symbol = MX::sym(name_prefix() + "x_" + str(count_var_), sp);
  
   // Store the symbol; preventing it from going ut of scope
   symbols_.push_back(symbol);
   store_initial_[OPTI_VAR].push_back(DM::zeros(symbol.sparsity()));
   store_latest_[OPTI_VAR].push_back(DM::nan(symbol.sparsity()));
   store_linear_scale_[OPTI_VAR].push_back(DM::ones(symbol.sparsity()));
   store_linear_scale_offset_[OPTI_VAR].push_back(DM::zeros(symbol.sparsity()));
  
   set_meta(symbol, meta_data);
   return symbol;
 }

References casadi::MetaVar::attribute, casadi::MetaVar::count, casadi::MetaVar::i, casadi::MetaVar::m, casadi::MetaVar::n, casadi::Matrix< double >::nan(), casadi::GenericMatrix< MatType >::ones(), casadi::OPTI_VAR, set_meta(), casadi::Sparsity::size1(), casadi::Sparsity::size2(), casadi::MX::sparsity(), casadi::str(), casadi::GenericMatrix< MX >::sym(), casadi::MetaVar::type, and casadi::GenericMatrix< MatType >::zeros().

◆ weak()

GenericWeakRef< SharedObject , SharedObjectInternal > * casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::weak

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1ai

Definition at line 67 of file generic_shared_internal.hpp.

                                                                                   {
     if (weak_ref_==nullptr) {
       weak_ref_ = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
     }
     return weak_ref_;
   }

◆ x()

MX casadi::OptiNode::x ( ) const

inline

Definition at line 243 of file optistack_internal.hpp.

                {
     if (problem_dirty()) return baked_copy().x();
     return nlp_.at("x");
   }

Referenced by bake(), set_domain(), set_initial(), set_linear_scale(), set_value(), value(), and x_lookup().

◆ x_describe()

std::string casadi::OptiNode::x_describe	(	casadi_int	i,
		const Dict &	opts = `Dict()`
	)		const

Definition at line 221 of file optistack_internal.cpp.

                                                                    {
   if (problem_dirty()) return baked_copy().x_describe(i, opts);
   MX symbol = x_lookup(i);
   casadi_int local_i = i-meta(symbol).start + GlobalOptions::start_index;
   std::string description = describe(symbol, 0, opts);
   if (symbol.numel()>1)
     description += "\nAt nonzero " + str(local_i) + ".";
   return description;
 }

References baked_copy(), describe(), casadi::description(), casadi::GenericMatrix< MatType >::numel(), problem_dirty(), casadi::IndexAbstraction::start, casadi::GlobalOptions::start_index, casadi::str(), casadi::OptiAdvanced::x_describe(), and x_lookup().

◆ x_linear_scale()

DM casadi::OptiNode::x_linear_scale ( ) const

inline

Definition at line 282 of file optistack_internal.hpp.

                             {
     if (problem_dirty()) return baked_copy().x_linear_scale();
     return DM(linear_scale_);
   }

Referenced by scale_helper().

◆ x_linear_scale_offset()

DM casadi::OptiNode::x_linear_scale_offset ( ) const

inline

Definition at line 286 of file optistack_internal.hpp.

                                    {
     if (problem_dirty()) return baked_copy().x_linear_scale_offset();
     return DM(linear_scale_offset_);
   }

Referenced by scale_helper().

◆ x_lookup()

MX casadi::OptiNode::x_lookup ( casadi_int i ) const

Definition at line 231 of file optistack_internal.cpp.

                                         {
   if (problem_dirty()) return baked_copy().x_lookup(i);
   casadi_assert_dev(i>=0);
   casadi_assert_dev(i<nx());
   std::vector<MX> x = active_symvar(OPTI_VAR);
   for (const auto& e : x) {
     const MetaVar& m = meta(e);
     if (i>=m.start && i<m.stop) return e;
   }
   casadi_error("Internal error");
   return MX();
 }

References active_symvar(), baked_copy(), nx(), casadi::OPTI_VAR, problem_dirty(), casadi::IndexAbstraction::start, casadi::IndexAbstraction::stop, x(), and casadi::OptiAdvanced::x_lookup().

Referenced by x_describe().

Friends And Related Function Documentation

◆ InternalOptiCallback

friend class InternalOptiCallback

friend

Definition at line 57 of file optistack_internal.hpp.

Referenced by solve_prepare(), and solver_construct().

Member Data Documentation

◆ problem_dirty_

bool casadi::OptiNode::problem_dirty_

Definition at line 321 of file optistack_internal.hpp.

◆ solved_

bool casadi::OptiNode::solved_

Definition at line 329 of file optistack_internal.hpp.

◆ solver_dirty_

bool casadi::OptiNode::solver_dirty_

Definition at line 325 of file optistack_internal.hpp.

The documentation for this class was generated from the following files:

Detailed Description

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Friends

Member Typedef Documentation

◆ weak_ref_type

Constructor & Destructor Documentation

◆ OptiNode()

◆ ~OptiNode()

Member Function Documentation

◆ active_symvar()

◆ active_values() [1/2]

◆ active_values() [2/2]

◆ arg()

◆ assert_active_symbol()

◆ assert_baked()

◆ assert_empty()

◆ assert_solved()

◆ bake()

◆ baked_copy()

◆ callback_class() [1/2]

◆ callback_class() [2/2]

◆ canon_expr()

◆ casadi_solver()

◆ class_name()

◆ constraints()

◆ copy()

◆ create()

◆ debug_repr()

◆ describe()

◆ destroySingleton()

◆ disp()

◆ dual()

◆ f()

◆ f_linear_scale()

◆ g()

◆ g_describe()

◆ g_index_reduce_g()

◆ g_index_reduce_x()

◆ g_index_unreduce_g()

◆ g_linear_scale()

◆ g_lookup()

◆ get_meta()

◆ get_meta_con()

◆ getCount()

◆ has_callback_class()

◆ initial()

◆ initSingleton()

◆ instance_number()

◆ is_parametric()

◆ lam_g()

◆ lbg()

◆ mark_problem_dirty()

◆ mark_solved()

◆ mark_solver_dirty()

◆ minimize()

◆ ng()

◆ np()

◆ nx()

◆ objective()

◆ p()

◆ parameter() [1/3]

◆ parameter() [2/3]

◆ parameter() [3/3]

◆ problem_dirty()

◆ res() [1/2]

◆ res() [2/2]

◆ return_status()

◆ return_success()

◆ scale_helper()

◆ set_domain()

◆ set_initial() [1/2]

◆ set_initial() [2/2]

◆ set_linear_scale()

◆ set_meta()

◆ set_meta_con()

◆ set_value() [1/2]