casadi::LapackLu Class Reference

'lapacklu' plugin for Linsol More...

#include <lapack_lu.hpp>

Detailed Description

This class solves the linear system A.x=b by making an LU factorization of A:
A = L.U, with L lower and U upper triangular

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

List of available options

Id	Type	Description
allow_equilibration_failure	OT_BOOL	Non-fatal error when equilibration fails
equilibration	OT_BOOL	Equilibrate the matrix

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
allow_equilibration_failure	OT_BOOL	Non-fatal error when equilibration fails	casadi::LapackLu
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
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
equilibration	OT_BOOL	Equilibrate the matrix	casadi::LapackLu
error_on_fail	OT_BOOL	Throw exceptions when function evaluation fails (default true).	casadi::ProtoFunction
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
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

Definition at line 82 of file lapack_lu.hpp.

Inheritance diagram for casadi::LapackLu:

Collaboration diagram for casadi::LapackLu:

Public Types
typedef LinsolInternal *(*	Creator) (const std::string &name, const Sparsity &sp)
using	weak_ref_type = WeakRefInternal
typedef int(*	RegFcn) (Plugin *plugin)

Public Member Functions
	LapackLu (const std::string &name, const Sparsity &sp)
	~LapackLu () override
	Destructor. More...
void	init (const Dict &opts) override
	Initialize the solver. More...
void *	alloc_mem () const override
	Create memory block. More...
int	init_mem (void *mem) const override
	Initalize memory block. More...
void	free_mem (void *mem) const override
	Free memory block. More...
int	nfact (void *mem, const double *A) const override
	Numeric factorization. More...
int	solve (void *mem, const double *A, double *x, casadi_int nrhs, bool tr) const override
void	serialize_body (SerializingStream &s) const override
	Serialize an object without type information. More...
void	disp (std::ostream &stream, bool more) const override
	Display object. More...
virtual void	disp_more (std::ostream &stream) const
	Print more. More...
virtual void	linsol_eval_sx (const SXElem **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem, bool tr, casadi_int nrhs) const
	Evaluate SX, possibly transposed. More...
virtual int	sfact (void *mem, const double *A) const
virtual casadi_int	neig (void *mem, const double *A) const
	Number of negative eigenvalues. More...
virtual casadi_int	rank (void *mem, const double *A) const
	Matrix rank. More...
virtual void	generate (CodeGenerator &g, const std::string &A, const std::string &x, casadi_int nrhs, bool tr) const
	Generate C code. More...
casadi_int	nrow () const
	Get sparsity pattern. More...
casadi_int	ncol () const
const casadi_int *	colind () const
const casadi_int *	row () const
casadi_int	nnz () const
void	serialize_type (SerializingStream &s) const override
	Serialize type information. More...
void	construct (const Dict &opts)
	Construct. More...
virtual Dict	generate_options (const std::string &target) const
	Reconstruct options dict. More...
void	print_options (std::ostream &stream) const
	Print list of options. More...
void	print_option (const std::string &name, std::ostream &stream) const
	Print all information there is to know about a certain option. More...
bool	has_option (const std::string &option_name) const
	Does a particular option exist. More...
virtual void	change_option (const std::string &option_name, const GenericType &option_value)
	Change option after object creation for debugging. More...
virtual void	finalize ()
	Finalize the object creation. More...
int	checkout () const
	Checkout a memory object. More...
void	release (int mem) const
	Release a memory object. More...
void *	memory (int ind) const
	Memory objects. More...
bool	has_memory (int ind) const
	Check for existance of memory object. More...
virtual void	check_mem_count (casadi_int n) const
	Check for validatity of memory object count. More...
virtual Dict	get_stats (void *mem) const
	Get all statistics. More...
void	clear_mem ()
	Clear all memory (called from destructor) More...
void	print (const char *fmt,...) const
	C-style formatted printing during evaluation. More...
void	sprint (char *buf, size_t buf_sz, const char *fmt,...) const
	C-style formatted printing to string. More...
void	format_time (char *buffer, double time) const
	Format time in a fixed width 8 format. More...
void	print_time (const std::map< std::string, FStats > &fstats) const
	Print timing statistics. More...
void	serialize (SerializingStream &s) const
	Serialize an object. More...
virtual std::string	serialize_base_function () const
	String used to identify the immediate FunctionInternal subclass. More...
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...

Static Public Member Functions
static LinsolInternal *	creator (const std::string &name, const Sparsity &sp)
	Create a new Linsol. More...
static ProtoFunction *	deserialize (DeserializingStream &s)
	Deserialize with type disambiguation. More...
static bool	has_plugin (const std::string &pname, bool verbose=false)
	Check if a plugin is available or can be loaded. More...
static const Options &	plugin_options (const std::string &pname)
	Get the plugin options. More...
static Deserialize	plugin_deserialize (const std::string &pname)
	Get the plugin deserialize_map. More...
static Plugin	pluginFromRegFcn (RegFcn regfcn)
	Instantiate a Plugin struct from a factory function. More...
static Plugin	load_plugin (const std::string &pname, bool register_plugin=true, bool needs_lock=true)
	Load a plugin dynamically. More...
static handle_t	load_library (const std::string &libname, std::string &resultpath, bool global)
	Load a library dynamically. More...
static void	registerPlugin (const Plugin &plugin, bool needs_lock=true)
	Register an integrator in the factory. More...
static void	registerPlugin (RegFcn regfcn, bool needs_lock=true)
	Register an integrator in the factory. More...
static Plugin &	getPlugin (const std::string &pname)
	Load and get the creator function. More...
static LinsolInternal *	instantiate (const std::string &fname, const std::string &pname, Problem problem)

Public Attributes
Sparsity	sp_
std::string	name_
	Name. More...
bool	verbose_
	Verbose printout. More...
bool	print_time_
bool	record_time_
bool	regularity_check_
	Errors are thrown when NaN is produced. More...
bool	error_on_fail_
	Throw an exception on failure? More...

Static Public Attributes
static const std::string	meta_doc
	A documentation string. More...
static std::map< std::string, Plugin >	solvers_
	Collection of solvers. More...
static const std::string	infix_ = "linsol"
	Infix. More...

Protected Member Functions
	LapackLu (DeserializingStream &s)
	Deserializing constructor. More...
const char *	plugin_name () const override
std::string	class_name () const override
	Readable name of the internal class. More...
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...

Protected Attributes
bool	equilibriate_
	Equilibrate? More...
bool	allow_equilibration_failure_
	Allow the equilibration to fail. More...
static const Options	options_
	Options. More...
const Options &	get_options () const override
	Options. More...

Member Typedef Documentation

Creator

typedef LinsolInternal*(* casadi::LinsolInternal::Creator) (const std::string &name, const Sparsity &sp)

inherited

Definition at line 121 of file linsol_internal.hpp.

RegFcn

typedef int(* casadi::PluginInterface< LinsolInternal >::RegFcn) (Plugin *plugin)

inherited

Definition at line 73 of file plugin_interface.hpp.

weak_ref_type

using casadi::SharedObjectInternal::weak_ref_type = WeakRefInternal

inherited

Definition at line 152 of file shared_object.hpp.

Constructor & Destructor Documentation

LapackLu() [1/2]

casadi::LapackLu::LapackLu	(	const std::string &	name,
		const Sparsity &	sp
	)

Definition at line 48 of file lapack_lu.cpp.

    : LinsolInternal(name, sp) {
 
    // Default options
    equilibriate_ = true;
    allow_equilibration_failure_ = false;
  }

References allow_equilibration_failure_, and equilibriate_.

~LapackLu()

casadi::LapackLu::~LapackLu ( )

override

Definition at line 56 of file lapack_lu.cpp.

                      {
    clear_mem();
  }

References casadi::ProtoFunction::clear_mem().

LapackLu() [2/2]

