Title

Functions
Function	casadi::dplesol (const std::string &name, const std::string &solver, const SpDict &st, const Dict &opts)
MX	casadi::dplesol (const MX &A, const MX &V, const std::string &solver, const Dict &opts)
CASADI_EXPORT MXVector	casadi::dplesol (const MXVector &A, const MXVector &V, const std::string &solver, const Dict &opts)
CASADI_EXPORT DMVector	casadi::dplesol (const DMVector &A, const DMVector &V, const std::string &solver, const Dict &opts)
std::vector< std::string >	casadi::dple_in ()
	Get input scheme of DPLE solvers. More...
std::vector< std::string >	casadi::dple_out ()
	Get output scheme of DPLE solvers. More...
std::string	casadi::dple_in (casadi_int ind)
	Get DPLE input scheme name by index. More...
std::string	casadi::dple_out (casadi_int ind)
	Get DPLE output scheme name by index. More...
casadi_int	casadi::dple_n_in ()
	Get the number of QP solver inputs. More...
casadi_int	casadi::dple_n_out ()
	Get the number of QP solver outputs. More...
bool	casadi::has_dple (const std::string &name)
	Check if a particular plugin is available. More...
void	casadi::load_dple (const std::string &name)
	Explicitly load a plugin dynamically. More...
std::string	casadi::doc_dple (const std::string &name)
	Get the documentation string for a plugin. More...

Detailed Description

Discrete periodic Lyapunov Equation solver Given matrices and symmetric

A_k in R^(n x n)
V_k in R^n

provides all of that satisfy:

P_0 = A_(K-1)*P_(K-1)*A_(K-1)' + V_k
P_k+1 = A_k*P_k*A_k' + V_k  for k = 1..K-1

General information

List of available options

