casadi::OptiNode Class Reference

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:

Collaboration diagram for casadi::OptiNode:

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.

                    {
}

Member Function Documentation

active_symvar()

std::vector< MX > casadi::OptiNode::active_symvar

(

VariableType

type

)

const

Definition at line 1656 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 1676 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 1680 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 211 of file optistack_internal.hpp.

{ 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 1498 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 1188 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 1194 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 1182 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 739 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 217 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 1047 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)
      casadi_assert(!parametric[1], "Constraint must contain decision variables.");
      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;
  }
 
}

References casadi::MetaCon::canon, casadi::MX::dep(), casadi::GenericMatrix< MatType >::dim(), casadi::MX::eye(), casadi::MetaCon::flipped, casadi::inf, casadi::MX::is_op(), is_parametric(), casadi::GenericMatrix< MatType >::is_scalar(), casadi::GenericMatrix< MatType >::is_vector(), casadi::MetaCon::lb, casadi::MetaCon::linear_scale, casadi::MetaCon::n, casadi::GenericMatrix< MatType >::ones(), casadi::OP_EQ, casadi::OP_LE, casadi::OP_LT, casadi::OP_NORM2, casadi::OP_NORMF, casadi::OPTI_DOUBLE_INEQUALITY, casadi::OPTI_EQUALITY, casadi::OPTI_GENERIC_EQUALITY, casadi::OPTI_GENERIC_INEQUALITY, casadi::OPTI_INEQUALITY, casadi::OPTI_PSD, casadi::OPTI_UNKNOWN, casadi::MetaCon::original, casadi::GenericMatrix< MatType >::size(), casadi::GenericMatrix< MatType >::size1(), casadi::GenericMatrix< MatType >::size2(), casadi::MX::sparsity(), casadi::MetaCon::type, casadi::MetaCon::ub, and casadi::GenericMatrix< MatType >::zeros().

Referenced by subject_to().

casadi_solver()

Function casadi::OptiNode::casadi_solver

(

)

const

Definition at line 574 of file optistack_internal.cpp.

                                       {
  return solver_;
}

class_name()

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

inlineoverridevirtual

Implements casadi::SharedObjectInternal.

Definition at line 223 of file optistack_internal.hpp.

{ return "OptiNode"; }

constraints()

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

inline

Definition at line 214 of file optistack_internal.hpp.

{ 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 1750 of file optistack_internal.cpp.

                                                       {
 
}

dual()

MX casadi::OptiNode::dual

(

const MX &

m

)

const

Definition at line 616 of file optistack_internal.cpp.

                                   {
  return meta_con(m).dual;
}

References casadi::MetaCon::dual.

f()

MX casadi::OptiNode::f ( ) const

inline

Definition at line 262 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 295 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 256 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 529 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 537 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 533 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 291 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(i>=0 && i<ng(),
    "Index " + str(i) + " out of range for " + str(ng()) + " constraints");
  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, casadi::IndexAbstraction::stop, and casadi::str().

Referenced by g_describe().

get_meta()

MetaVar casadi::OptiNode::get_meta

(

const MX &

m

)

const

Definition at line 644 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 648 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 712 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 1754 of file optistack_internal.cpp.

                                           {
    return instance_number_;
}

is_parametric()

bool casadi::OptiNode::is_parametric

(

const MX &

expr

)

const

Definition at line 1043 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 278 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 267 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 323 of file optistack_internal.hpp.

{ problem_dirty_=flag; mark_solver_dirty(); }

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

mark_solved()

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

inline

Definition at line 331 of file optistack_internal.hpp.

{ solved_ = flag;}

Referenced by res(), and set_domain().

mark_solver_dirty()

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

inline

Definition at line 327 of file optistack_internal.hpp.

{ solver_dirty_=flag; mark_solved(false); }

Referenced by solve(), and solver().

minimize()

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

Definition at line 1199 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 238 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 232 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 226 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 215 of file optistack_internal.hpp.

{ return f_; }

p()

MX casadi::OptiNode::p ( ) const

inline

Definition at line 250 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 463 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_PAR;
  meta_data.count = count_++;
  meta_data.i = count_par_++;
 
  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() + "p_" + str(count_par_), n*(n+1)/2);
    ret = tril2symm(MX(Sparsity::lower(n), symbol));
  } else if (attribute=="full") {
    symbol = MX::sym(name_prefix() + "p_" + str(count_par_), n, m);
    ret = symbol;
  } else {
    casadi_error("Unknown attribute '" + attribute + "'. Choose from 'full' or 'symmetric'.");
  }
 
  symbols_.push_back(symbol);
  store_initial_[OPTI_PAR].push_back(DM::nan(symbol.sparsity()));
 
  set_meta(symbol, meta_data);
  return ret;
}