casadi::LapackLu::LapackLu ( DeserializingStream &  s )

explicitprotected

Definition at line 191 of file lapack_lu.cpp.

                                           : LinsolInternal(s) {
    s.version("LapackLu", 1);
    s.unpack("LapackLu::equilibriate", equilibriate_);
    s.unpack("LapackLu::allow_equilibration_failure", allow_equilibration_failure_);
  }

References allow_equilibration_failure_, equilibriate_, casadi::DeserializingStream::unpack(), and casadi::DeserializingStream::version().

Member Function Documentation

alloc_mem()

void* casadi::LapackLu::alloc_mem ( ) const

inlineoverridevirtual

Reimplemented from casadi::LinsolInternal.

Definition at line 105 of file lapack_lu.hpp.

{ return new LapackLuMemory();}

change_option()

void casadi::ProtoFunction::change_option ( const std::string &  option_name, const GenericType &  option_value  )

virtualinherited

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

Reimplemented in casadi::MXFunction, casadi::FunctionInternal, and casadi::FmuFunction.

Definition at line 924 of file function_internal.cpp.

                                       {
    if (option_name == "verbose") {
      verbose_ = option_value;
    } else if (option_name == "regularity_check") {
      regularity_check_ = option_value;
    } else {
      // Failure
      casadi_error("Option '" + option_name + "' cannot be changed");
    }
  }

References casadi::ProtoFunction::regularity_check_, and casadi::ProtoFunction::verbose_.

Referenced by casadi::FunctionInternal::change_option().

check_mem_count()

virtual void casadi::ProtoFunction::check_mem_count ( casadi_int  n ) const

inlinevirtualinherited

Purpose if to allow more helpful error messages

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

Reimplemented in casadi::FmuFunction.

Definition at line 179 of file function_internal.hpp.

{ }

Referenced by casadi::ProtoFunction::checkout().

checkout()

int casadi::ProtoFunction::checkout ( ) const

inherited

Definition at line 3585 of file function_internal.cpp.

                                    {
#ifdef CASADI_WITH_THREAD
    std::lock_guard<std::mutex> lock(mtx_);
#endif //CASADI_WITH_THREAD
    if (unused_.empty()) {
      check_mem_count(mem_.size()+1);
      // Allocate a new memory object
      void* m = alloc_mem();
      mem_.push_back(m);
      if (init_mem(m)) {
        casadi_error("Failed to create or initialize memory object");
      }
      return static_cast<int>(mem_.size()) - 1;
    } else {
      // Use an unused memory object
      int m = unused_.top();
      unused_.pop();
      return m;
    }
  }

References casadi::ProtoFunction::alloc_mem(), casadi::ProtoFunction::check_mem_count(), and casadi::ProtoFunction::init_mem().

Referenced by casadi::ProtoFunction::finalize(), casadi::FunctionBuffer::FunctionBuffer(), and casadi::Sqpmethod::init_mem().

class_name()

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

inlineoverrideprotectedvirtual

Implements casadi::SharedObjectInternal.

Definition at line 142 of file lapack_lu.hpp.

{ return "LapackLu";}

clear_mem()

void casadi::ProtoFunction::clear_mem ( )

inherited

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

Definition at line 3473 of file function_internal.cpp.

                                {
    for (auto&& i : mem_) {
      if (i!=nullptr) free_mem(i);
    }
    mem_.clear();
  }

References casadi::ProtoFunction::free_mem().

Referenced by casadi::AlpaqaInterface::~AlpaqaInterface(), casadi::AmplInterface::~AmplInterface(), casadi::BlazingSplineFunction::~BlazingSplineFunction(), casadi::Blocksqp::~Blocksqp(), casadi::BonminInterface::~BonminInterface(), casadi::BSplineInterpolant::~BSplineInterpolant(), casadi::CallbackInternal::~CallbackInternal(), casadi::CbcInterface::~CbcInterface(), casadi::ClarabelInterface::~ClarabelInterface(), casadi::ClpInterface::~ClpInterface(), casadi::CplexInterface::~CplexInterface(), casadi::CsparseInterface::~CsparseInterface(), casadi::CvodesInterface::~CvodesInterface(), casadi::DaqpInterface::~DaqpInterface(), casadi::External::~External(), casadi::FastNewton::~FastNewton(), casadi::FatropConicInterface::~FatropConicInterface(), casadi::FatropInterface::~FatropInterface(), casadi::Feasiblesqpmethod::~Feasiblesqpmethod(), casadi::FiniteDiff::~FiniteDiff(), casadi::FixedStepIntegrator::~FixedStepIntegrator(), casadi::FmuFunction::~FmuFunction(), casadi::GurobiInterface::~GurobiInterface(), casadi::HighsInterface::~HighsInterface(), casadi::HpipmInterface::~HpipmInterface(), casadi::HpmpcInterface::~HpmpcInterface(), casadi::IdasInterface::~IdasInterface(), casadi::ImplicitToNlp::~ImplicitToNlp(), casadi::IpoptInterface::~IpoptInterface(), casadi::Ipqp::~Ipqp(), casadi::JitFunction::~JitFunction(), casadi::KinsolInterface::~KinsolInterface(), casadi::KnitroInterface::~KnitroInterface(), ~LapackLu(), casadi::LapackQr::~LapackQr(), casadi::LinearInterpolant::~LinearInterpolant(), casadi::LinearInterpolantJac::~LinearInterpolantJac(), casadi::LinsolLdl::~LinsolLdl(), casadi::LinsolQr::~LinsolQr(), casadi::LinsolTridiag::~LinsolTridiag(), casadi::Lsqr::~Lsqr(), casadi::Ma27Interface::~Ma27Interface(), casadi::MadnlpInterface::~MadnlpInterface(), casadi::Map::~Map(), casadi::MapSum::~MapSum(), casadi::MumpsInterface::~MumpsInterface(), casadi::MXFunction::~MXFunction(), casadi::Newton::~Newton(), casadi::Nlpsol::~Nlpsol(), casadi::OmpMap::~OmpMap(), casadi::OoqpInterface::~OoqpInterface(), casadi::OsqpInterface::~OsqpInterface(), casadi::ProxqpInterface::~ProxqpInterface(), casadi::QpoasesInterface::~QpoasesInterface(), casadi::QpToNlp::~QpToNlp(), casadi::Qrqp::~Qrqp(), casadi::Qrsqp::~Qrsqp(), casadi::Scpgen::~Scpgen(), casadi::SLEQPInterface::~SLEQPInterface(), casadi::SlicotDple::~SlicotDple(), casadi::SlicotExpm::~SlicotExpm(), casadi::SnoptInterface::~SnoptInterface(), casadi::Sqpmethod::~Sqpmethod(), casadi::SuperscsInterface::~SuperscsInterface(), casadi::Switch::~Switch(), casadi::SXFunction::~SXFunction(), casadi::SymbolicQr::~SymbolicQr(), casadi::ThreadMap::~ThreadMap(), and casadi::WorhpInterface::~WorhpInterface().

colind()

const casadi_int* casadi::LinsolInternal::colind ( ) const

inlineinherited

Definition at line 142 of file linsol_internal.hpp.

{ return sp_.colind();}

Referenced by casadi::CsparseInterface::init_mem(), casadi::MumpsInterface::init_mem(), casadi::Ma27Interface::nfact(), and casadi::MumpsInterface::nfact().

construct()

void casadi::ProtoFunction::construct ( const Dict &  opts )

inherited

Prepares the function for evaluation

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

Definition at line 137 of file function_internal.cpp.

                                                {
    // Sanitize dictionary is needed
    if (!Options::is_sane(opts)) {
      // Call recursively
      return construct(Options::sanitize(opts));
    }
 
    // Make sure all options exist
    get_options().check(opts);
 
    // Initialize the class hierarchy
    try {
      init(opts);
    } catch(std::exception& e) {
      casadi_error("Error calling " + class_name() + "::init for '" + name_ + "':\n"
        + std::string(e.what()));
    }
 
    // Revisit class hierarchy in reverse order
    try {
      finalize();
    } catch(std::exception& e) {
      casadi_error("Error calling " + class_name() + "::finalize for '" + name_ + "':\n"
        + std::string(e.what()));
    }
  }