Id	Type	Description	Used in
ad_weight	OT_DOUBLE	Weighting factor for derivative calculation.When there is an option of either using forward or reverse mode directional derivatives, the condition ad_weight*nf<=(1-ad_weight)*na is used where nf and na are estimates of the number of forward/reverse mode directional derivatives needed. By default, ad_weight is calculated automatically, but this can be overridden by setting this option. In particular, 0 means forcing forward mode and 1 forcing reverse mode. Leave unset for (class specific) heuristics.	casadi::FunctionInternal
ad_weight_sp	OT_DOUBLE	Weighting factor for sparsity pattern calculation calculation.Overrides default behavior. Set to 0 and 1 to force forward and reverse mode respectively. Cf. option "ad_weight". When set to -1, sparsity is completely ignored and dense matrices are used.	casadi::FunctionInternal
always_inline	OT_BOOL	Force inlining.	casadi::FunctionInternal
cache	OT_DICT	Prepopulate the function cache. Default: empty	casadi::FunctionInternal
compiler	OT_STRING	Just-in-time compiler plugin to be used.	casadi::FunctionInternal
const_dim	OT_BOOL	Assume constant dimension of P	casadi::Dple
custom_jacobian	OT_FUNCTION	Override CasADi's AD. Use together with 'jac_penalty': 0. Note: Highly experimental. Syntax may break often.	casadi::FunctionInternal
der_options	OT_DICT	Default options to be used to populate forward_options, reverse_options, and jacobian_options before those options are merged in.	casadi::FunctionInternal
derivative_of	OT_FUNCTION	The function is a derivative of another function. The type of derivative (directional derivative, Jacobian) is inferred from the function name.	casadi::FunctionInternal
dump	OT_BOOL	Dump function to file upon first evaluation. [false]	casadi::FunctionInternal
dump_dir	OT_STRING	Directory to dump inputs/outputs to. Make sure the directory exists [.]	casadi::FunctionInternal
dump_format	OT_STRING	Choose file format to dump matrices. See DM.from_file [mtx]	casadi::FunctionInternal
dump_in	OT_BOOL	Dump numerical values of inputs to file (readable with DM.from_file) [default: false]	casadi::FunctionInternal
dump_out	OT_BOOL	Dump numerical values of outputs to file (readable with DM.from_file) [default: false]	casadi::FunctionInternal
enable_fd	OT_BOOL	Enable derivative calculation by finite differencing. [default: false]]	casadi::FunctionInternal
enable_forward	OT_BOOL	Enable derivative calculation using generated functions for Jacobian-times-vector products - typically using forward mode AD - if available. [default: true]	casadi::FunctionInternal
enable_jacobian	OT_BOOL	Enable derivative calculation using generated functions for Jacobians of all differentiable outputs with respect to all differentiable inputs - if available. [default: true]	casadi::FunctionInternal
enable_reverse	OT_BOOL	Enable derivative calculation using generated functions for transposed Jacobian-times-vector products - typically using reverse mode AD - if available. [default: true]	casadi::FunctionInternal
eps_unstable	OT_DOUBLE	A margin for unstability detection	casadi::Dple
error_on_fail	OT_BOOL	Throw exceptions when function evaluation fails (default true).	casadi::ProtoFunction
error_unstable	OT_BOOL	Throw an exception when it is detected that Product(A_i, i=N..1)has eigenvalues greater than 1-eps_unstable	casadi::Dple
external_transform	OT_VECTORVECTOR	List of external_transform instruction arguments. Default: empty	casadi::FunctionInternal
fd_method	OT_STRING	Method for finite differencing [default 'central']	casadi::FunctionInternal
fd_options	OT_DICT	Options to be passed to the finite difference instance	casadi::FunctionInternal
forward_options	OT_DICT	Options to be passed to a forward mode constructor	casadi::FunctionInternal
gather_stats	OT_BOOL	Deprecated option (ignored): Statistics are now always collected.	casadi::FunctionInternal
input_scheme	OT_STRINGVECTOR	Deprecated option (ignored)	casadi::FunctionInternal
inputs_check	OT_BOOL	Throw exceptions when the numerical values of the inputs don't make sense	casadi::FunctionInternal
is_diff_in	OT_BOOLVECTOR	Indicate for each input if it should be differentiable.	casadi::FunctionInternal
is_diff_out	OT_BOOLVECTOR	Indicate for each output if it should be differentiable.	casadi::FunctionInternal
jac_penalty	OT_DOUBLE	When requested for a number of forward/reverse directions, it may be cheaper to compute first the full jacobian and then multiply with seeds, rather than obtain the requested directions in a straightforward manner. Casadi uses a heuristic to decide which is cheaper. A high value of 'jac_penalty' makes it less likely for the heurstic to chose the full Jacobian strategy. The special value -1 indicates never to use the full Jacobian strategy	casadi::FunctionInternal
jacobian_options	OT_DICT	Options to be passed to a Jacobian constructor	casadi::FunctionInternal
jit	OT_BOOL	Use just-in-time compiler to speed up the evaluation	casadi::FunctionInternal
jit_cleanup	OT_BOOL	Cleanup up the temporary source file that jit creates. Default: true	casadi::FunctionInternal
jit_name	OT_STRING	The file name used to write out code. The actual file names used depend on 'jit_temp_suffix' and include extensions. Default: 'jit_tmp'	casadi::FunctionInternal
jit_options	OT_DICT	Options to be passed to the jit compiler.	casadi::FunctionInternal
jit_serialize	OT_STRING	Specify behaviour when serializing a jitted function: SOURCE|link|embed.	casadi::FunctionInternal
jit_temp_suffix	OT_BOOL	Use a temporary (seemingly random) filename suffix for generated code and libraries. This is desired for thread-safety. This behaviour may defeat caching compiler wrappers. Default: true	casadi::FunctionInternal
max_io	OT_INT	Acceptable number of inputs and outputs. Warn if exceeded.	casadi::FunctionInternal
max_num_dir	OT_INT	Specify the maximum number of directions for derivative functions. Overrules the builtin optimized_num_dir.	casadi::FunctionInternal
never_inline	OT_BOOL	Forbid inlining.	casadi::FunctionInternal
output_scheme	OT_STRINGVECTOR	Deprecated option (ignored)	casadi::FunctionInternal
pos_def	OT_BOOL	Assume P positive definite	casadi::Dple
post_expand	OT_BOOL	After construction, expand this Function. Default: False	casadi::FunctionInternal
post_expand_options	OT_DICT	Options to be passed to post-construction expansion. Default: empty	casadi::FunctionInternal
print_in	OT_BOOL	Print numerical values of inputs [default: false]	casadi::FunctionInternal
print_out	OT_BOOL	Print numerical values of outputs [default: false]	casadi::FunctionInternal
print_time	OT_BOOL	print information about execution time. Implies record_time.	casadi::ProtoFunction
record_time	OT_BOOL	record information about execution time, for retrieval with stats().	casadi::ProtoFunction
regularity_check	OT_BOOL	Throw exceptions when NaN or Inf appears during evaluation	casadi::ProtoFunction
reverse_options	OT_DICT	Options to be passed to a reverse mode constructor	casadi::FunctionInternal
user_data	OT_VOIDPTR	A user-defined field that can be used to identify the function or pass additional information	casadi::FunctionInternal
verbose	OT_BOOL	Verbose evaluation – for debugging	casadi::ProtoFunction