References casadi::MetaVar::attribute, casadi::MetaVar::count, casadi::MetaVar::i, casadi::Sparsity::lower(), casadi::MetaVar::m, casadi::MetaVar::n, casadi::Matrix< double >::nan(), casadi::OPTI_PAR, set_meta(), 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 424 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(), and casadi::MetaVar::type.

parameter() [3/3]

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

Definition at line 443 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::str(), casadi::GenericMatrix< MX >::sym(), and casadi::MetaVar::type.

problem_dirty()

bool casadi::OptiNode::problem_dirty ( ) const

inline

Definition at line 324 of file optistack_internal.hpp.

{ 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 213 of file optistack_internal.hpp.

{ 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 1256 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 542 of file optistack_internal.cpp.

                                        {
  Dict mystats;
  try {
    mystats = stats();
  } catch (...) {
    return "unknown";
  }
  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 557 of file optistack_internal.cpp.

                                                     {
  Dict mystats;
  try {
    mystats = stats();
  } catch (...) {
    return false;
  }
  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 911 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 1514 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 1629 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 1505 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 1643 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 578 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 582 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 1636 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 1532 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 1758 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 1335 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 1400 of file optistack_internal.cpp.

                                               {
  return solver_(arg);
}

References arg().

Referenced by solve().

solve_prepare()

void casadi::OptiNode::solve_prepare

(

)

Definition at line 1361 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 332 of file optistack_internal.hpp.

{ 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 969 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 1289 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 328 of file optistack_internal.hpp.

{ return solver_dirty_; }

Referenced by solve().

stats()

Dict casadi::OptiNode::stats

(

)

const

Definition at line 493 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 1239 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 1207 of file optistack_internal.cpp.

                                                                                  {
  assert_only_opti_nondual(g);
  mark_problem_dirty();
 
  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
  MetaCon con = canon_expr(g, linear_scale);
  casadi_assert(con.type!=OPTI_UNKNOWN, "Constraint type unknown. Use ==, >= or <= .");
  set_meta_con(g, con);
  register_dual(meta_con(g));
  g_.push_back(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(), casadi::OPTI_UNKNOWN, set_meta_con(), casadi::MetaCon::type, and update_user_dict().

symvar() [1/4]

std::vector< MX > casadi::OptiNode::symvar

(

)

const

Get symbols present in expression

Definition at line 993 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 997 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 1247 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 1666 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 1692 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))};
  Dict h_opts;
  Dict opts_remainder = extract_from_dict(opts, "helper_options", h_opts);
  Function helper("helper", helper_in, {res}, h_opts);
 
  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_remainder);
 
}

References casadi::MetaVar::active_i, active_symvar(), active_values(), arg(), casadi::assign_vector(), baked_copy(), casadi::extract_from_dict(), 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 272 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 586 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 606 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.

                                                                          { 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 1418 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.

                                                                          {
    casadi_assert(x.is_constant(), "Opti works with MX: cannot evaluate SX expression " + str(x));
    return evalf(x);
  }

References casadi::Matrix< Scalar >::is_constant(), and casadi::str().

value_parameters()

std::vector< MX > casadi::OptiNode::value_parameters

(

)

const

Definition at line 730 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 721 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::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::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::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.

                                                                                  {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    auto* w = weak_ref_.load(std::memory_order_acquire);
    if (!w) {
      auto* nw = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
      GenericWeakRef<Shared, Internal>* expected = nullptr;
      if (weak_ref_.compare_exchange_strong(
            expected, nw, std::memory_order_release, std::memory_order_acquire)) {
        w = nw;
      } else {
        delete nw; // lost the race; another thread published first
        w = expected;
      }
    }
    return w;
#else
    if (weak_ref_==nullptr) {
      weak_ref_ = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
    }
    return weak_ref_;
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  }

x()

MX casadi::OptiNode::x ( ) const

inline

Definition at line 244 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(), 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 283 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 287 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(i>=0 && i<nx(),
    "Index " + str(i) + " out of range for " + str(nx()) + " decision variables");
  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, casadi::str(), 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 322 of file optistack_internal.hpp.

solved_

bool casadi::OptiNode::solved_

Definition at line 330 of file optistack_internal.hpp.

solver_dirty_

bool casadi::OptiNode::solver_dirty_

Definition at line 326 of file optistack_internal.hpp.

---

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

• optistack_internal.hpp
• optistack_internal.cpp