References casadi::Options::check(), casadi::SharedObjectInternal::class_name(), casadi::ProtoFunction::finalize(), casadi::ProtoFunction::get_options(), casadi::ProtoFunction::init(), casadi::Options::is_sane(), casadi::ProtoFunction::name_, and casadi::Options::sanitize().

Referenced by casadi::Function::create(), casadi::FmuFunction::factory(), casadi::FmuFunction::get_forward(), casadi::FmuFunction::get_jacobian(), casadi::LinearInterpolant::get_jacobian(), and casadi::FmuFunction::get_reverse().

creator()

static LinsolInternal* casadi::LapackLu::creator ( const std::string &  name, const Sparsity &  sp  )

inlinestatic

Definition at line 88 of file lapack_lu.hpp.

                                                                              {
      return new LapackLu(name, sp);
    }

Referenced by casadi::casadi_register_linsol_lapacklu().

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

deserialize()

static ProtoFunction* casadi::LapackLu::deserialize ( DeserializingStream &  s )

inlinestatic

Definition at line 126 of file lapack_lu.hpp.

{ return new LapackLu(s); }

Referenced by casadi::casadi_register_linsol_lapacklu().

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::LinsolInternal::disp ( std::ostream &  stream, bool  more  ) const

overridevirtualinherited

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

Implements casadi::SharedObjectInternal.

Definition at line 43 of file linsol_internal.cpp.

                                                               {
    stream << "Linear solver " << class_name();
    if (more) {
      stream << std::endl;
      disp_more(stream);
    }
  }

References casadi::SharedObjectInternal::class_name(), and casadi::LinsolInternal::disp_more().

disp_more()

virtual void casadi::LinsolInternal::disp_more ( std::ostream &  stream ) const

inlinevirtualinherited

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

Definition at line 65 of file linsol_internal.hpp.

{}

Referenced by casadi::LinsolInternal::disp().

finalize()

void casadi::ProtoFunction::finalize ( )

virtualinherited

This function, which visits the class hierarchy in reverse order is run after init() has been completed.

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

Reimplemented in casadi::LinsolQr, casadi::OracleFunction, casadi::FunctionInternal, and casadi::CallbackInternal.

Definition at line 725 of file function_internal.cpp.

                               {
    // Create memory object
    int mem = checkout();
    casadi_assert_dev(mem==0);
  }

References casadi::ProtoFunction::checkout().

Referenced by casadi::ProtoFunction::construct(), casadi::Linsol::deserialize(), casadi::FunctionInternal::finalize(), and casadi::LinsolQr::finalize().

format_time()

void casadi::ProtoFunction::format_time ( char *  buffer, double  time  ) const

inherited

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

Definition at line 3772 of file function_internal.cpp.

                                                                 {
    // Always of width 8
    casadi_assert_dev(time>=0);
    double log_time = log10(time);
    int magn = static_cast<int>(floor(log_time));
    int iprefix = static_cast<int>(floor(log_time/3));
    if (iprefix<-4) {
      sprint(buffer, 10, "       0");
      return;
    }
    if (iprefix>=5) {
      sprint(buffer, 10, "     inf");
      return;
    }
    char prefixes[] = "TGMk munp";
    char prefix = prefixes[4-iprefix];
 
    int rem = magn-3*iprefix;
    double time_normalized = time/pow(10, 3*iprefix);
 
    if (rem==0) {
      sprint(buffer, 10, "  %1.2f%cs", time_normalized, prefix);
    } else if (rem==1) {
      sprint(buffer, 10, " %2.2f%cs", time_normalized, prefix);
    } else {
      sprint(buffer, 10, "%3.2f%cs", time_normalized, prefix);
    }
  }

References casadi::ProtoFunction::sprint().

Referenced by casadi::ProtoFunction::print_time().

free_mem()

void casadi::LapackLu::free_mem ( void *  mem ) const

inlineoverridevirtual

Reimplemented from casadi::LinsolInternal.

Definition at line 111 of file lapack_lu.hpp.

{ delete static_cast<LapackLuMemory*>(mem);}

generate()

void casadi::LinsolInternal::generate ( CodeGenerator &  g, const std::string &  A, const std::string &  x, casadi_int  nrhs, bool  tr  ) const

virtualinherited

Reimplemented in casadi::Lsqr, casadi::LinsolTridiag, casadi::LinsolQr, and casadi::LinsolLdl.

Definition at line 110 of file linsol_internal.cpp.

                                                                {
    g << "#error " <<  class_name() << " does not support code generation\n";
  }

References casadi::SharedObjectInternal::class_name().

generate_options()

Dict casadi::ProtoFunction::generate_options ( const std::string &  target ) const

virtualinherited

Reimplemented in casadi::SXFunction, casadi::MXFunction, and casadi::FunctionInternal.

Definition at line 372 of file function_internal.cpp.

                                                                    {
    Dict opts;
    opts["verbose"] = verbose_;
    opts["print_time"] = print_time_;
    opts["record_time"] = record_time_;
    opts["regularity_check"] = regularity_check_;
    opts["error_on_fail"] = error_on_fail_;
    return opts;
  }

References casadi::ProtoFunction::error_on_fail_, casadi::ProtoFunction::print_time_, casadi::ProtoFunction::record_time_, casadi::ProtoFunction::regularity_check_, and casadi::ProtoFunction::verbose_.

Referenced by casadi::FunctionInternal::generate_options().

get_options()

const Options& casadi::LapackLu::get_options ( ) const

inlineoverridevirtual

Reimplemented from casadi::ProtoFunction.

Definition at line 98 of file lapack_lu.hpp.

{ return options_;}

get_stats()

Dict casadi::ProtoFunction::get_stats ( void *  mem ) const

virtualinherited

Reimplemented in casadi::Sqpmethod, casadi::Scpgen, casadi::Qrsqp, casadi::Qrqp, casadi::QpToNlp, casadi::Newton, casadi::Ipqp, casadi::ImplicitToNlp, casadi::Feasiblesqpmethod, casadi::FastNewton, casadi::WorhpInterface, casadi::SuperscsInterface, casadi::SundialsInterface, casadi::SnoptInterface, casadi::SLEQPInterface, casadi::QpoasesInterface, casadi::ProxqpInterface, casadi::OsqpInterface, casadi::OoqpInterface, casadi::MadnlpInterface, casadi::KnitroInterface, casadi::IpoptInterface, casadi::HpmpcInterface, casadi::HpipmInterface, casadi::HighsInterface, casadi::GurobiInterface, casadi::FatropInterface, casadi::FatropConicInterface, casadi::DaqpInterface, casadi::CplexInterface, casadi::ClpInterface, casadi::ClarabelInterface, casadi::CbcInterface, casadi::BonminInterface, casadi::AlpaqaInterface, casadi::Rootfinder, casadi::OracleFunction, casadi::Nlpsol, casadi::MXFunction, casadi::FunctionInternal, casadi::FmuFunction, and casadi::Conic.

Definition at line 2884 of file function_internal.cpp.

                                               {
    auto m = static_cast<ProtoFunctionMemory*>(mem);
    // Add timing statistics
    Dict stats;
    for (const auto& s : m->fstats) {
      stats["n_call_" +s.first] = s.second.n_call;
      stats["t_wall_" +s.first] = s.second.t_wall;
      stats["t_proc_" +s.first] = s.second.t_proc;
    }
    return stats;
  }

Referenced by casadi::FunctionInternal::get_stats().

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

getPlugin()