Input scheme: casadi::DpleInput (DPLE_NUM_IN = 2)

Full name	Short	Description
DPLE_A	a	A matrices (horzcat when const_dim, diagcat otherwise) [a].
DPLE_V	v	V matrices (horzcat when const_dim, diagcat otherwise) [v].

Output scheme: casadi::DpleOutput (DPLE_NUM_OUT = 1)

Full name	Short	Description
DPLE_P	p	Lyapunov matrix (horzcat when const_dim, diagcat otherwise) (Cholesky of P if pos_def) [p].

List of plugins

- slicot

Note: some of the plugins in this list might not be available on your system. Also, there might be extra plugins available to you that are not listed here. You can obtain their documentation with Dple.doc("myextraplugin")

---

slicot

An efficient solver for Discrete Periodic Lyapunov Equations using SLICOT

Uses Periodic Schur Decomposition ('psd') and does not assume positive definiteness. Based on Periodic Lyapunov equations: some applications and new algorithms. Int. J. Control, vol. 67, pp. 69-87, 1997.

Overview of the method: J. Gillis Practical Methods for Approximate Robust Periodic Optimal Control ofNonlinear Mechanical Systems, PhD Thesis, KULeuven, 2015

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

List of available options

Id	Type	Description
linear_solver	OT_STRING	User-defined linear solver class. Needed for sensitivities.
linear_solver_options	OT_DICT	Options to be passed to the linear solver.
psd_num_zero	OT_DOUBLE	Numerical zero used in Periodic Schur decomposition with slicot.This option is needed when your systems has Floquet multiplierszero or close to zero

Author

Joris Gillis

Date

2013-2016

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

Function Documentation

doc_dple()

CASADI_EXPORT std::string casadi::doc_dple

(

const std::string &

name

)

Definition at line 39 of file dple.cpp.

                                            {
    return Dple::getPlugin(name).doc;
  }

References casadi::PluginInterface< Dple >::getPlugin().

dple_in() [1/2]

CASADI_EXPORT std::vector< std::string > casadi::dple_in

(

)

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

Definition at line 102 of file dple.cpp.

                                 {
    std::vector<std::string> ret(dple_n_in());
    for (size_t i=0; i<ret.size(); ++i) ret[i]=dple_in(i);
    return ret;
  }

References casadi::dple_n_in().

Referenced by casadi::Dple::get_name_in().

dple_in() [2/2]

CASADI_EXPORT std::string casadi::dple_in

(

casadi_int

ind

)

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

Definition at line 114 of file dple.cpp.

                                    {
    switch (static_cast<DpleInput>(ind)) {
    case DPLE_A:      return "a";
    case DPLE_V:      return "v";
    case DPLE_NUM_IN: break;
    }
    return std::string();
  }

References casadi::DPLE_A, casadi::DPLE_NUM_IN, and casadi::DPLE_V.

dple_n_in()

CASADI_EXPORT casadi_int casadi::dple_n_in

(

)

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

Definition at line 131 of file dple.cpp.

                         {
    return DPLE_NUM_IN;
  }

References casadi::DPLE_NUM_IN.

Referenced by casadi::dple_in().

dple_n_out()

CASADI_EXPORT casadi_int casadi::dple_n_out

(

)

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

Definition at line 135 of file dple.cpp.

                          {
    return DPLE_NUM_OUT;
  }

References casadi::DPLE_NUM_OUT.

Referenced by casadi::dple_out().

dple_out() [1/2]

CASADI_EXPORT std::vector< std::string > casadi::dple_out

(

)

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

Definition at line 108 of file dple.cpp.

                                  {
    std::vector<std::string> ret(dple_n_out());
    for (size_t i=0; i<ret.size(); ++i) ret[i]=dple_out(i);
    return ret;
  }