PluginInterface< LinsolInternal >::Plugin & casadi::PluginInterface< LinsolInternal >::getPlugin ( const std::string &  pname )

staticinherited

Definition at line 102 of file plugin_interface.hpp.

                                                            {
 
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    std::lock_guard<std::mutex> lock(Derived::mutex_solvers_);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
 
    // Check if the solver has been loaded
    auto it=Derived::solvers_.find(pname);
 
    // Load the solver if needed
    if (it==Derived::solvers_.end()) {
      load_plugin(pname, true, false);
      it=Derived::solvers_.find(pname);
    }
    casadi_assert_dev(it!=Derived::solvers_.end());
    return it->second;
  }

has_memory()

bool casadi::ProtoFunction::has_memory ( int  ind ) const

inherited

Definition at line 3581 of file function_internal.cpp.

                                              {
    return ind<mem_.size();
  }

has_option()

bool casadi::ProtoFunction::has_option ( const std::string &  option_name ) const

inherited

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

Definition at line 920 of file function_internal.cpp.

                                                                   {
    return get_options().find(option_name) != 0;
  }

References casadi::Options::find(), and casadi::ProtoFunction::get_options().

has_plugin()

bool casadi::PluginInterface< LinsolInternal >::has_plugin ( const std::string &  pname, bool  verbose = false  )

staticinherited

Definition at line 76 of file plugin_interface.hpp.

                                                                                {
 
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    std::lock_guard<std::mutex> lock(Derived::mutex_solvers_);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
 
    // Quick return if available
    if (Derived::solvers_.find(pname) != Derived::solvers_.end()) {
      return true;
    }
 
    // Try loading the plugin
    try {
      (void)load_plugin(pname, false, false);
      return true;
    } catch (CasadiException& ex) {
      if (verbose) {
        casadi_warning(ex.what());
      }
      return false;
    }
  }

init()

void casadi::LapackLu::init ( const Dict &  opts )

overridevirtual

Reimplemented from casadi::LinsolInternal.

Definition at line 71 of file lapack_lu.cpp.

                                      {
    // Call the base class initializer
    LinsolInternal::init(opts);
 
    // Read options
    for (auto&& op : opts) {
      if (op.first=="equilibration") {
        equilibriate_ = op.second;
      } else if (op.first=="allow_equilibration_failure") {
        allow_equilibration_failure_ = op.second;
      }
    }
  }

References allow_equilibration_failure_, equilibriate_, and casadi::LinsolInternal::init().

init_mem()

int casadi::LapackLu::init_mem ( void *  mem ) const

overridevirtual

Reimplemented from casadi::LinsolInternal.

Definition at line 85 of file lapack_lu.cpp.

                                        {
    if (LinsolInternal::init_mem(mem)) return 0;
    auto m = static_cast<LapackLuMemory*>(mem);
 
    // Allocate matrix
    m->mat.resize(nrow() * ncol());
    m->ipiv.resize(ncol());
 
    // Equilibration
    if (equilibriate_) {
      m->r.resize(nrow());
      m->c.resize(ncol());
    }
    m->equed = 'N'; // No equilibration
    return 0;
  }

References equilibriate_, casadi::LinsolInternal::init_mem(), casadi::LapackLuMemory::mat, casadi::LinsolInternal::ncol(), and casadi::LinsolInternal::nrow().

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++;
    }

instantiate()

LinsolInternal * casadi::PluginInterface< LinsolInternal >::instantiate ( const std::string &  fname, const std::string &  pname, Problem  problem  )

staticinherited

Definition at line 106 of file plugin_interface.hpp.

                                                       {
 
    // Assert the plugin exists (needed for adaptors)
    if (!has_plugin(pname, true)) {
      casadi_error("Plugin '" + pname + "' is not found.");
    }
    return getPlugin(pname).creator(fname, problem);
  }

linsol_eval_sx()

void casadi::LinsolInternal::linsol_eval_sx ( const SXElem **  arg, SXElem **  res, casadi_int *  iw, SXElem *  w, void *  mem, bool  tr, casadi_int  nrhs  ) const

virtualinherited

Reimplemented in casadi::SymbolicQr.

Definition at line 63 of file linsol_internal.cpp.

                                                                                 {
    casadi_error("eval_sx not defined for " + class_name());
  }

References casadi::SharedObjectInternal::class_name().

load_library()

handle_t casadi::PluginInterface< LinsolInternal >::load_library ( const std::string &  libname, std::string &  resultpath, bool  global  )

staticinherited

Definition at line 92 of file plugin_interface.hpp.

                                        {
 
#ifndef WITH_DL
    casadi_error("WITH_DL option needed for dynamic loading");
#else // WITH_DL
 
    // Get the name of the shared library
    std::string lib = SHARED_LIBRARY_PREFIX + libname + SHARED_LIBRARY_SUFFIX;
 
    // Build up search paths;
    std::vector<std::string> search_paths = get_search_paths();
    return open_shared_library(lib, search_paths, resultpath,
      "PluginInterface::load_plugin", global);
 
#endif // WITH_DL
  }

load_plugin()

PluginInterface< LinsolInternal >::Plugin casadi::PluginInterface< LinsolInternal >::load_plugin ( const std::string &  pname, bool  register_plugin = true, bool  needs_lock = true  )

staticinherited

Definition at line 88 of file plugin_interface.hpp.

                                               {
 
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    casadi::conditional_lock_guard<std::mutex> lock(Derived::mutex_solvers_, needs_lock);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
 
    // Issue warning and quick return if already loaded
    if (Derived::solvers_.find(pname) != Derived::solvers_.end()) {
      casadi_warning("PluginInterface: Solver " + pname + " is already in use. Ignored.");
      return Plugin();
    }
 
    // Logger singletons are lazily instantiated on first uout()/uerr() calls
    // This instantation may lead to a data race with potential instatiations in plugin
    // To be safe, trigger instantatin before any plugin loading
    uout();
    uerr();
 
#ifndef WITH_DL
    casadi_error("WITH_DL option needed for dynamic loading");
#else // WITH_DL
    // Retrieve the registration function
    RegFcn reg;
 
    // Load the dll
    std::string regName = "casadi_register_" + Derived::infix_ + "_" + pname;
 
    std::string searchpath;
    handle_t handle = load_library("casadi_" + Derived::infix_ + "_" + pname, searchpath,
      false);
 
#ifdef _WIN32
 
#if __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-function-type"
#endif
    reg = reinterpret_cast<RegFcn>(GetProcAddress(handle, TEXT(regName.c_str())));
#if __GNUC__
#pragma GCC diagnostic pop
#endif
 
#else // _WIN32
    // Reset error
    dlerror();
 
    // Load creator
    reg = reinterpret_cast<RegFcn>(dlsym(handle, regName.c_str()));
#endif // _WIN32
    casadi_assert(reg!=nullptr,
      "PluginInterface::load_plugin: no \"" + regName + "\" found in " + searchpath + ".");
 
    // Create a temporary struct
    Plugin plugin = pluginFromRegFcn(reg);
    // Register the plugin
    if (register_plugin) {
      registerPlugin(plugin, false);
    }
 
    return plugin;
 
#endif // WITH_DL
  }

memory()

void * casadi::ProtoFunction::memory ( int  ind ) const

inherited

Definition at line 3574 of file function_internal.cpp.

                                           {
#ifdef CASADI_WITH_THREAD
    std::lock_guard<std::mutex> lock(mtx_);
#endif //CASADI_WITH_THREAD
    return mem_.at(ind);
  }