References casadi::dple_n_out().

Referenced by casadi::Dple::get_name_out().

dple_out() [2/2]

CASADI_EXPORT std::string casadi::dple_out

(

casadi_int

ind

)

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

Definition at line 123 of file dple.cpp.

                                     {
    switch (static_cast<DpleOutput>(ind)) {
      case DPLE_P:      return "p";
      case DPLE_NUM_OUT: break;
    }
    return std::string();
  }

References casadi::DPLE_NUM_OUT, and casadi::DPLE_P.

dplesol() [1/4]

CASADI_EXPORT DMVector casadi::dplesol	(	const DMVector &	A,
		const DMVector &	V,
		const std::string &	solver,
		const Dict &	opts
	)

Definition at line 71 of file dple.cpp.

                      {
      casadi_assert(A.size()==V.size(),
        "dplesol: sizes of A vector (" + str(A.size()) + ") and V vector "
        "(" + str(V.size()) + ") must match.");
      std::vector<DM> Adense, Vdense;
 
      for (casadi_int i=0;i<A.size();++i) {
        Adense.push_back(densify(A[i]));
        Vdense.push_back(densify(V[i]));
      }
 
      DM Afull = diagcat(Adense);
      DM Vfull = diagcat(Vdense);
 
      SpDict sp;
      sp["a"] = Afull.sparsity();
      sp["v"] = Vfull.sparsity();
      Function f = dplesol("dplesol", solver, sp, opts);
      DMDict f_in;
      f_in["a"] = Afull;
      f_in["v"] = Vfull;
      DMDict f_out = f(f_in);
      return diagsplit(f_out["p"], f_out["p"].size1()/A.size());
  }

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

dplesol() [2/4]

CASADI_EXPORT MX casadi::dplesol	(	const MX &	A,
		const MX &	V,
		const std::string &	solver,
		const Dict &	opts
	)

Definition at line 43 of file dple.cpp.

                                                                                  {
    SpDict sp;
    sp["a"] = A.sparsity();
    sp["v"] = V.sparsity();
    Function f = dplesol("dplesol", solver, sp, opts);
    MXDict f_in;
    f_in["a"] = A;
    f_in["v"] = V;
    MXDict f_out = f(f_in);
    return f_out["p"];
  }

References casadi::MX::sparsity().

Referenced by casadi::dplesol(), casadi::Dple::get_forward(), and casadi::Dple::get_reverse().

dplesol() [3/4]

CASADI_EXPORT MXVector casadi::dplesol	(	const MXVector &	A,
		const MXVector &	V,
		const std::string &	solver,
		const Dict &	opts
	)

Definition at line 55 of file dple.cpp.

                      {
      casadi_assert(A.size()==V.size(),
        "dplesol: sizes of A vector (" + str(A.size()) + ") and V vector "
        "(" + str(V.size()) + ") must match.");
      std::vector<MX> Adense, Vdense;
 
      for (casadi_int i=0;i<A.size();++i) {
        Adense.push_back(densify(A[i]));
        Vdense.push_back(densify(V[i]));
      }
 
      MX ret = dplesol(diagcat(Adense), diagcat(Vdense), solver, opts);
      return diagsplit(ret, ret.size1()/A.size());
  }

References casadi::dplesol(), casadi::GenericMatrix< MatType >::size1(), and casadi::str().

dplesol() [4/4]

CASADI_EXPORT Function casadi::dplesol	(	const std::string &	name,
		const std::string &	solver,
		const SpDict &	st,
		const Dict &	opts = Dict()
	)

Definition at line 97 of file dple.cpp.

                                                    {
    return Function::create(Dple::instantiate(name, solver, st), opts);
  }

References casadi::Function::create(), and casadi::PluginInterface< Dple >::instantiate().

has_dple()

CASADI_EXPORT bool casadi::has_dple

(

const std::string &

name

)

Definition at line 31 of file dple.cpp.

                                       {
    return Dple::has_plugin(name);
  }

References casadi::PluginInterface< Dple >::has_plugin().

load_dple()

CASADI_EXPORT void casadi::load_dple

(

const std::string &

name

)

Definition at line 35 of file dple.cpp.

                                        {
    Dple::load_plugin(name);
  }

References casadi::PluginInterface< Dple >::load_plugin().