Referenced by casadi::FunctionInternal::call_gen(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::Sqpmethod::solve_ela_QP(), and casadi::Sqpmethod::solve_QP().

ncol()

casadi_int casadi::LinsolInternal::ncol ( ) const

inlineinherited

Definition at line 141 of file linsol_internal.hpp.

{ return sp_.size2();}

Referenced by casadi::LinsolQr::finalize(), casadi::LinsolQr::generate(), casadi::Lsqr::generate(), casadi::CsparseInterface::init_mem(), casadi::Ma27Interface::init_mem(), init_mem(), casadi::LapackQr::init_mem(), casadi::LinsolQr::init_mem(), casadi::Lsqr::init_mem(), casadi::Ma27Interface::nfact(), nfact(), casadi::LapackQr::nfact(), casadi::LinsolQr::nfact(), casadi::CsparseInterface::solve(), casadi::Ma27Interface::solve(), solve(), casadi::LinsolTridiag::solve(), and casadi::LapackQr::solve_batch().

neig()

casadi_int casadi::LinsolInternal::neig ( void *  mem, const double *  A  ) const

virtualinherited

Reimplemented in casadi::LinsolLdl, and casadi::Ma27Interface.

Definition at line 102 of file linsol_internal.cpp.

                                                                  {
    casadi_error("'neig' not defined for " + class_name());
  }

References casadi::SharedObjectInternal::class_name().

nfact()

int casadi::LapackLu::nfact ( void *  mem, const double *  A  ) const

overridevirtual

Reimplemented from casadi::LinsolInternal.

Definition at line 102 of file lapack_lu.cpp.

                                                      {
    auto m = static_cast<LapackLuMemory*>(mem);
 
    // Dimensions
    int nrow = this->nrow();
    int ncol = this->ncol();
 
    // Get the elements of the matrix, dense format
    casadi_densify(A, sp_, get_ptr(m->mat), false);
 
    if (equilibriate_) {
      // Calculate the col and row scaling factors
      double colcnd, rowcnd; // ratio of the smallest to the largest col/row scaling factor
      double amax; // absolute value of the largest matrix element
      int info = -100;
      dgeequ_(&ncol, &nrow, get_ptr(m->mat), &ncol, get_ptr(m->r),
              get_ptr(m->c), &colcnd, &rowcnd, &amax, &info);
      if (info < 0) return 1;
      if (info > 0) {
        std::stringstream ss;
        ss << "LapackLu::prepare: ";
        if (info<=ncol)  ss << (info-1) << "-th row (zero-based) is exactly zero";
        else             ss << (info-1-ncol) << "-th col (zero-based) is exactly zero";
        uout() << "Warning: " << ss.str() << std::endl;
        if (allow_equilibration_failure_)  uout() << "Warning: " << ss.str() << std::endl;
        else                              casadi_error(ss.str());
      }
 
      // Equilibrate the matrix if scaling was successful
      if (info!=0)
        dlaqge_(&ncol, &nrow, get_ptr(m->mat), &ncol, get_ptr(m->r), get_ptr(m->c),
                &colcnd, &rowcnd, &amax, &m->equed);
      else
        m->equed = 'N';
    }
 
    // Factorize the matrix
    int info = -100;
    dgetrf_(&ncol, &ncol, get_ptr(m->mat), &ncol, get_ptr(m->ipiv), &info);
    if (info) {
      if (verbose_) casadi_warning("dgetrf_ failed: Info: " + str(info));
      return 1;
    }
    return 0;
  }

References allow_equilibration_failure_, casadi::casadi_densify(), equilibriate_, casadi::get_ptr(), casadi::LinsolInternal::ncol(), casadi::LinsolInternal::nrow(), casadi::LinsolInternal::sp_, casadi::str(), casadi::uout(), and casadi::ProtoFunction::verbose_.

nnz()

casadi_int casadi::LinsolInternal::nnz ( ) const

inlineinherited

Definition at line 144 of file linsol_internal.hpp.

{ return sp_.nnz();}

Referenced by casadi::CsparseInterface::init_mem(), casadi::Ma27Interface::init_mem(), casadi::MumpsInterface::init_mem(), casadi::SymbolicQr::linsol_eval_sx(), casadi::CsparseInterface::nfact(), casadi::Ma27Interface::nfact(), and casadi::MumpsInterface::nfact().

nrow()

casadi_int casadi::LinsolInternal::nrow ( ) const

inlineinherited

Definition at line 140 of file linsol_internal.hpp.

{ return sp_.size1();}

Referenced by casadi::LinsolLdl::generate(), casadi::LinsolQr::generate(), casadi::Lsqr::generate(), casadi::CsparseInterface::init_mem(), init_mem(), casadi::MumpsInterface::init_mem(), casadi::LinsolLdl::init_mem(), casadi::LinsolQr::init_mem(), casadi::LinsolTridiag::init_mem(), casadi::Lsqr::init_mem(), casadi::LinsolLdl::neig(), nfact(), casadi::MumpsInterface::nfact(), casadi::LinsolLdl::rank(), solve(), casadi::LapackQr::solve(), casadi::LinsolTridiag::solve(), and casadi::SymbolicQr::solve().

plugin_deserialize()

Deserialize casadi::PluginInterface< LinsolInternal >::plugin_deserialize ( const std::string &  pname )

staticinherited

Definition at line 82 of file plugin_interface.hpp.

                                                                                 {
    Deserialize m = getPlugin(pname).deserialize;
    casadi_assert(m, "Plugin \"" + pname + "\" does not support deserialize");
    return m;
  }

plugin_name()

const char* casadi::LapackLu::plugin_name ( ) const

inlineoverrideprotectedvirtual

Implements casadi::LinsolInternal.

Definition at line 139 of file lapack_lu.hpp.

{ return "lapacklu";}

plugin_options()

const Options & casadi::PluginInterface< LinsolInternal >::plugin_options ( const std::string &  pname )

staticinherited

Definition at line 79 of file plugin_interface.hpp.

                                                                                {
    const Options *op = getPlugin(pname).options;
    casadi_assert(op!=nullptr, "Plugin \"" + pname + "\" does not support options");
    return *op;
  }

pluginFromRegFcn()

PluginInterface< LinsolInternal >::Plugin casadi::PluginInterface< LinsolInternal >::pluginFromRegFcn ( RegFcn  regfcn )

staticinherited

Definition at line 85 of file plugin_interface.hpp.

                                                              {
    // Create a temporary struct
    Plugin plugin;
 
    // Set the fields
    int flag = regfcn(&plugin);
    casadi_assert(flag==0, "Registration of plugin failed.");
 
    return plugin;
  }

print()

void casadi::ProtoFunction::print ( const char *  fmt,   ...  ) const

inherited

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

Definition at line 3813 of file function_internal.cpp.

                                                      {
    // Variable number of arguments
    va_list args;
    va_start(args, fmt);
    // Static & dynamic buffers
    char buf[256];
    size_t buf_sz = sizeof(buf);
    char* buf_dyn = nullptr;
    // Try to print with a small buffer
    casadi_int n = vsnprintf(buf, buf_sz, fmt, args);
    // Need a larger buffer?
    if (n>static_cast<casadi_int>(buf_sz)) {
      buf_sz = static_cast<size_t>(n+1);
      buf_dyn = new char[buf_sz];
      n = vsnprintf(buf_dyn, buf_sz, fmt, args);
    }
    // Print buffer content
    if (n>=0) uout() << (buf_dyn ? buf_dyn : buf) << std::flush;
    // Cleanup
    delete[] buf_dyn;
    va_end(args);
    // Throw error if failure
    casadi_assert(n>=0, "Print failure while processing '" + std::string(fmt) + "'");
  }

References casadi::uout().

Referenced by casadi::Feasiblesqpmethod::anderson_acc_step_update(), casadi::Nlpsol::callback(), casadi::Blocksqp::convertHessian(), casadi::FmuFunction::eval_task(), casadi::Feasiblesqpmethod::feasibility_iterations(), casadi::Blocksqp::feasibilityRestorationPhase(), casadi::Blocksqp::fullstep(), casadi::Blocksqp::init(), casadi::Feasiblesqpmethod::init(), casadi::Ipqp::init(), casadi::Qrqp::init(), casadi::Qrsqp::init(), casadi::Sqpmethod::init(), casadi::LinsolQr::nfact(), casadi::Feasiblesqpmethod::print_iteration(), casadi::Qrsqp::print_iteration(), casadi::Sqpmethod::print_iteration(), casadi::SundialsInterface::print_stats(), casadi::ProtoFunction::print_time(), casadi::Blocksqp::printInfo(), casadi::Blocksqp::printProgress(), casadi::Blocksqp::run(), casadi::Blocksqp::solve(), casadi::Feasiblesqpmethod::solve(), casadi::Qrsqp::solve(), casadi::Sqpmethod::solve(), casadi::Sqpmethod::solve_ela_QP(), casadi::Feasiblesqpmethod::solve_LP(), casadi::Feasiblesqpmethod::solve_QP(), casadi::Qrsqp::solve_QP(), casadi::Sqpmethod::solve_QP(), and casadi::Blocksqp::solveQP().

print_option()

void casadi::ProtoFunction::print_option ( const std::string &  name, std::ostream &  stream  ) const

inherited

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

Definition at line 916 of file function_internal.cpp.

                                                                                  {
    get_options().print_one(name, stream);
  }

References casadi::ProtoFunction::get_options(), and casadi::Options::print_one().

print_options()

void casadi::ProtoFunction::print_options ( std::ostream &  stream ) const

inherited

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

Definition at line 912 of file function_internal.cpp.

                                                            {
    get_options().print_all(stream);
  }

References casadi::ProtoFunction::get_options(), and casadi::Options::print_all().

print_time()

void casadi::ProtoFunction::print_time ( const std::map< std::string, FStats > &  fstats ) const

inherited

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

Definition at line 3733 of file function_internal.cpp.

                                                                              {
    if (!print_time_) return;
    // Length of the name being printed
    size_t name_len=0;
    for (auto &&s : fstats) {
      name_len = std::max(s.first.size(), name_len);
    }
    name_len = std::max(name_.size(), name_len);
 
    // Print name with a given length. Format: "%NNs "
    char namefmt[10];
    sprint(namefmt, sizeof(namefmt), "%%%ds ", static_cast<casadi_int>(name_len));
 
    // Print header
    print(namefmt, name_.c_str());
 
    print(" : %8s %10s %8s %10s %9s\n", "t_proc", "(avg)", "t_wall", "(avg)", "n_eval");
 
 
    char buffer_proc[10];
    char buffer_wall[10];
    char buffer_proc_avg[10];
    char buffer_wall_avg[10];
 
    // Print keys
    for (const auto &s : fstats) {
      if (s.second.n_call!=0) {
        print(namefmt, s.first.c_str());
        format_time(buffer_proc, s.second.t_proc);
        format_time(buffer_wall, s.second.t_wall);
        format_time(buffer_proc_avg, s.second.t_proc/s.second.n_call);
        format_time(buffer_wall_avg, s.second.t_wall/s.second.n_call);
        print(" | %s (%s) %s (%s) %9d\n",
          buffer_proc, buffer_proc_avg,
          buffer_wall, buffer_wall_avg, s.second.n_call);
      }
    }
  }

References casadi::ProtoFunction::format_time(), casadi::ProtoFunction::name_, casadi::ProtoFunction::print(), casadi::ProtoFunction::print_time_, and casadi::ProtoFunction::sprint().

Referenced by casadi::FunctionInternal::eval_gen().

rank()

casadi_int casadi::LinsolInternal::rank ( void *  mem, const double *  A  ) const

virtualinherited

Reimplemented in casadi::LinsolLdl, and casadi::Ma27Interface.

Definition at line 106 of file linsol_internal.cpp.

                                                                  {
    casadi_error("'rank' not defined for " + class_name());
  }

References casadi::SharedObjectInternal::class_name().

registerPlugin() [1/2]

void casadi::PluginInterface< LinsolInternal >::registerPlugin ( const Plugin &  plugin, bool  needs_lock = true  )

staticinherited

Definition at line 96 of file plugin_interface.hpp.

                                                                                     {
 
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    casadi::conditional_lock_guard<std::mutex> lock(Derived::mutex_solvers_, needs_lock);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
 
    // Check if the solver name is in use
    typename std::map<std::string, Plugin>::iterator it=Derived::solvers_.find(plugin.name);
    casadi_assert(it==Derived::solvers_.end(),
      "Solver " + str(plugin.name) + " is already in use");
 
    // Add to list of solvers
    Derived::solvers_[plugin.name] = plugin;
  }

registerPlugin() [2/2]

void casadi::PluginInterface< LinsolInternal >::registerPlugin ( RegFcn  regfcn, bool  needs_lock = true  )

staticinherited

Definition at line 99 of file plugin_interface.hpp.

                                                                              {
    registerPlugin(pluginFromRegFcn(regfcn), needs_lock);
  }

release()

void casadi::ProtoFunction::release ( int  mem ) const

inherited

Definition at line 3606 of file function_internal.cpp.

                                           {
#ifdef CASADI_WITH_THREAD
    std::lock_guard<std::mutex> lock(mtx_);
#endif //CASADI_WITH_THREAD
    unused_.push(mem);
  }

row()

const casadi_int* casadi::LinsolInternal::row ( ) const

inlineinherited

Definition at line 143 of file linsol_internal.hpp.

{ return sp_.row();}

Referenced by casadi::CsparseInterface::init_mem(), casadi::MumpsInterface::init_mem(), casadi::Ma27Interface::nfact(), and casadi::MumpsInterface::nfact().

serialize()

void casadi::ProtoFunction::serialize ( SerializingStream &  s ) const

inherited

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

Definition at line 4090 of file function_internal.cpp.

                                                          {
    serialize_type(s);
    serialize_body(s);
  }

References casadi::ProtoFunction::serialize_body(), and casadi::ProtoFunction::serialize_type().

serialize_base_function()

virtual std::string casadi::ProtoFunction::serialize_base_function ( ) const

inlinevirtualinherited

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

Reimplemented in casadi::LinearInterpolantJac, casadi::Rootfinder, casadi::Nlpsol, casadi::MapSum, casadi::Map, casadi::Interpolant, casadi::Integrator, casadi::External, casadi::Conic, and casadi::BlazingSplineFunction.

Definition at line 241 of file function_internal.hpp.

                                                      {
      return class_name();
    }

Referenced by casadi::FunctionInternal::serialize_type().

serialize_body()

void casadi::LapackLu::serialize_body ( SerializingStream &  s ) const

overridevirtual

Reimplemented from casadi::LinsolInternal.

Definition at line 197 of file lapack_lu.cpp.

                                                          {
    LinsolInternal::serialize_body(s);
    s.version("LapackLu", 1);
    s.pack("LapackLu::equilibriate", equilibriate_);
    s.pack("LapackLu::allow_equilibration_failure", allow_equilibration_failure_);
  }

References allow_equilibration_failure_, equilibriate_, casadi::SerializingStream::pack(), casadi::LinsolInternal::serialize_body(), and casadi::SerializingStream::version().

serialize_type()

void casadi::LinsolInternal::serialize_type ( SerializingStream &  s ) const

overridevirtualinherited

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

Reimplemented from casadi::ProtoFunction.

Definition at line 124 of file linsol_internal.cpp.

                                                                {
    ProtoFunction::serialize_type(s);
    PluginInterface<LinsolInternal>::serialize_type(s);
  }

References casadi::ProtoFunction::serialize_type(), and casadi::PluginInterface< Derived >::serialize_type().

sfact()

virtual int casadi::LinsolInternal::sfact ( void *  mem, const double *  A  ) const

inlinevirtualinherited

Reimplemented in casadi::LinsolTridiag, casadi::LinsolQr, casadi::LinsolLdl, casadi::CsparseInterface, and casadi::CSparseCholeskyInterface.

Definition at line 102 of file linsol_internal.hpp.

{ return 0;}

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

solve()

int casadi::LapackLu::solve ( void *  mem, const double *  A, double *  x, casadi_int  nrhs, bool  tr  ) const

overridevirtual

Reimplemented from casadi::LinsolInternal.

Definition at line 148 of file lapack_lu.cpp.

                                                                                           {
    auto m = static_cast<LapackLuMemory*>(mem);
 
    // Dimensions
    int nrow = this->nrow();
    int ncol = this->ncol();
 
    int n_rhs = nrhs;
 
    // Scale the right hand side
    if (tr) {
      if (m->equed=='C' || m->equed=='B')
        for (casadi_int rhs=0; rhs<nrhs; ++rhs)
          for (casadi_int i=0; i<nrow; ++i)
            x[i+rhs*nrow] *= m->c[i];
    } else {
      if (m->equed=='R' || m->equed=='B')
        for (casadi_int rhs=0; rhs<nrhs; ++rhs)
          for (casadi_int i=0; i<ncol; ++i)
            x[i+rhs*nrow] *= m->r[i];
    }
 
    // Solve the system of equations
    int info = 100;
    char trans = tr ? 'T' : 'N';
    dgetrs_(&trans, &ncol, &n_rhs, get_ptr(m->mat), &ncol, get_ptr(m->ipiv), x, &ncol, &info);
    if (info) return 1;
 
    // Scale the solution
    if (tr) {
      if (m->equed=='R' || m->equed=='B')
        for (casadi_int rhs=0; rhs<nrhs; ++rhs)
          for (casadi_int i=0; i<ncol; ++i)
            x[i+rhs*nrow] *= m->r[i];
    } else {
      if (m->equed=='C' || m->equed=='B')
        for (casadi_int rhs=0; rhs<nrhs; ++rhs)
          for (casadi_int i=0; i<nrow; ++i)
            x[i+rhs*nrow] *= m->c[i];
    }
    return 0;
  }

References casadi::get_ptr(), casadi::LinsolInternal::ncol(), and casadi::LinsolInternal::nrow().

sprint()

void casadi::ProtoFunction::sprint ( char *  buf, size_t  buf_sz, const char *  fmt,   ...  ) const

inherited

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

Definition at line 3801 of file function_internal.cpp.

                                                                                 {
    // Variable number of arguments
    va_list args;
    va_start(args, fmt);
    // Print to buffer
    casadi_int n = vsnprintf(buf, buf_sz, fmt, args);
    // Cleanup
    va_end(args);
    // Throw error if failure
    casadi_assert(n>=0 && n<buf_sz, "Print failure while processing '" + std::string(fmt) + "'");
  }

Referenced by casadi::ProtoFunction::format_time(), and casadi::ProtoFunction::print_time().

weak()

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

inherited

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

Definition at line 67 of file generic_shared_internal.hpp.

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

Member Data Documentation

allow_equilibration_failure_

bool casadi::LapackLu::allow_equilibration_failure_

protected

Definition at line 136 of file lapack_lu.hpp.

Referenced by init(), LapackLu(), nfact(), and serialize_body().

equilibriate_

bool casadi::LapackLu::equilibriate_

protected

Definition at line 133 of file lapack_lu.hpp.

Referenced by init(), init_mem(), LapackLu(), nfact(), and serialize_body().

error_on_fail_

bool casadi::ProtoFunction::error_on_fail_

inherited

Definition at line 261 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::call_gen(), casadi::ClarabelInterface::codegen_body(), casadi::DaqpInterface::codegen_body(), casadi::FatropInterface::codegen_body(), casadi::HighsInterface::codegen_body(), casadi::HpipmInterface::codegen_body(), casadi::IpoptInterface::codegen_body(), casadi::MadnlpInterface::codegen_body(), casadi::OsqpInterface::codegen_body(), casadi::Qrqp::codegen_body(), casadi::Conic::Conic(), casadi::Conic::eval(), casadi::Nlpsol::eval(), casadi::Rootfinder::eval(), casadi::ProtoFunction::generate_options(), casadi::ProtoFunction::init(), casadi::Nlpsol::Nlpsol(), casadi::ProtoFunction::ProtoFunction(), casadi::Rootfinder::Rootfinder(), casadi::ProtoFunction::serialize_body(), and casadi::KinsolInterface::solve().

infix_

const std::string casadi::LinsolInternal::infix_ = "linsol"

staticinherited

Definition at line 134 of file linsol_internal.hpp.

meta_doc

const std::string casadi::LapackLu::meta_doc

static

Initial value:

=
      "\n"
"\n"
"\n"
"This class solves the linear system  A.x=b by making an LU factorization of A:  A = L.U, with L lower and U upper triangular\n"
"\n"
"Extra doc: https://github.com/casadi/casadi/wiki/L_22h \n"
"\n"
"\n"
">List of available options\n"
"\n"
"+-----------------------------+---------+----------------------------------+\n"
"|             Id              |  Type   |           Description            |\n"
"+=============================+=========+==================================+\n"
"| allow_equilibration_failure | OT_BOOL | Non-fatal error when             |\n"
"|                             |         | equilibration fails              |\n"
"+-----------------------------+---------+----------------------------------+\n"
"| equilibration               | OT_BOOL | Equilibrate the matrix           |\n"
"+-----------------------------+---------+----------------------------------+\n"
"\n"
"\n"
"\n"
"\n"

Definition at line 120 of file lapack_lu.hpp.

Referenced by casadi::casadi_register_linsol_lapacklu().

name_

std::string casadi::ProtoFunction::name_

inherited

Definition at line 246 of file function_internal.hpp.

Referenced by casadi::MXFunction::ad_forward(), casadi::SXFunction::ad_forward(), casadi::MXFunction::ad_reverse(), casadi::SXFunction::ad_reverse(), casadi::Integrator::augmented_dae(), casadi::OracleFunction::calc_function(), casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::call_reverse(), casadi::FunctionInternal::codegen_body(), casadi::External::codegen_body(), casadi::External::codegen_checkout(), casadi::External::codegen_declarations(), casadi::MXFunction::codegen_declarations(), casadi::SXFunction::codegen_declarations(), casadi::External::codegen_decref(), casadi::External::codegen_incref(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::codegen_name(), casadi::External::codegen_release(), casadi::FunctionInternal::codegen_sparsities(), casadi::ProtoFunction::construct(), casadi::OracleFunction::create_function(), casadi::FunctionInternal::definition(), casadi::FunctionInternal::eval(), casadi::MXFunction::eval(), casadi::SXFunction::eval(), casadi::FunctionInternal::eval_mx(), casadi::MXFunction::eval_mx(), casadi::SXFunction::eval_mx(), casadi::SXFunction::eval_sx(), casadi::FmuFunction::factory(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::forward(), casadi::FunctionInternal::FunctionInternal(), casadi::Integrator::get_forward(), casadi::Integrator::get_forward_dae(), casadi::Map::get_function(), casadi::MapSum::get_function(), casadi::OracleFunction::get_function(), casadi::GenericExternal::get_jac_sparsity(), casadi::BlazingSplineFunction::get_jacobian(), casadi::FunctionInternal::get_n_in(), casadi::External::get_n_in(), casadi::FunctionInternal::get_n_out(), casadi::External::get_n_out(), casadi::FunctionInternal::get_name_in(), casadi::External::get_name_in(), casadi::FunctionInternal::get_name_out(), casadi::External::get_name_out(), casadi::FunctionInternal::get_partition(), casadi::Integrator::get_reverse(), casadi::FunctionInternal::get_sparsity_in(), casadi::GenericExternal::get_sparsity_in(), casadi::FunctionInternal::get_sparsity_out(), casadi::GenericExternal::get_sparsity_out(), casadi::FunctionInternal::get_stats(), casadi::External::has_forward(), casadi::GenericExternal::has_jac_sparsity(), casadi::External::has_jacobian(), casadi::External::has_reverse(), casadi::External::init(), casadi::FunctionInternal::init(), casadi::MXFunction::init(), casadi::SXFunction::init(), casadi::CvodesInterface::init(), casadi::IdasInterface::init(), casadi::External::init_external(), casadi::GenericExternal::init_external(), casadi::FunctionInternal::jac_is_symm(), casadi::FunctionInternal::jacobian(), casadi::FunctionInternal::map(), casadi::OracleFunction::monitored(), casadi::MXFunction::print_arg(), casadi::FunctionInternal::print_in(), casadi::FunctionInternal::print_out(), casadi::MXFunction::print_res(), casadi::ProtoFunction::print_time(), casadi::ProtoFunction::ProtoFunction(), casadi::CvodesInterface::reset(), casadi::IdasInterface::reset(), casadi::IdasInterface::resetB(), casadi::FunctionInternal::reverse(), casadi::ProtoFunction::serialize_body(), casadi::GurobiInterface::solve(), casadi::SnoptInterface::solve(), casadi::Integrator::sp_forward(), casadi::Integrator::sp_reverse(), casadi::FunctionInternal::wrap(), and casadi::FunctionInternal::wrap_as_needed().

options_

const Options casadi::LapackLu::options_

static

Initial value:

= {{&FunctionInternal::options_},
     {{"equilibration",
       {OT_BOOL,
        "Equilibrate the matrix"}},
      {"allow_equilibration_failure",
       {OT_BOOL,
        "Non-fatal error when equilibration fails"}}
     }
  }

Definition at line 97 of file lapack_lu.hpp.

Referenced by casadi::casadi_register_linsol_lapacklu().

print_time_

bool casadi::ProtoFunction::print_time_

inherited

Definition at line 252 of file function_internal.hpp.

Referenced by casadi::FixedStepIntegrator::create_advanced(), casadi::ProtoFunction::generate_options(), casadi::ProtoFunction::init(), casadi::FunctionInternal::init(), casadi::Nlpsol::Nlpsol(), casadi::ProtoFunction::print_time(), casadi::ProtoFunction::ProtoFunction(), and casadi::ProtoFunction::serialize_body().

record_time_

bool casadi::ProtoFunction::record_time_

inherited

Definition at line 255 of file function_internal.hpp.

Referenced by casadi::ProtoFunction::generate_options(), casadi::ProtoFunction::init(), casadi::FunctionInternal::init(), casadi::ProtoFunction::init_mem(), casadi::LinsolInternal::init_mem(), casadi::ProtoFunction::ProtoFunction(), and casadi::ProtoFunction::serialize_body().

regularity_check_

bool casadi::ProtoFunction::regularity_check_

inherited

Definition at line 258 of file function_internal.hpp.

Referenced by casadi::OracleFunction::calc_function(), casadi::ProtoFunction::change_option(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::FunctionInternal(), casadi::ProtoFunction::generate_options(), casadi::ProtoFunction::init(), casadi::ProtoFunction::ProtoFunction(), and casadi::ProtoFunction::serialize_body().

solvers_

std::map< std::string, LinsolInternal::Plugin > casadi::LinsolInternal::solvers_

staticinherited

Definition at line 127 of file linsol_internal.hpp.

sp_

Sparsity casadi::LinsolInternal::sp_

inherited

Definition at line 161 of file linsol_internal.hpp.

Referenced by casadi::LinsolQr::finalize(), casadi::LinsolLdl::generate(), casadi::LinsolQr::generate(), casadi::Lsqr::generate(), casadi::LinsolLdl::init(), casadi::LinsolQr::init(), casadi::SymbolicQr::init(), casadi::MumpsInterface::init_mem(), casadi::Lsqr::init_mem(), casadi::SymbolicQr::init_mem(), casadi::SymbolicQr::linsol_eval_sx(), casadi::LinsolInternal::LinsolInternal(), casadi::CsparseInterface::nfact(), nfact(), casadi::LapackQr::nfact(), casadi::LinsolLdl::nfact(), casadi::LinsolQr::nfact(), casadi::LinsolInternal::serialize_body(), casadi::LinsolTridiag::solve(), and casadi::Lsqr::solve().

verbose_

bool casadi::ProtoFunction::verbose_

inherited

Definition at line 249 of file function_internal.hpp.

Referenced by casadi::MXFunction::ad_forward(), casadi::SXFunction::ad_forward(), casadi::MXFunction::ad_reverse(), casadi::SXFunction::ad_reverse(), casadi::Integrator::advance(), casadi::ProtoFunction::change_option(), casadi::BSplineInterpolant::construct_graph(), casadi::OracleFunction::create_function(), casadi::FmuFunction::eval(), casadi::Integrator::eval(), casadi::MXFunction::eval(), casadi::SXFunction::eval(), casadi::MXFunction::eval_mx(), casadi::SXFunction::eval_mx(), casadi::SXFunction::eval_sx(), casadi::FmuFunction::factory(), casadi::FunctionInternal::finalize(), casadi::KinsolInterface::func(), casadi::ProtoFunction::generate_options(), casadi::FmuFunction::get_forward(), casadi::Integrator::get_forward(), casadi::Integrator::get_forward_dae(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::FmuFunction::get_jacobian(), casadi::FunctionInternal::get_partition(), casadi::FmuFunction::get_reverse(), casadi::Integrator::get_reverse(), casadi::ProtoFunction::init(), casadi::FiniteDiff::init(), casadi::FmuFunction::init(), casadi::FunctionInternal::init(), casadi::MXFunction::init(), casadi::SXFunction::init(), casadi::Blocksqp::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HpipmInterface::init(), casadi::HpmpcInterface::init(), casadi::IpoptInterface::init(), casadi::MadnlpInterface::init(), casadi::CvodesInterface::init(), casadi::IdasInterface::init(), casadi::Feasiblesqpmethod::init(), casadi::Scpgen::init(), casadi::Sqpmethod::init(), casadi::IpoptInterface::init_mem(), casadi::IdasInterface::init_mem(), casadi::SXFunction::instructions_sx(), casadi::BonminInterface::intermediate_callback(), casadi::OracleFunction::jit_dependencies(), casadi::CsparseInterface::nfact(), nfact(), casadi::LapackQr::nfact(), casadi::LinsolQr::nfact(), casadi::Integrator::predict_events(), casadi::ProtoFunction::ProtoFunction(), casadi::CvodesInterface::reset(), casadi::IdasInterface::reset(), casadi::IdasInterface::resetB(), casadi::ProtoFunction::serialize_body(), casadi::CbcInterface::solve(), casadi::ClpInterface::solve(), casadi::CplexInterface::solve(), casadi::GurobiInterface::solve(), casadi::HpipmInterface::solve(), casadi::QpoasesInterface::solve(), casadi::Ipqp::solve(), casadi::Qrqp::solve(), casadi::AlpaqaInterface::solve(), casadi::AmplInterface::solve(), casadi::SnoptInterface::solve(), casadi::KinsolInterface::solve(), casadi::WorhpInterface::solve(), casadi::Newton::solve(), casadi::Qrsqp::solve(), casadi::Scpgen::solve(), casadi::Sqpmethod::solve(), casadi::Sqpmethod::solve_ela_QP(), casadi::Feasiblesqpmethod::solve_LP(), casadi::Feasiblesqpmethod::solve_QP(), casadi::Qrsqp::solve_QP(), casadi::Sqpmethod::solve_QP(), casadi::Integrator::sp_forward(), casadi::Integrator::sp_reverse(), and casadi::Integrator::trigger_event().

---

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

• lapack_lu.hpp
• lapack_lu.cpp
• lapack_lu_meta.cpp