List of all members | Classes | Public Types | Public Member Functions | Static Public Member Functions | Public Attributes
casadi::CodeGenerator Class Reference

Helper class for C code generation. More...

#include <code_generator.hpp>

Detailed Description

Author
Joel Andersson
Date
2016

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

Definition at line 43 of file code_generator.hpp.

Classes

struct  FunctionMeta
 

Public Types

enum  Auxiliary {
  AUX_COPY , AUX_CVX , AUX_CONVEXIFY , AUX_SWAP ,
  AUX_SCAL , AUX_AXPY , AUX_DOT , AUX_BILIN ,
  AUX_RANK1 , AUX_NORM_1 , AUX_NORM_2 , AUX_CLIP_MAX ,
  AUX_CLIP_MIN , AUX_VECTOR_FMAX , AUX_VECTOR_FMIN , AUX_NORM_INF ,
  AUX_MASKED_NORM_INF , AUX_IAMAX , AUX_CLEAR , AUX_FILL ,
  AUX_MV , AUX_MV_DENSE , AUX_MTIMES , AUX_TRILSOLVE ,
  AUX_TRIUSOLVE , AUX_PROJECT , AUX_TRI_PROJECT , AUX_DENSIFY ,
  AUX_SPARSIFY , AUX_TRANS , AUX_TO_MEX , AUX_FROM_MEX ,
  AUX_INTERPN , AUX_INTERPN_GRAD , AUX_FLIP , AUX_INTERPN_WEIGHTS ,
  AUX_LOW , AUX_INTERPN_INTERPOLATE , AUX_DE_BOOR , AUX_ND_BOOR_EVAL ,
  AUX_FINITE_DIFF , AUX_QR , AUX_QP , AUX_QRQP ,
  AUX_NLP , AUX_SQPMETHOD , AUX_FEASIBLESQPMETHOD , AUX_LDL ,
  AUX_NEWTON , AUX_TO_DOUBLE , AUX_TO_INT , AUX_CAST ,
  AUX_SQ , AUX_SIGN , AUX_IF_ELSE , AUX_PRINTF ,
  AUX_FMIN , AUX_FMAX , AUX_FABS , AUX_MIN ,
  AUX_MAX , AUX_VFMIN , AUX_VFMAX , AUX_MAX_VIOL ,
  AUX_SUM_VIOL , AUX_SUM , AUX_REGULARIZE , AUX_INF ,
  AUX_NAN , AUX_REAL_MIN , AUX_ISINF , AUX_BOUNDS_CONSISTENCY ,
  AUX_LSQR , AUX_FILE_SLURP , AUX_CACHE , AUX_LOG1P ,
  AUX_EXPM1 , AUX_HYPOT , AUX_MMIN , AUX_MMAX ,
  AUX_LOGSUMEXP , AUX_SPARSITY , AUX_BFGS , AUX_ORACLE_CALLBACK ,
  AUX_OCP_BLOCK , AUX_ORACLE , AUX_SCALED_COPY , AUX_BLAZING_DE_BOOR ,
  AUX_BLAZING_1D_BOOR_EVAL , AUX_BLAZING_2D_BOOR_EVAL , AUX_BLAZING_3D_BOOR_EVAL , AUX_PRINTME ,
  AUX_PRINT_SCALAR , AUX_PRINT_VECTOR , AUX_PRINT_CANONICAL
}
 Auxiliary functions. More...
 

Public Member Functions

 CodeGenerator (const std::string &name, const Dict &opts=Dict())
 Constructor. More...
 
void add (const Function &f, bool with_jac_sparsity=false)
 Add a function (name generated) More...
 
void dump (std::ostream &s)
 Generate the code to a stream. More...
 
std::string dump ()
 Generate a file, return code as string. More...
 
std::string generate (const std::string &prefix="")
 Generate file(s) More...
 
void add_include (const std::string &new_include, bool relative_path=false, const std::string &use_ifdef=std::string())
 Add an include file optionally using a relative path "..." instead of an absolute path <...> More...
 
std::string add_dependency (const Function &f)
 Add a function dependency. More...
 
void add_external (const std::string &new_external)
 Add an external function declaration. More...
 
std::string shorthand (const std::string &name) const
 Get a shorthand. More...
 
std::string shorthand (const std::string &name, bool allow_adding=true)
 Add/get a shorthand. More...
 
std::string sparsity (const Sparsity &sp, bool canonical=true)
 
casadi_int add_sparsity (const Sparsity &sp, bool canonical=true)
 
casadi_int get_sparsity (const Sparsity &sp) const
 Get the index of an existing sparsity pattern. More...
 
casadi_int get_constant (const std::vector< double > &v, bool allow_adding=false)
 Get or add a constant. More...
 
casadi_int get_constant (const std::vector< casadi_int > &v, bool allow_adding=false)
 Get or add an integer constant. More...
 
casadi_int get_constant (const std::vector< char > &v, bool allow_adding=false)
 Get or add a char constant. More...
 
casadi_int get_constant (const std::vector< std::string > &v, bool allow_adding=false)
 Get or add a vector<string> constant. More...
 
std::string constant (const std::vector< casadi_int > &v)
 Represent an array constant; adding it when new. More...
 
std::string constant (const std::vector< int > &v)
 Represent an array constant; adding it when new. More...
 
void constant_copy (const std::string &var_name, const std::vector< casadi_int > &v, const std::string &type="casadi_int")
 Represent an array constant; adding it when new. More...
 
std::string constant (const std::vector< double > &v)
 Represent an array constant; adding it when new. More...
 
std::string constant (const std::vector< char > &v)
 Represent an array constant; adding it when new. More...
 
std::string constant (const std::vector< std::string > &v)
 Represent an array constant; adding it when new. More...
 
void define_rom_double (const void *id, casadi_int size)
 Allocate file scope double read-only memory. More...
 
std::string rom_double (const void *id) const
 Access file scope double read-only memory. More...
 
void define_rom_integer (const void *id, casadi_int size)
 Allocate file scope integer read-only memory. More...
 
std::string rom_integer (const void *id) const
 Access file scope integer read-only memory. More...
 
void define_pool_double (const std::string &name, const std::vector< double > &def)
 Allocate file scope double writeable memory. More...
 
std::string pool_double (const std::string &name) const
 Access file scope double writeable memory. More...
 
void setup_callback (const std::string &s, const Function &f)
 Setup a callback. More...
 
std::string operator() (const Function &f, const std::string &arg, const std::string &res, const std::string &iw, const std::string &w, const std::string &failure_ret="1")
 Generate a call to a function (generic signature) More...
 
CodeGenerator & operator<< (const std::string &s)
 Print a string to buffer. More...
 
void print_formatted (const std::string &s)
 Print without newline characters. More...
 
template<typename T >
CodeGenerator & operator<< (T s)
 Print an arbitrary type to buffer. More...
 
void flush (std::ostream &s)
 Flush the buffer to a stream of choice. More...
 
void local (const std::string &name, const std::string &type, const std::string &ref="")
 Declare a local variable. More...
 
void scope_enter ()
 Enter a local scope. More...
 
void scope_exit ()
 Exit a local scope. More...
 
std::string sx_work (casadi_int i)
 Declare a work vector element. More...
 
void init_local (const std::string &name, const std::string &def)
 Specify the default value for a local variable. More...
 
void indent ()
 Increase indentation. More...
 
void unindent ()
 Decrease indentation. More...
 
bool avoid_stack () const
 Avoid stack? More...
 
std::string constant (double v)
 Print a constant in a lossless but compact manner. More...
 
std::string constant (casadi_int v)
 
std::string constant (const std::string &v)
 
std::string constant (char v)
 
std::string format_padded (casadi_int i) const
 
std::string zeros (casadi_int sz)
 
std::string ones (casadi_int sz)
 
template<typename T >
std::string initializer (const std::vector< T > &v)
 Print an initializer. More...
 
std::string sanitize_source (const std::string &src, const std::vector< std::string > &inst, bool add_shorthand=true)
 Sanitize source files for codegen. More...
 
std::string dot (casadi_int n, const std::string &x, const std::string &y)
 Codegen inner product. More...
 
std::string mv (const std::string &x, const Sparsity &sp_x, const std::string &y, const std::string &z, bool tr)
 Codegen sparse matrix-vector multiplication. More...
 
std::string mv (const std::string &x, casadi_int nrow_x, casadi_int ncol_x, const std::string &y, const std::string &z, bool tr)
 Codegen dense matrix-vector multiplication. More...
 
std::string axpy (casadi_int n, const std::string &a, const std::string &x, const std::string &y)
 Codegen axpy: y += a*x. More...
 
std::string clip_min (const std::string &x, casadi_int n, const std::string &min, const std::string &mask)
 Codegen clip_min: Clips the smaller entries in a vector than min to the min. More...
 
std::string clip_max (const std::string &x, casadi_int n, const std::string &min, const std::string &mask)
 Codegen clip_max: Clips the larger entries in a vector than max to the max. More...
 
std::string vector_fmax (casadi_int n, const std::string &x, const std::string &y, const std::string &z)
 Codegen vector_fmax: Takes vectorwise max of a vector and writes the result to second vector. More...
 
std::string vector_fmin (casadi_int n, const std::string &x, const std::string &y, const std::string &z)
 Codegen vector_fmin: Takes vectorwise min of a vector and writes the result to second vector. More...
 
std::string masked_norm_inf (casadi_int n, const std::string &x, const std::string &mask)
 codegen masked_norm_inf: The mask tells what entry is used in the inf-norm. More...
 
std::string scal (casadi_int n, const std::string &alpha, const std::string &x)
 What does scal do?? More...
 
std::string mtimes (const std::string &x, const Sparsity &sp_x, const std::string &y, const Sparsity &sp_y, const std::string &z, const Sparsity &sp_z, const std::string &w, bool tr)
 Codegen sparse matrix-matrix multiplication. More...
 
std::string trilsolve (const Sparsity &sp_x, const std::string &x, const std::string &y, bool tr, bool unity, casadi_int nrhs)
 Codegen lower triangular solve. More...
 
std::string triusolve (const Sparsity &sp_x, const std::string &x, const std::string &y, bool tr, bool unity, casadi_int nrhs)
 Codegen upper triangular solve. More...
 
std::string bilin (const std::string &A, const Sparsity &sp_A, const std::string &x, const std::string &y)
 Codegen bilinear form. More...
 
std::string rank1 (const std::string &A, const Sparsity &sp_A, const std::string &alpha, const std::string &x, const std::string &y)
 Rank-1 update. More...
 
std::string logsumexp (const std::string &A, casadi_int n)
 
std::string interpn (const std::string &res, casadi_int ndim, const std::string &grid, const std::string &offset, const std::string &values, const std::string &x, const std::string &lookup_mode, casadi_int m, const std::string &iw, const std::string &w)
 Multilinear interpolation. More...
 
std::string interpn_grad (const std::string &grad, casadi_int ndim, const std::string &grid, const std::string &offset, const std::string &values, const std::string &x, const std::string &lookup_mode, casadi_int m, const std::string &iw, const std::string &w)
 Multilinear interpolation - calculate gradient. More...
 
std::string trans (const std::string &x, const Sparsity &sp_x, const std::string &y, const Sparsity &sp_y, const std::string &iw)
 Transpose. More...
 
std::string qr (const std::string &sp, const std::string &A, const std::string &w, const std::string &sp_v, const std::string &v, const std::string &sp_r, const std::string &r, const std::string &beta, const std::string &prinv, const std::string &pc)
 QR factorization. More...
 
std::string qr_solve (const std::string &x, casadi_int nrhs, bool tr, const std::string &sp_v, const std::string &v, const std::string &sp_r, const std::string &r, const std::string &beta, const std::string &prinv, const std::string &pc, const std::string &w)
 QR solve. More...
 
std::string lsqr_solve (const std::string &A, const std::string &x, casadi_int nrhs, bool tr, const std::string &sp, const std::string &w)
 
std::string ldl (const std::string &sp_a, const std::string &a, const std::string &sp_lt, const std::string &lt, const std::string &d, const std::string &p, const std::string &w)
 LDL factorization. More...
 
std::string ldl_solve (const std::string &x, casadi_int nrhs, const std::string &sp_lt, const std::string &lt, const std::string &d, const std::string &p, const std::string &w)
 LDL solve. More...
 
std::string fmax (const std::string &x, const std::string &y)
 fmax More...
 
std::string fmin (const std::string &x, const std::string &y)
 fmin More...
 
std::string mmax (const std::string &x, casadi_int n, bool is_dense)
 mmax More...
 
std::string mmin (const std::string &x, casadi_int n, bool is_dense)
 mmin More...
 
std::string vfmax (const std::string &x, casadi_int n, const std::string &y)
 vfmax More...
 
std::string vfmin (const std::string &x, casadi_int n, const std::string &y)
 vfmin More...
 
std::string vfmax (const std::string &x, const std::string &n, const std::string &y)
 vfmax More...
 
std::string vfmin (const std::string &x, const std::string &n, const std::string &y)
 vfmin More...
 
std::string max (const std::string &x, const std::string &y)
 max More...
 
std::string min (const std::string &x, const std::string &y)
 min More...
 
std::string norm_inf (casadi_int n, const std::string &x)
 norm_inf More...
 
std::string norm_1 (casadi_int n, const std::string &x)
 norm_1 More...
 
std::string norm_2 (casadi_int n, const std::string &x)
 norm_2 More...
 
std::string max_viol (casadi_int n, const std::string &x, const std::string &lb, const std::string &ub)
 max_viol More...
 
std::string sum_viol (casadi_int n, const std::string &x, const std::string &lb, const std::string &ub)
 sum_viol More...
 
std::string bound_consistency (casadi_int n, const std::string &x, const std::string &lam, const std::string &lbx, const std::string &ubx)
 bound_consistency More...
 
std::string lb_eig (const Sparsity &sp_h, const std::string &h)
 lb_eig More...
 
std::string regularize (const Sparsity &sp_h, const std::string &h, const std::string &reg)
 regularize More...
 
std::string convexify_eval (const ConvexifyData &d, const std::string &Hin, const std::string &Hout, const std::string &iw, const std::string &w)
 convexify More...
 
std::string low (const std::string &x, const std::string &grid, casadi_int ng, casadi_int lookup_mode)
 low More...
 
std::string declare (std::string s)
 Declare a function. More...
 
void comment (const std::string &s)
 Write a comment line (ignored if not verbose) More...
 
void add_auxiliary (Auxiliary f, const std::vector< std::string > &inst={"casadi_real"})
 Add a built-in auxiliary function. More...
 
void add_io_sparsities (const std::string &name, const std::vector< Sparsity > &sp_in, const std::vector< Sparsity > &sp_out)
 Add io sparsity patterns of a function. More...
 
std::string work (casadi_int n, casadi_int sz, bool is_ref) const
 
std::string workel (casadi_int n) const
 
void reserve_work (casadi_int n)
 Reserve a maximum size of work elements, used for padding of index. More...
 
void print_vector (std::ostream &s, const std::string &name, const std::vector< casadi_int > &v)
 Print casadi_int vector to a c file. More...
 
void print_vector (std::ostream &s, const std::string &name, const std::vector< char > &v)
 Print char vector to a c file. More...
 
void print_vector (std::ostream &s, const std::string &name, const std::vector< double > &v)
 Print real vector to a c file. More...
 
void print_vector (std::ostream &s, const std::string &name, const std::vector< std::string > &v)
 Print string vector to a c file. More...
 
std::string print_canonical (const Sparsity &sp, const std::string &arg)
 Print canonical representaion of a matrix. More...
 
std::string print_vector (casadi_int sz, const std::string &arg)
 Print canonical representaion of a vector. More...
 
std::string print_scalar (const std::string &arg)
 Print canonical representaion of a scalar. More...
 
std::string copy (const std::string &arg, std::size_t n, const std::string &res)
 Create a copy operation. More...
 
void copy_check (const std::string &arg, std::size_t n, const std::string &res, bool check_lhs=true, bool check_rhs=true)
 
void copy_default (const std::string &arg, std::size_t n, const std::string &res, const std::string &def, bool check_rhs=true)
 
bool elide_copy (casadi_int sz)
 
std::string fill (const std::string &res, std::size_t n, const std::string &v)
 Create a fill operation. More...
 
std::string clear (const std::string &res, std::size_t n)
 Create a fill operation. More...
 
std::string arg (casadi_int i) const
 Refer to argument. More...
 
std::string res (casadi_int i) const
 Refer to resuly. More...
 
std::string mem (const Function &f)
 Access thread-local memory. More...
 
std::string project (const std::string &arg, const Sparsity &sp_arg, const std::string &res, const Sparsity &sp_res, const std::string &w)
 Sparse assignment. More...
 
std::string tri_project (const std::string &arg, const Sparsity &sp_arg, const std::string &res, bool lower)
 Project triangular part. More...
 
std::string densify (const std::string &arg, const Sparsity &sp_arg, const std::string &res, bool tr=false)
 Densify. More...
 
std::string sparsify (const std::string &arg, const std::string &res, const Sparsity &sp_res, bool tr=false)
 Sparsify. More...
 
std::string to_mex (const Sparsity &sp, const std::string &arg)
 Create matrix in MATLAB's MEX format. More...
 
std::string from_mex (std::string &arg, const std::string &res, std::size_t res_off, const Sparsity &sp_res, const std::string &w)
 Get matrix from MATLAB's MEX format. More...
 
std::string printf (const std::string &str, const std::vector< std::string > &arg=std::vector< std::string >())
 Printf. More...
 
std::string printf (const std::string &str, const std::string &arg1)
 
std::string printf (const std::string &str, const std::string &arg1, const std::string &arg2)
 
std::string printf (const std::string &str, const std::string &arg1, const std::string &arg2, const std::string &arg3)
 
std::string print_op (casadi_int op, const std::string &a0)
 Print an operation to a c file. More...
 
std::string print_op (casadi_int op, const std::string &a0, const std::string &a1)
 
std::string file_slurp (const std::string &fname, casadi_int n, const std::string &a)
 Slurp a file. More...
 
std::string cache_check (const std::string &key, const std::string &cache, const std::string &loc, casadi_int stride, casadi_int sz, casadi_int key_sz, const std::string &val)
 cache check More...
 
void sz_work (size_t &sz_arg, size_t &sz_res, size_t &sz_iw, size_t &sz_w) const
 Get number of temporary variables needed for all functions. More...
 
std::string wrapper (const Function &base, const std::string &name)
 

Static Public Member Functions

static std::string array (const std::string &type, const std::string &name, casadi_int len, const std::string &def=std::string())
 
static std::string fmu_helpers (const std::string &modelname)
 FMU helper functions. More...
 
static std::string casadi_version ()
 Current CasADi version as string. More...
 
static void stream_open (std::ostream &f, bool cpp)
 Print file header. More...
 
static void stream_close (std::ostream &f, bool cpp)
 Print file header. More...
 
static size_t hash (const std::vector< double > &v)
 
static size_t hash (const std::vector< casadi_int > &v)
 
static size_t hash (const std::vector< char > &v)
 
static size_t hash (const std::vector< std::string > &v)
 
template<typename T >
static bool equal (const std::vector< T > &v1, const std::vector< T > &v2)
 

Public Attributes

std::string name
 
std::string suffix
 
std::string casadi_real_type
 
std::string casadi_int_type
 
bool with_mem
 
bool with_header
 
bool mex
 
bool with_sfunction
 
std::vector< std::string > added_sfunctions
 
bool unroll_args
 
bool verbose
 
bool verbose_runtime
 
bool cpp
 
bool main
 
bool include_math
 
bool avoid_stack_
 
std::string infinity
 
std::string nan
 
std::string real_min
 
bool codegen_scalars
 Codegen scalar. More...
 
bool with_export
 
bool with_import
 
casadi_int max_declarations_per_line
 
casadi_int max_initializer_elements_per_line
 
bool force_canonical
 
std::string dll_export
 
std::string dll_import
 
std::string prefix
 
std::stringstream includes
 
std::stringstream auxiliaries
 
std::stringstream body
 
std::stringstream header
 
std::stringstream buffer
 
bool newline_
 
casadi_int indent_
 
casadi_int current_indent_
 
casadi_int sz_zeros_
 
casadi_int sz_ones_
 
casadi_int padding_length_
 
std::vector< std::string > exposed_fname
 
std::set< std::string > sparsity_meta
 
std::set< std::string > added_includes_
 
std::set< std::string > added_externals_
 
std::set< std::string > added_shorthands_
 
std::multimap< Auxiliary, std::vector< std::string > > added_auxiliaries_
 
std::multimap< size_t, size_t > added_double_constants_
 
std::multimap< size_t, size_t > added_integer_constants_
 
std::multimap< size_t, size_t > added_char_constants_
 
std::multimap< size_t, size_t > added_string_constants_
 
std::map< std::string, std::pair< std::string, std::string > > local_variables_
 
std::map< std::string, std::string > local_default_
 
std::map< const void *, casadi_int > file_scope_double_
 
std::map< const void *, casadi_int > file_scope_integer_
 
std::vector< std::vector< double > > pool_double_defaults_
 
std::map< std::string, casadi_int > pool_double_
 
std::vector< FunctionMeta > added_functions_
 
std::map< std::string, std::map< FunctionInternal *, casadi_int > > added_wrappers_
 
std::vector< std::vector< double > > double_constants_
 
std::vector< std::vector< casadi_int > > integer_constants_
 
std::vector< std::vector< char > > char_constants_
 
std::vector< std::vector< std::string > > string_constants_
 
bool needs_mem_
 

Member Enumeration Documentation

◆ Auxiliary

enum casadi::CodeGenerator::Auxiliary

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

Enumerator
AUX_COPY 
AUX_CVX 
AUX_CONVEXIFY 
AUX_SWAP 
AUX_SCAL 
AUX_AXPY 
AUX_DOT 
AUX_BILIN 
AUX_RANK1 
AUX_NORM_1 
AUX_NORM_2 
AUX_CLIP_MAX 
AUX_CLIP_MIN 
AUX_VECTOR_FMAX 
AUX_VECTOR_FMIN 
AUX_NORM_INF 
AUX_MASKED_NORM_INF 
AUX_IAMAX 
AUX_CLEAR 
AUX_FILL 
AUX_MV 
AUX_MV_DENSE 
AUX_MTIMES 
AUX_TRILSOLVE 
AUX_TRIUSOLVE 
AUX_PROJECT 
AUX_TRI_PROJECT 
AUX_DENSIFY 
AUX_SPARSIFY 
AUX_TRANS 
AUX_TO_MEX 
AUX_FROM_MEX 
AUX_INTERPN 
AUX_INTERPN_GRAD 
AUX_FLIP 
AUX_INTERPN_WEIGHTS 
AUX_LOW 
AUX_INTERPN_INTERPOLATE 
AUX_DE_BOOR 
AUX_ND_BOOR_EVAL 
AUX_FINITE_DIFF 
AUX_QR 
AUX_QP 
AUX_QRQP 
AUX_NLP 
AUX_SQPMETHOD 
AUX_FEASIBLESQPMETHOD 
AUX_LDL 
AUX_NEWTON 
AUX_TO_DOUBLE 
AUX_TO_INT 
AUX_CAST 
AUX_SQ 
AUX_SIGN 
AUX_IF_ELSE 
AUX_PRINTF 
AUX_FMIN 
AUX_FMAX 
AUX_FABS 
AUX_MIN 
AUX_MAX 
AUX_VFMIN 
AUX_VFMAX 
AUX_MAX_VIOL 
AUX_SUM_VIOL 
AUX_SUM 
AUX_REGULARIZE 
AUX_INF 
AUX_NAN 
AUX_REAL_MIN 
AUX_ISINF 
AUX_BOUNDS_CONSISTENCY 
AUX_LSQR 
AUX_FILE_SLURP 
AUX_CACHE 
AUX_LOG1P 
AUX_EXPM1 
AUX_HYPOT 
AUX_MMIN 
AUX_MMAX 
AUX_LOGSUMEXP 
AUX_SPARSITY 
AUX_BFGS 
AUX_ORACLE_CALLBACK 
AUX_OCP_BLOCK 
AUX_ORACLE 
AUX_SCALED_COPY 
AUX_BLAZING_DE_BOOR 
AUX_BLAZING_1D_BOOR_EVAL 
AUX_BLAZING_2D_BOOR_EVAL 
AUX_BLAZING_3D_BOOR_EVAL 
AUX_PRINTME 
AUX_PRINT_SCALAR 
AUX_PRINT_VECTOR 
AUX_PRINT_CANONICAL 

Definition at line 598 of file code_generator.hpp.

598  {
599  AUX_COPY,
600  AUX_CVX,
601  AUX_CONVEXIFY,
602  AUX_SWAP,
603  AUX_SCAL,
604  AUX_AXPY,
605  AUX_DOT,
606  AUX_BILIN,
607  AUX_RANK1,
608  AUX_NORM_1,
609  AUX_NORM_2,
610  AUX_CLIP_MAX,
611  AUX_CLIP_MIN,
612  AUX_VECTOR_FMAX,
613  AUX_VECTOR_FMIN,
614  AUX_NORM_INF,
615  AUX_MASKED_NORM_INF,
616  AUX_IAMAX,
617  AUX_CLEAR,
618  AUX_FILL,
619  AUX_MV,
620  AUX_MV_DENSE,
621  AUX_MTIMES,
622  AUX_TRILSOLVE,
623  AUX_TRIUSOLVE,
624  AUX_PROJECT,
625  AUX_TRI_PROJECT,
626  AUX_DENSIFY,
627  AUX_SPARSIFY,
628  AUX_TRANS,
629  AUX_TO_MEX,
630  AUX_FROM_MEX,
631  AUX_INTERPN,
632  AUX_INTERPN_GRAD,
633  AUX_FLIP,
634  AUX_INTERPN_WEIGHTS,
635  AUX_LOW,
636  AUX_INTERPN_INTERPOLATE,
637  AUX_DE_BOOR,
638  AUX_ND_BOOR_EVAL,
639  AUX_FINITE_DIFF,
640  AUX_QR,
641  AUX_QP,
642  AUX_QRQP,
643  AUX_NLP,
644  AUX_SQPMETHOD,
645  AUX_FEASIBLESQPMETHOD,
646  AUX_LDL,
647  AUX_NEWTON,
648  AUX_TO_DOUBLE,
649  AUX_TO_INT,
650  AUX_CAST,
651  AUX_SQ,
652  AUX_SIGN,
653  AUX_IF_ELSE,
654  AUX_PRINTF,
655  AUX_FMIN,
656  AUX_FMAX,
657  AUX_FABS,
658  AUX_MIN,
659  AUX_MAX,
660  AUX_VFMIN,
661  AUX_VFMAX,
662  AUX_MAX_VIOL,
663  AUX_SUM_VIOL,
664  AUX_SUM,
665  AUX_REGULARIZE,
666  AUX_INF,
667  AUX_NAN,
668  AUX_REAL_MIN,
669  AUX_ISINF,
670  AUX_BOUNDS_CONSISTENCY,
671  AUX_LSQR,
672  AUX_FILE_SLURP,
673  AUX_CACHE,
674  AUX_LOG1P,
675  AUX_EXPM1,
676  AUX_HYPOT,
677  AUX_MMIN,
678  AUX_MMAX,
679  AUX_LOGSUMEXP,
680  AUX_SPARSITY,
681  AUX_BFGS,
682  AUX_ORACLE_CALLBACK,
683  AUX_OCP_BLOCK,
684  AUX_ORACLE,
685  AUX_SCALED_COPY,
686  AUX_BLAZING_DE_BOOR,
687  AUX_BLAZING_1D_BOOR_EVAL,
688  AUX_BLAZING_2D_BOOR_EVAL,
689  AUX_BLAZING_3D_BOOR_EVAL,
690  AUX_PRINTME,
691  AUX_PRINT_SCALAR,
692  AUX_PRINT_VECTOR,
693  AUX_PRINT_CANONICAL
694  };

Constructor & Destructor Documentation

◆ CodeGenerator()

casadi::CodeGenerator::CodeGenerator ( const std::string &  name,
const Dict &  opts = Dict() 
)

Definition at line 37 of file code_generator.cpp.

37  {
38  // Default options
39  this->verbose = true;
40  this->verbose_runtime = false;
41  this->mex = false;
42  this->with_sfunction = false;
43  this->unroll_args = false;
44  this->cpp = false;
45  this->main = false;
46  this->casadi_real_type = "double";
47  this->casadi_int_type = CASADI_INT_TYPE_STR;
48  this->codegen_scalars = false;
49  this->with_header = false;
50  this->with_mem = false;
51  this->with_export = true;
52  this->with_import = false;
53  this->include_math = true;
54  this->infinity = "INFINITY";
55  this->nan = "NAN";
56  this->real_min = "";
57  bool prefix_set = false;
58  this->prefix = "";
59  this->max_declarations_per_line = 12;
60  this->max_initializer_elements_per_line = 8;
61  this->force_canonical = false;
62 
63  avoid_stack_ = false;
64  indent_ = 2;
65  sz_zeros_ = 0;
66  sz_ones_ = 0;
67 
68  // Read options
69  for (auto&& e : opts) {
70  if (e.first=="verbose") {
71  this->verbose = e.second;
72  } else if (e.first=="verbose_runtime") {
73  this->verbose_runtime = e.second;
74  } else if (e.first=="mex") {
75  this->mex = e.second;
76  } else if (e.first=="with_sfunction") {
77  this->with_sfunction = e.second;
78  } else if (e.first=="unroll_args") {
79  this->unroll_args = e.second;
80  } else if (e.first=="cpp") {
81  this->cpp = e.second;
82  } else if (e.first=="main") {
83  this->main = e.second;
84  } else if (e.first=="casadi_real") {
85  this->casadi_real_type = e.second.to_string();
86  } else if (e.first=="casadi_int") {
87  this->casadi_int_type = e.second.to_string();
88  } else if (e.first=="codegen_scalars") {
89  this->codegen_scalars = e.second;
90  } else if (e.first=="with_header") {
91  this->with_header = e.second;
92  } else if (e.first=="with_mem") {
93  this->with_mem = e.second;
94  } else if (e.first=="with_export") {
95  this->with_export = e.second;
96  } else if (e.first=="with_import") {
97  this->with_import = e.second;
98  } else if (e.first=="include_math") {
99  this->include_math = e.second;
100  } else if (e.first=="infinity") {
101  this->infinity = e.second.to_string();
102  } else if (e.first=="nan") {
103  this->nan = e.second.to_string();
104  } else if (e.first=="real_min") {
105  this->real_min = e.second.to_string();
106  } else if (e.first=="indent") {
107  indent_ = e.second;
108  casadi_assert_dev(indent_>=0);
109  } else if (e.first=="avoid_stack") {
110  avoid_stack_ = e.second;
111  } else if (e.first=="prefix") {
112  this->prefix = e.second.to_string();
113  prefix_set = true;
114  } else if (e.first=="max_declarations_per_line") {
115  this->max_declarations_per_line = e.second;
116  casadi_assert(this->max_declarations_per_line>=0,
117  "Option max_declarations_per_line must be >=0");
118  } else if (e.first=="max_initializer_elements_per_line") {
119  this->max_initializer_elements_per_line = e.second;
120  casadi_assert(this->max_initializer_elements_per_line>=0,
121  "Option max_initializer_elements_per_line must be >=0");
122  } else if (e.first=="force_canonical") {
123  this->force_canonical = e.second;
124  } else {
125  casadi_error("Unrecognized option: " + str(e.first));
126  }
127  }
128 
129  // If real_min is not specified, make an educated guess
130  if (this->real_min.empty()) {
131  std::stringstream ss;
132  ss << std::scientific << std::setprecision(std::numeric_limits<double>::digits10 + 1);
133  if (casadi_real_type=="float") {
134  ss << std::numeric_limits<float>::min();
135  this->real_min = ss.str();
136  } else if (casadi_real_type=="double") {
137  ss << std::numeric_limits<double>::min();
138  this->real_min = ss.str();
139  } else {
140  this->real_min = "<NOT SPECIFIED>";
141  }
142  }
143 
144  // Start at new line with no indentation
145  newline_ = true;
146  current_indent_ = 0;
147 
148  // Start off without the need for thread-local memory
149  needs_mem_ = false;
150 
151  // Divide name into base and suffix (if any)
152  std::string::size_type dotpos = name.rfind('.');
153  if (dotpos==std::string::npos) {
154  this->name = name;
155  this->suffix = this->cpp ? ".cpp" : ".c";
156  } else {
157  this->name = name.substr(0, dotpos);
158  this->suffix = name.substr(dotpos);
159  }
160 
161  // Symbol prefix
162  if (this->with_export) dll_export = "CASADI_SYMBOL_EXPORT ";
163  if (this->with_import) dll_import = "CASADI_SYMBOL_IMPORT ";
164 
165  // Make sure that the base name is sane
166  casadi_assert_dev(Function::check_name(this->name));
167 
168  // Includes needed
169  if (this->include_math) add_include("math.h");
170  if (this->main) add_include("stdio.h");
171  if (this->verbose_runtime) add_auxiliary(AUX_PRINTF);
172 
173  // Mex and main need string.h
174  if (this->mex || this->main) {
175  add_include("string.h");
176  }
177 
178  // Mex
179  if (this->mex) {
180  add_include("mex.h", false, "MATLAB_MEX_FILE");
181  }
182 
183  // s-Function
184  if (this->with_sfunction) {
185  this->casadi_real_type = "real_T";
186  this->casadi_int_type = "int_T";
187  this->with_header = true;
188  add_include("simstruc.h");
189  }
190 
191  // Memory struct entry point
192  if (this->with_mem) {
193  this->header << "#include <casadi/mem.h>\n";
194  }
195 
196  // Use name as default prefix
197  if (!prefix_set) {
198  this->prefix = this->name;
199  }
200 
201  }
casadi::CodeGenerator::codegen_scalars
bool codegen_scalars
Codegen scalar.
Definition: code_generator.hpp:964
casadi::CodeGenerator::max_initializer_elements_per_line
casadi_int max_initializer_elements_per_line
Definition: code_generator.hpp:973
casadi::CodeGenerator::header
std::stringstream header
Definition: code_generator.hpp:988
casadi::CodeGenerator::max_declarations_per_line
casadi_int max_declarations_per_line
Definition: code_generator.hpp:970
casadi::CodeGenerator::add_include
void add_include(const std::string &new_include, bool relative_path=false, const std::string &use_ifdef=std::string())
Add an include file optionally using a relative path "..." instead of an absolute path <....
Definition: code_generator.cpp:1121
casadi::CodeGenerator::add_auxiliary
void add_auxiliary(Auxiliary f, const std::vector< std::string > &inst={"casadi_real"})
Add a built-in auxiliary function.
Definition: code_generator.cpp:1376
casadi::Function::check_name
static bool check_name(const std::string &name)
Check if a string is a valid function name.
Definition: function.cpp:1324
casadi::str
std::string str(const T &v)
String representation, any type.
Definition: casadi_common.hpp:247

References add_auxiliary(), add_include(), AUX_PRINTF, avoid_stack_, casadi_int_type, casadi_real_type, casadi::Function::check_name(), codegen_scalars, cpp, current_indent_, dll_export, dll_import, force_canonical, header, include_math, indent_, infinity, main, max_declarations_per_line, max_initializer_elements_per_line, mex, name, nan, needs_mem_, newline_, prefix, real_min, casadi::str(), suffix, sz_ones_, sz_zeros_, unroll_args, verbose, verbose_runtime, with_export, with_header, with_import, with_mem, and with_sfunction.

Member Function Documentation

◆ add()

void casadi::CodeGenerator::add ( const Function &  f,
bool  with_jac_sparsity = false 
)

Definition at line 331 of file code_generator.cpp.

331  {
332  // Add if not already added
333  std::string codegen_name = add_dependency(f);
334 
335  // Define function
336  *this << declare(f->signature(f.name())) << "{\n"
337  << "return " << codegen_name << "(arg, res, iw, w, mem);\n"
338  << "}\n\n";
339 
340  if (this->unroll_args) {
341  // Define function
342  *this << declare(f->signature_unrolled(f.name())) << "{\n";
343  for (casadi_int i=0; i<f.n_in(); ++i) {
344  *this << "arg[" << i << "] = " << f.name_in(i) << ";\n";
345  }
346  for (casadi_int i=0; i<f.n_out(); ++i) {
347  *this << "res[" << i << "] = " << f.name_out(i) << ";\n";
348  }
349  *this << "return " << codegen_name << "(arg, res, iw, w, mem);\n";
350  *this << "}\n\n";
351  // Flush buffers
352  flush(this->body);
353  }
354 
355  // Generate meta information
356  f->codegen_meta(*this);
357 
358  // Generate Jacobian sparsity information
359  if (with_jac_sparsity) {
360  // Generate/get Jacobian sparsity
361  std::vector<Sparsity> jac = f.jac_sparsity();
362  // Code generate the sparsity pattern
363  add_io_sparsities("jac_" + f.name(), f->sparsity_in_, jac);
364 
365  // Flush buffers
366  flush(this->body);
367  }
368 
369  // Generate function specific code for Simulink sfunction
370  if (this->with_sfunction) this->added_sfunctions.push_back( this->codegen_sfunction(f) );
371 
372  // Add to list of exposed symbols
373  this->exposed_fname.push_back(f.name());
374  }
casadi::CodeGenerator::add_dependency
std::string add_dependency(const Function &f)
Add a function dependency.
Definition: code_generator.cpp:250
casadi::CodeGenerator::added_sfunctions
std::vector< std::string > added_sfunctions
Definition: code_generator.hpp:933
casadi::CodeGenerator::add_io_sparsities
void add_io_sparsities(const std::string &name, const std::vector< Sparsity > &sp_in, const std::vector< Sparsity > &sp_out)
Add io sparsity patterns of a function.
Definition: code_generator.cpp:2459
casadi::CodeGenerator::flush
void flush(std::ostream &s)
Flush the buffer to a stream of choice.
Definition: code_generator.cpp:2318
casadi::CodeGenerator::declare
std::string declare(std::string s)
Declare a function.
Definition: code_generator.cpp:2083
casadi::CodeGenerator::body
std::stringstream body
Definition: code_generator.hpp:987
casadi::CodeGenerator::exposed_fname
std::vector< std::string > exposed_fname
Definition: code_generator.hpp:1005

References add_dependency(), add_io_sparsities(), added_sfunctions, body, casadi::FunctionInternal::codegen_meta(), declare(), exposed_fname, flush(), casadi::Function::jac_sparsity(), casadi::Function::n_in(), casadi::Function::n_out(), casadi::Function::name(), casadi::Function::name_in(), casadi::Function::name_out(), casadi::FunctionInternal::signature(), casadi::FunctionInternal::signature_unrolled(), casadi::FunctionInternal::sparsity_in_, unroll_args, and with_sfunction.

Referenced by casadi::DaeBuilderInternal::export_fmu(), casadi::FunctionInternal::finalize(), casadi::Function::generate(), casadi::OracleFunction::generate_dependencies(), and casadi::Scpgen::init().

◆ add_auxiliary()

void casadi::CodeGenerator::add_auxiliary ( Auxiliary  f,
const std::vector< std::string > &  inst = {"casadi_real"} 
)

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

Definition at line 1376 of file code_generator.cpp.

1376  {
1377  // Look for existing instantiations
1378  auto f_match = added_auxiliaries_.equal_range(f);
1379  // Look for duplicates
1380  for (auto it=f_match.first; it!=f_match.second; ++it) {
1381  if (it->second==inst) return;
1382  }
1383  added_auxiliaries_.insert(std::make_pair(f, inst));
1384 
1385  // Add the appropriate function
1386  switch (f) {
1387  case AUX_COPY:
1388  this->auxiliaries << sanitize_source(casadi_copy_str, inst);
1389  break;
1390  case AUX_SCALED_COPY:
1391  this->auxiliaries << sanitize_source(casadi_scaled_copy_str, inst);
1392  break;
1393  case AUX_SWAP:
1394  this->auxiliaries << sanitize_source(casadi_swap_str, inst);
1395  break;
1396  case AUX_SCAL:
1397  this->auxiliaries << sanitize_source(casadi_scal_str, inst);
1398  break;
1399  case AUX_AXPY:
1400  this->auxiliaries << sanitize_source(casadi_axpy_str, inst);
1401  break;
1402  case AUX_DOT:
1403  this->auxiliaries << sanitize_source(casadi_dot_str, inst);
1404  break;
1405  case AUX_BILIN:
1406  this->auxiliaries << sanitize_source(casadi_bilin_str, inst);
1407  break;
1408  case AUX_RANK1:
1409  this->auxiliaries << sanitize_source(casadi_rank1_str, inst);
1410  break;
1411  case AUX_IAMAX:
1412  this->auxiliaries << sanitize_source(casadi_iamax_str, inst);
1413  break;
1414  case AUX_INTERPN:
1415  add_auxiliary(AUX_INTERPN_WEIGHTS);
1416  add_auxiliary(AUX_INTERPN_INTERPOLATE);
1417  add_auxiliary(AUX_FLIP, {});
1418  add_auxiliary(AUX_CLEAR);
1419  add_auxiliary(AUX_CLEAR, {"casadi_int"});
1420  this->auxiliaries << sanitize_source(casadi_interpn_str, inst);
1421  break;
1422  case AUX_INTERPN_GRAD:
1423  add_auxiliary(AUX_INTERPN);
1424  this->auxiliaries << sanitize_source(casadi_interpn_grad_str, inst);
1425  break;
1426  case AUX_DE_BOOR:
1427  this->auxiliaries << sanitize_source(casadi_de_boor_str, inst);
1428  break;
1429  case AUX_ND_BOOR_EVAL:
1430  add_auxiliary(AUX_DE_BOOR);
1431  add_auxiliary(AUX_FILL);
1432  add_auxiliary(AUX_FILL, {"casadi_int"});
1433  add_auxiliary(AUX_CLEAR);
1434  add_auxiliary(AUX_CLEAR, {"casadi_int"});
1435  add_auxiliary(AUX_LOW);
1436  this->auxiliaries << sanitize_source(casadi_nd_boor_eval_str, inst);
1437  break;
1438  case AUX_FLIP:
1439  this->auxiliaries << sanitize_source(casadi_flip_str, inst);
1440  break;
1441  case AUX_LOW:
1442  this->auxiliaries << sanitize_source(casadi_low_str, inst);
1443  break;
1444  case AUX_INTERPN_WEIGHTS:
1445  add_auxiliary(AUX_LOW);
1446  this->auxiliaries << sanitize_source(casadi_interpn_weights_str, inst);
1447  break;
1448  case AUX_INTERPN_INTERPOLATE:
1449  this->auxiliaries << sanitize_source(casadi_interpn_interpolate_str, inst);
1450  break;
1451  case AUX_NORM_1:
1452  this->auxiliaries << sanitize_source(casadi_norm_1_str, inst);
1453  break;
1454  case AUX_NORM_2:
1455  add_auxiliary(AUX_DOT);
1456  this->auxiliaries << sanitize_source(casadi_norm_2_str, inst);
1457  break;
1458  case AUX_NORM_INF:
1459  add_auxiliary(AUX_FMAX);
1460  this->auxiliaries << sanitize_source(casadi_norm_inf_str, inst);
1461  break;
1462  case AUX_VECTOR_FMAX:
1463  add_auxiliary(AUX_FMAX);
1464  this->auxiliaries << sanitize_source(casadi_vector_fmax_str, inst);
1465  break;
1466  case AUX_VECTOR_FMIN:
1467  add_auxiliary(AUX_FMIN);
1468  this->auxiliaries << sanitize_source(casadi_vector_fmin_str, inst);
1469  break;
1470  case AUX_MASKED_NORM_INF:
1471  add_auxiliary(AUX_FMAX);
1472  this->auxiliaries << sanitize_source(casadi_masked_norm_inf_str, inst);
1473  break;
1474  case AUX_CLIP_MIN:
1475  // add_auxiliary(AUX_CLIP_MIN);
1476  this->auxiliaries << sanitize_source(casadi_clip_min_str, inst);
1477  break;
1478  case AUX_CLIP_MAX:
1479  // add_auxiliary(AUX_CLIP_MAX);
1480  this->auxiliaries << sanitize_source(casadi_clip_max_str, inst);
1481  break;
1482  case AUX_CLEAR:
1483  this->auxiliaries << sanitize_source(casadi_clear_str, inst);
1484  break;
1485  case AUX_FILL:
1486  this->auxiliaries << sanitize_source(casadi_fill_str, inst);
1487  break;
1488  case AUX_MV:
1489  this->auxiliaries << sanitize_source(casadi_mv_str, inst);
1490  break;
1491  case AUX_MV_DENSE:
1492  this->auxiliaries << sanitize_source(casadi_mv_dense_str, inst);
1493  break;
1494  case AUX_MTIMES:
1495  this->auxiliaries << sanitize_source(casadi_mtimes_str, inst);
1496  break;
1497  case AUX_TRILSOLVE:
1498  this->auxiliaries << sanitize_source(casadi_trilsolve_str, inst);
1499  break;
1500  case AUX_TRIUSOLVE:
1501  this->auxiliaries << sanitize_source(casadi_triusolve_str, inst);
1502  break;
1503  case AUX_PROJECT:
1504  this->auxiliaries << sanitize_source(casadi_project_str, inst);
1505  break;
1506  case AUX_TRI_PROJECT:
1507  this->auxiliaries << sanitize_source(casadi_tri_project_str, inst);
1508  break;
1509  case AUX_DENSIFY:
1510  add_auxiliary(AUX_CLEAR);
1511  add_auxiliary(AUX_CAST);
1512  {
1513  std::vector<std::string> inst2 = inst;
1514  if (inst.size()==1) inst2.push_back(inst[0]);
1515  this->auxiliaries << sanitize_source(casadi_densify_str, inst2);
1516  }
1517  break;
1518  case AUX_SPARSIFY:
1519  add_auxiliary(AUX_CAST);
1520  {
1521  std::vector<std::string> inst2 = inst;
1522  if (inst.size()==1) inst2.push_back(inst[0]);
1523  this->auxiliaries << sanitize_source(casadi_sparsify_str, inst2);
1524  }
1525  break;
1526  case AUX_TRANS:
1527  this->auxiliaries << sanitize_source(casadi_trans_str, inst);
1528  break;
1529  case AUX_TO_MEX:
1530  add_auxiliary(AUX_TO_DOUBLE);
1531  this->auxiliaries << "#ifdef MATLAB_MEX_FILE\n"
1532  << sanitize_source(casadi_to_mex_str, inst)
1533  << "#endif\n\n";
1534  break;
1535  case AUX_FROM_MEX:
1536  add_auxiliary(AUX_FILL);
1537  this->auxiliaries << "#ifdef MATLAB_MEX_FILE\n"
1538  << sanitize_source(casadi_from_mex_str, inst)
1539  << "#endif\n\n";
1540  break;
1541  case AUX_FINITE_DIFF:
1542  add_auxiliary(AUX_FMAX);
1543  this->auxiliaries << sanitize_source(casadi_finite_diff_str, inst);
1544  break;
1545  case AUX_QR:
1546  add_auxiliary(AUX_IF_ELSE);
1547  add_auxiliary(AUX_SCAL);
1548  add_auxiliary(AUX_DOT);
1549  add_auxiliary(AUX_CLEAR);
1550  this->auxiliaries << sanitize_source(casadi_qr_str, inst);
1551  break;
1552  case AUX_LSQR:
1553  add_auxiliary(AUX_COPY);
1554  add_auxiliary(AUX_CLEAR);
1555  add_auxiliary(AUX_NORM_2);
1556  add_auxiliary(AUX_MV);
1557  add_auxiliary(AUX_FABS);
1558  add_auxiliary(AUX_SIGN);
1559  this->auxiliaries << sanitize_source(casadi_lsqr_str, inst);
1560  break;
1561  case AUX_QP:
1562  this->auxiliaries << sanitize_source(casadi_qp_str, inst);
1563  break;
1564  case AUX_QRQP:
1565  add_auxiliary(AUX_QP);
1566  add_auxiliary(AUX_COPY);
1567  add_auxiliary(AUX_QR);
1568  add_auxiliary(AUX_MAX);
1569  add_auxiliary(AUX_FMIN);
1570  add_auxiliary(AUX_FMAX);
1571  add_auxiliary(AUX_TRANS);
1572  add_auxiliary(AUX_AXPY);
1573  add_auxiliary(AUX_MV);
1574  add_auxiliary(AUX_BILIN);
1575  add_auxiliary(AUX_INF);
1576  add_auxiliary(AUX_REAL_MIN);
1577  add_auxiliary(AUX_CLEAR);
1578  add_include("stdarg.h");
1579  add_include("stdio.h");
1580  add_include("math.h");
1581 
1582  this->auxiliaries << sanitize_source(casadi_qrqp_str, inst);
1583  break;
1584  case AUX_NLP:
1585  add_auxiliary(AUX_ORACLE);
1586  this->auxiliaries << sanitize_source(casadi_nlp_str, inst);
1587  break;
1588  case AUX_SQPMETHOD:
1589  add_auxiliary(AUX_QP);
1590  add_auxiliary(AUX_NLP);
1591  add_auxiliary(AUX_FILL);
1592  add_auxiliary(AUX_FABS);
1593  this->auxiliaries << sanitize_source(casadi_sqpmethod_str, inst);
1594  break;
1595  case AUX_FEASIBLESQPMETHOD:
1596  add_auxiliary(AUX_QP);
1597  add_auxiliary(AUX_NLP);
1598  this->auxiliaries << sanitize_source(casadi_feasiblesqpmethod_str, inst);
1599  break;
1600  case AUX_LDL:
1601  this->auxiliaries << sanitize_source(casadi_ldl_str, inst);
1602  break;
1603  case AUX_NEWTON:
1604  add_auxiliary(AUX_COPY);
1605  add_auxiliary(AUX_AXPY);
1606  add_auxiliary(AUX_NORM_INF);
1607  add_auxiliary(AUX_QR);
1608  this->auxiliaries << sanitize_source(casadi_newton_str, inst);
1609  break;
1610  case AUX_MAX_VIOL:
1611  add_auxiliary(AUX_FMAX);
1612  this->auxiliaries << sanitize_source(casadi_max_viol_str, inst);
1613  break;
1614  case AUX_SUM_VIOL:
1615  this->auxiliaries << sanitize_source(casadi_sum_viol_str, inst);
1616  break;
1617  case AUX_SUM:
1618  this->auxiliaries << sanitize_source(casadi_sum_str, inst);
1619  break;
1620  case AUX_VFMIN:
1621  add_auxiliary(AUX_FMIN);
1622  this->auxiliaries << sanitize_source(casadi_vfmin_str, inst);
1623  break;
1624  case AUX_VFMAX:
1625  add_auxiliary(AUX_FMAX);
1626  this->auxiliaries << sanitize_source(casadi_vfmax_str, inst);
1627  break;
1628  case AUX_REGULARIZE:
1629  add_auxiliary(AUX_FABS);
1630  add_auxiliary(AUX_FMIN);
1631  this->auxiliaries << sanitize_source(casadi_regularize_str, inst);
1632  break;
1633  case AUX_BOUNDS_CONSISTENCY:
1634  add_auxiliary(AUX_ISINF);
1635  add_auxiliary(AUX_FMAX);
1636  add_auxiliary(AUX_FMIN);
1637  this->auxiliaries << sanitize_source(casadi_bound_consistency_str, inst);
1638  break;
1639  case AUX_FILE_SLURP:
1640  add_include("stdio.h");
1641  this->auxiliaries << sanitize_source(casadi_file_slurp_str, inst);
1642  break;
1643  case AUX_CACHE:
1644  this->auxiliaries << sanitize_source(casadi_cache_str, inst);
1645  break;
1646  case AUX_CVX:
1647  add_auxiliary(AUX_CLEAR);
1648  add_auxiliary(AUX_FABS);
1649  add_auxiliary(AUX_COPY);
1650  add_auxiliary(AUX_DOT);
1651  add_auxiliary(AUX_AXPY);
1652  add_auxiliary(AUX_FMAX);
1653  this->auxiliaries << sanitize_source(casadi_cvx_str, inst);
1654  break;
1655  case AUX_CONVEXIFY:
1656  add_auxiliary(AUX_CVX);
1657  add_auxiliary(AUX_PROJECT);
1658  add_auxiliary(AUX_REGULARIZE);
1659  add_auxiliary(AUX_COPY);
1660  this->auxiliaries << sanitize_source(casadi_convexify_str, inst);
1661  break;
1662  case AUX_LOGSUMEXP:
1663  add_auxiliary(AUX_LOG1P);
1664  add_auxiliary(AUX_FMAX);
1665  this->auxiliaries << sanitize_source(casadi_logsumexp_str, inst);
1666  break;
1667  case AUX_SPARSITY:
1668  this->auxiliaries << sanitize_source(casadi_sparsity_str, inst);
1669  break;
1670  case AUX_BFGS:
1671  add_auxiliary(AUX_COPY);
1672  add_auxiliary(AUX_AXPY);
1673  add_auxiliary(AUX_CLEAR);
1674  add_auxiliary(AUX_MV);
1675  add_auxiliary(AUX_DOT);
1676  add_auxiliary(AUX_IF_ELSE);
1677  add_auxiliary(AUX_SCAL);
1678  add_auxiliary(AUX_RANK1);
1679  this->auxiliaries << sanitize_source(casadi_bfgs_str, inst);
1680  break;
1681  case AUX_ORACLE:
1682  this->auxiliaries << sanitize_source(casadi_oracle_str, inst);
1683  break;
1684  case AUX_ORACLE_CALLBACK:
1685  this->auxiliaries << sanitize_source(casadi_oracle_callback_str, inst);
1686  break;
1687  case AUX_OCP_BLOCK:
1688  this->auxiliaries << sanitize_source(casadi_ocp_block_str, inst);
1689  break;
1690  case AUX_TO_DOUBLE:
1691  this->auxiliaries << "#define casadi_to_double(x) "
1692  << "(" << (this->cpp ? "static_cast<double>(x)" : "(double) x") << ")\n\n";
1693  break;
1694  case AUX_TO_INT:
1695  this->auxiliaries << "#define casadi_to_int(x) "
1696  << "(" << (this->cpp ? "static_cast<casadi_int>(x)" : "(casadi_int) x")
1697  << ")\n\n";
1698  break;
1699  case AUX_CAST:
1700  this->auxiliaries << "#define CASADI_CAST(x,y) "
1701  << "(" << (this->cpp ? "static_cast<x>(y)" : "(x) y") << ")\n\n";
1702  break;
1703  case AUX_SQ:
1704  shorthand("sq");
1705  this->auxiliaries << "casadi_real casadi_sq(casadi_real x) { return x*x;}\n\n";
1706  break;
1707  case AUX_SIGN:
1708  shorthand("sign");
1709  this->auxiliaries << "casadi_real casadi_sign(casadi_real x) "
1710  << "{ return x<0 ? -1 : x>0 ? 1 : x;}\n\n";
1711  break;
1712  case AUX_IF_ELSE:
1713  shorthand("if_else");
1714  this->auxiliaries << "casadi_real casadi_if_else"
1715  << "(casadi_real c, casadi_real x, casadi_real y) "
1716  << "{ return c!=0 ? x : y;}\n\n";
1717  break;
1718  case AUX_PRINTF:
1719  this->auxiliaries << "#ifndef CASADI_PRINTF\n";
1720  if (this->mex) {
1721  this->auxiliaries << "#ifdef MATLAB_MEX_FILE\n"
1722  << " #define CASADI_PRINTF mexPrintf\n"
1723  << "#else\n"
1724  << " #define CASADI_PRINTF printf\n"
1725  << "#endif\n";
1726  } else {
1727  add_include("stdio.h");
1728  this->auxiliaries << "#define CASADI_PRINTF printf\n";
1729  this->auxiliaries << "#ifndef CASADI_SNPRINTF\n";
1730  this->auxiliaries << "#define CASADI_SNPRINTF snprintf\n";
1731  this->auxiliaries << "#endif\n\n";
1732  }
1733  this->auxiliaries << "#endif\n\n";
1734  break;
1735  case AUX_FMIN:
1736  shorthand("fmin");
1737  this->auxiliaries << "casadi_real casadi_fmin(casadi_real x, casadi_real y) {\n"
1738  << "/* Pre-c99 compatibility */\n"
1739  << "#if __STDC_VERSION__ < 199901L\n"
1740  << " return x<y ? x : y;\n"
1741  << "#else\n"
1742  << " return fmin(x, y);\n"
1743  << "#endif\n"
1744  << "}\n\n";
1745  break;
1746  case AUX_FMAX:
1747  shorthand("fmax");
1748  this->auxiliaries << "casadi_real casadi_fmax(casadi_real x, casadi_real y) {\n"
1749  << "/* Pre-c99 compatibility */\n"
1750  << "#if __STDC_VERSION__ < 199901L\n"
1751  << " return x>y ? x : y;\n"
1752  << "#else\n"
1753  << " return fmax(x, y);\n"
1754  << "#endif\n"
1755  << "}\n\n";
1756  break;
1757  case AUX_FABS:
1758  shorthand("fabs");
1759  this->auxiliaries << "casadi_real casadi_fabs(casadi_real x) {\n"
1760  << "/* Pre-c99 compatibility */\n"
1761  << "#if __STDC_VERSION__ < 199901L\n"
1762  << " return x>0 ? x : -x;\n"
1763  << "#else\n"
1764  << " return fabs(x);\n"
1765  << "#endif\n"
1766  << "}\n\n";
1767  break;
1768  case AUX_ISINF:
1769  shorthand("isinf");
1770  this->auxiliaries << "casadi_real casadi_isinf(casadi_real x) {\n"
1771  << "/* Pre-c99 compatibility */\n"
1772  << "#if __STDC_VERSION__ < 199901L\n"
1773  << " return x== INFINITY || x==-INFINITY;\n"
1774  << "#else\n"
1775  << " return isinf(x);\n"
1776  << "#endif\n"
1777  << "}\n\n";
1778  break;
1779  case AUX_MIN:
1780  this->auxiliaries << "casadi_int casadi_min(casadi_int x, casadi_int y) {\n"
1781  << " return x>y ? y : x;\n"
1782  << "}\n\n";
1783  break;
1784  case AUX_MAX:
1785  this->auxiliaries << "casadi_int casadi_max(casadi_int x, casadi_int y) {\n"
1786  << " return x>y ? x : y;\n"
1787  << "}\n\n";
1788  break;
1789  case AUX_MMIN:
1790  add_auxiliary(AUX_VFMIN);
1791  add_auxiliary(AUX_INF);
1792  this->auxiliaries << sanitize_source(casadi_mmin_str, inst);
1793  break;
1794  case AUX_MMAX:
1795  add_auxiliary(AUX_VFMAX);
1796  add_auxiliary(AUX_INF);
1797  this->auxiliaries << sanitize_source(casadi_mmax_str, inst);
1798  break;
1799  case AUX_INF:
1800  this->auxiliaries << "#ifndef casadi_inf\n"
1801  << " #define casadi_inf " << this->infinity << "\n"
1802  << "#endif\n\n";
1803  break;
1804  case AUX_NAN:
1805  this->auxiliaries << "#ifndef casadi_nan\n"
1806  << " #define casadi_nan " << this->nan << "\n"
1807  << "#endif\n\n";
1808  break;
1809  case AUX_REAL_MIN:
1810  this->auxiliaries << "#ifndef casadi_real_min\n"
1811  << " #define casadi_real_min " << this->real_min << "\n"
1812  << "#endif\n\n";
1813  break;
1814  case AUX_LOG1P:
1815  shorthand("log1p");
1816  this->auxiliaries << "casadi_real casadi_log1p(casadi_real x) {\n"
1817  << "/* Pre-c99 compatibility */\n"
1818  << "#if __STDC_VERSION__ < 199901L\n"
1819  << " return log(1+x);\n"
1820  << "#else\n"
1821  << " return log1p(x);\n"
1822  << "#endif\n"
1823  << "}\n\n";
1824  break;
1825  case AUX_EXPM1:
1826  shorthand("expm1");
1827  this->auxiliaries << "casadi_real casadi_expm1(casadi_real x) {\n"
1828  << "/* Pre-c99 compatibility */\n"
1829  << "#if __STDC_VERSION__ < 199901L\n"
1830  << " return exp(x)-1;\n"
1831  << "#else\n"
1832  << " return expm1(x);\n"
1833  << "#endif\n"
1834  << "}\n\n";
1835  break;
1836  case AUX_HYPOT:
1837  shorthand("hypot");
1838  this->auxiliaries << "casadi_real casadi_hypot(casadi_real x, casadi_real y) {\n"
1839  << "/* Pre-c99 compatibility */\n"
1840  << "#if __STDC_VERSION__ < 199901L\n"
1841  << " return sqrt(x*x+y*y);\n"
1842  << "#else\n"
1843  << " return hypot(x, y);\n"
1844  << "#endif\n"
1845  << "}\n\n";
1846  break;
1847  case AUX_BLAZING_DE_BOOR:
1848  this->auxiliaries << sanitize_source(casadi_blazing_de_boor_str, inst);
1849  break;
1850  case AUX_BLAZING_1D_BOOR_EVAL:
1851  add_auxiliary(AUX_LOW);
1852  add_auxiliary(AUX_BLAZING_DE_BOOR);
1853  this->auxiliaries << sanitize_source(casadi_blazing_1d_boor_eval_str, inst);
1854  break;
1855  case AUX_BLAZING_2D_BOOR_EVAL:
1856  add_auxiliary(AUX_LOW);
1857  add_auxiliary(AUX_BLAZING_DE_BOOR);
1858  this->auxiliaries << sanitize_source(casadi_blazing_2d_boor_eval_str, inst);
1859  break;
1860  case AUX_BLAZING_3D_BOOR_EVAL:
1861  add_auxiliary(AUX_LOW);
1862  add_auxiliary(AUX_BLAZING_DE_BOOR);
1863  this->auxiliaries << sanitize_source(casadi_blazing_3d_boor_eval_str, inst);
1864  break;
1865  case AUX_PRINTME:
1866  add_auxiliary(AUX_PRINTF);
1867  this->auxiliaries << sanitize_source(casadi_printme_str, inst);
1868  break;
1869  case AUX_PRINT_SCALAR:
1870  add_auxiliary(AUX_PRINTF);
1871  this->auxiliaries << sanitize_source(casadi_print_scalar_str, inst);
1872  break;
1873  case AUX_PRINT_VECTOR:
1874  add_auxiliary(AUX_PRINT_SCALAR);
1875  this->auxiliaries << sanitize_source(casadi_print_vector_str, inst);
1876  break;
1877  case AUX_PRINT_CANONICAL:
1878  add_auxiliary(AUX_PRINT_VECTOR);
1879  this->auxiliaries << sanitize_source(casadi_print_canonical_str, inst);
1880  break;
1881  }
1882  }
casadi::CodeGenerator::added_auxiliaries_
std::multimap< Auxiliary, std::vector< std::string > > added_auxiliaries_
Definition: code_generator.hpp:1014
casadi::CodeGenerator::sanitize_source
std::string sanitize_source(const std::string &src, const std::vector< std::string > &inst, bool add_shorthand=true)
Sanitize source files for codegen.
Definition: code_generator.cpp:2359
casadi::CodeGenerator::shorthand
std::string shorthand(const std::string &name) const
Get a shorthand.
Definition: code_generator.cpp:1186
casadi::CodeGenerator::auxiliaries
std::stringstream auxiliaries
Definition: code_generator.hpp:986

References add_include(), added_auxiliaries_, AUX_AXPY, AUX_BFGS, AUX_BILIN, AUX_BLAZING_1D_BOOR_EVAL, AUX_BLAZING_2D_BOOR_EVAL, AUX_BLAZING_3D_BOOR_EVAL, AUX_BLAZING_DE_BOOR, AUX_BOUNDS_CONSISTENCY, AUX_CACHE, AUX_CAST, AUX_CLEAR, AUX_CLIP_MAX, AUX_CLIP_MIN, AUX_CONVEXIFY, AUX_COPY, AUX_CVX, AUX_DE_BOOR, AUX_DENSIFY, AUX_DOT, AUX_EXPM1, AUX_FABS, AUX_FEASIBLESQPMETHOD, AUX_FILE_SLURP, AUX_FILL, AUX_FINITE_DIFF, AUX_FLIP, AUX_FMAX, AUX_FMIN, AUX_FROM_MEX, AUX_HYPOT, AUX_IAMAX, AUX_IF_ELSE, AUX_INF, AUX_INTERPN, AUX_INTERPN_GRAD, AUX_INTERPN_INTERPOLATE, AUX_INTERPN_WEIGHTS, AUX_ISINF, AUX_LDL, AUX_LOG1P, AUX_LOGSUMEXP, AUX_LOW, AUX_LSQR, AUX_MASKED_NORM_INF, AUX_MAX, AUX_MAX_VIOL, AUX_MIN, AUX_MMAX, AUX_MMIN, AUX_MTIMES, AUX_MV, AUX_MV_DENSE, AUX_NAN, AUX_ND_BOOR_EVAL, AUX_NEWTON, AUX_NLP, AUX_NORM_1, AUX_NORM_2, AUX_NORM_INF, AUX_OCP_BLOCK, AUX_ORACLE, AUX_ORACLE_CALLBACK, AUX_PRINT_CANONICAL, AUX_PRINT_SCALAR, AUX_PRINT_VECTOR, AUX_PRINTF, AUX_PRINTME, AUX_PROJECT, AUX_QP, AUX_QR, AUX_QRQP, AUX_RANK1, AUX_REAL_MIN, AUX_REGULARIZE, AUX_SCAL, AUX_SCALED_COPY, AUX_SIGN, AUX_SPARSIFY, AUX_SPARSITY, AUX_SQ, AUX_SQPMETHOD, AUX_SUM, AUX_SUM_VIOL, AUX_SWAP, AUX_TO_DOUBLE, AUX_TO_INT, AUX_TO_MEX, AUX_TRANS, AUX_TRI_PROJECT, AUX_TRILSOLVE, AUX_TRIUSOLVE, AUX_VECTOR_FMAX, AUX_VECTOR_FMIN, AUX_VFMAX, AUX_VFMIN, auxiliaries, cpp, infinity, mex, nan, real_min, sanitize_source(), and shorthand().

Referenced by axpy(), bilin(), bound_consistency(), cache_check(), clear(), clip_max(), clip_min(), casadi::BlazingSplineFunction::codegen_body(), casadi::MapSum::codegen_body(), casadi::Switch::codegen_body(), casadi::ClarabelInterface::codegen_body(), casadi::DaqpInterface::codegen_body(), casadi::HighsInterface::codegen_body(), casadi::HpipmInterface::codegen_body(), casadi::OsqpInterface::codegen_body(), casadi::FastNewton::codegen_body(), casadi::Feasiblesqpmethod::codegen_body(), casadi::Qrqp::codegen_body(), casadi::Sqpmethod::codegen_body(), casadi::FiniteDiff::codegen_declarations(), casadi::Nlpsol::codegen_declarations(), casadi::FatropInterface::codegen_declarations(), casadi::IpoptInterface::codegen_declarations(), casadi::MadnlpInterface::codegen_declarations(), casadi::Sqpmethod::codegen_declarations(), CodeGenerator(), constant(), convexify_eval(), copy(), densify(), dot(), dump(), file_slurp(), fill(), fmax(), fmin(), from_mex(), casadi::BSplineCommon::generate(), casadi::HorzRepsum::generate(), interpn(), interpn_grad(), lb_eig(), ldl(), ldl_solve(), logsumexp(), low(), lsqr_solve(), masked_norm_inf(), max(), max_viol(), min(), mmax(), mmin(), mtimes(), mv(), norm_1(), norm_2(), norm_inf(), print_canonical(), print_op(), print_scalar(), print_vector(), printf(), project(), casadi::Conic::qp_codegen_body(), qr(), qr_solve(), rank1(), regularize(), scal(), sparsify(), sum_viol(), to_mex(), trans(), tri_project(), trilsolve(), triusolve(), vector_fmax(), vector_fmin(), vfmax(), and vfmin().

◆ add_dependency()

std::string casadi::CodeGenerator::add_dependency ( const Function &  f)

Definition at line 250 of file code_generator.cpp.

250  {
251  // Quick return if it already exists
252  for (auto&& e : added_functions_) if (e.f==f) return e.codegen_name;
253 
254  // Give it a name
255  std::string fname = shorthand("f" + str(added_functions_.size()));
256 
257  // Add to list of functions
258  added_functions_.push_back({f, fname});
259 
260  // Generate declarations
261  f->codegen_declarations(*this);
262 
263  // Print to file
264  f->codegen(*this, fname);
265 
266  // Codegen reference count functions, if needed
267  if (f->has_refcount_) {
268  // Increase reference counter
269  *this << "void " << fname << "_incref(void) {\n";
270  f->codegen_incref(*this);
271  *this << "}\n\n";
272 
273  // Decrease reference counter
274  *this << "void " << fname << "_decref(void) {\n";
275  f->codegen_decref(*this);
276  *this << "}\n\n";
277  }
278 
279  bool fun_needs_mem = !f->codegen_mem_type().empty();
280  needs_mem_ |= fun_needs_mem;
281 
282  if (fun_needs_mem) {
283  // Alloc memory
284  *this << "int " << fname << "_alloc_mem(void) {\n";
285  flush(this->body);
286  scope_enter();
287  f->codegen_alloc_mem(*this);
288  scope_exit();
289  *this << "}\n\n";
290 
291  // Initialize memory
292  *this << "int " << fname << "_init_mem(int mem) {\n";
293  flush(this->body);
294  scope_enter();
295  f->codegen_init_mem(*this);
296  scope_exit();
297  *this << "}\n\n";
298 
299  // Clear memory
300  *this << "void " << fname << "_free_mem(int mem) {\n";
301  flush(this->body);
302  scope_enter();
303  f->codegen_free_mem(*this);
304  scope_exit();
305  *this << "}\n\n";
306 
307  // Checkout
308  *this << "int " << fname << "_checkout(void) {\n";
309  flush(this->body);
310  scope_enter();
311  f->codegen_checkout(*this);
312  scope_exit();
313  *this << "}\n\n";
314 
315  // Clear memory
316  *this << "void " << fname << "_release(int mem) {\n";
317  flush(this->body);
318  scope_enter();
319  f->codegen_release(*this);
320  scope_exit();
321  *this << "}\n\n";
322 
323  }
324 
325  // Flush to body
326  flush(this->body);
327 
328  return fname;
329  }
casadi::CodeGenerator::scope_enter
void scope_enter()
Enter a local scope.
Definition: code_generator.cpp:203
casadi::CodeGenerator::scope_exit
void scope_exit()
Exit a local scope.
Definition: code_generator.cpp:208
casadi::CodeGenerator::added_functions_
std::vector< FunctionMeta > added_functions_
Definition: code_generator.hpp:1033

References added_functions_, body, casadi::FunctionInternal::codegen(), casadi::FunctionInternal::codegen_alloc_mem(), casadi::FunctionInternal::codegen_checkout(), casadi::FunctionInternal::codegen_declarations(), casadi::FunctionInternal::codegen_decref(), casadi::FunctionInternal::codegen_free_mem(), casadi::FunctionInternal::codegen_incref(), casadi::FunctionInternal::codegen_init_mem(), casadi::FunctionInternal::codegen_mem_type(), casadi::FunctionInternal::codegen_release(), flush(), casadi::FunctionInternal::has_refcount_, needs_mem_, scope_enter(), scope_exit(), shorthand(), and casadi::str().

Referenced by add(), casadi::Call::add_dependency(), casadi::FiniteDiff::codegen_declarations(), casadi::Map::codegen_declarations(), casadi::MapSum::codegen_declarations(), casadi::Nlpsol::codegen_declarations(), casadi::Switch::codegen_declarations(), casadi::SXFunction::codegen_declarations(), casadi::FatropInterface::codegen_declarations(), casadi::IpoptInterface::codegen_declarations(), casadi::MadnlpInterface::codegen_declarations(), casadi::FastNewton::codegen_declarations(), casadi::Feasiblesqpmethod::codegen_declarations(), casadi::Sqpmethod::codegen_declarations(), operator()(), and setup_callback().

◆ add_external()

void casadi::CodeGenerator::add_external ( const std::string &  new_external)

Definition at line 1182 of file code_generator.cpp.

1182  {
1183  added_externals_.insert(new_external);
1184  }
casadi::CodeGenerator::added_externals_
std::set< std::string > added_externals_
Definition: code_generator.hpp:1012

References added_externals_.

Referenced by casadi::External::codegen_declarations().

◆ add_include()

void casadi::CodeGenerator::add_include ( const std::string &  new_include,
bool  relative_path = false,
const std::string &  use_ifdef = std::string() 
)

Definition at line 1121 of file code_generator.cpp.

1122  {
1123  // Register the new element
1124  bool added = added_includes_.insert(new_include).second;
1125 
1126  // Quick return if it already exists
1127  if (!added) return;
1128 
1129  // Ifdef opening
1130  if (!use_ifdef.empty()) this->includes << "#ifdef " << use_ifdef << std::endl;
1131 
1132  // Print to the header section
1133  if (relative_path) {
1134  this->includes << "#include \"" << new_include << "\"\n";
1135  } else {
1136  this->includes << "#include <" << new_include << ">\n";
1137  }
1138 
1139  // Ifdef closing
1140  if (!use_ifdef.empty()) this->includes << "#endif\n";
1141  }
casadi::CodeGenerator::includes
std::stringstream includes
Definition: code_generator.hpp:985
casadi::CodeGenerator::added_includes_
std::set< std::string > added_includes_
Definition: code_generator.hpp:1011

References added_includes_, and includes.

Referenced by add_auxiliary(), casadi::ConstantPool::add_dependency(), casadi::BlazingSplineFunction::codegen_body(), casadi::ClarabelInterface::codegen_body(), casadi::DaqpInterface::codegen_body(), casadi::HighsInterface::codegen_body(), casadi::HpipmInterface::codegen_body(), casadi::OsqpInterface::codegen_body(), casadi::FatropInterface::codegen_declarations(), casadi::IpoptInterface::codegen_declarations(), casadi::MadnlpInterface::codegen_declarations(), and CodeGenerator().

◆ add_io_sparsities()

void casadi::CodeGenerator::add_io_sparsities ( const std::string &  name,
const std::vector< Sparsity > &  sp_in,
const std::vector< Sparsity > &  sp_out 
)

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

Definition at line 2458 of file code_generator.cpp.

2461  {
2462  // Insert element, quick return if it already exists
2463  if (!sparsity_meta.insert(name).second) return;
2464 
2465  // Input sparsities
2466  *this << declare("const casadi_int* " + name + "_sparsity_in(casadi_int i)") << " {\n"
2467  << "switch (i) {\n";
2468  for (casadi_int i=0; i<sp_in.size(); ++i) {
2469  *this << "case " << i << ": return " << sparsity(sp_in[i], force_canonical) << ";\n";
2470  }
2471  *this << "default: return 0;\n}\n"
2472  << "}\n\n";
2473 
2474  // Output sparsities
2475  *this << declare("const casadi_int* " + name + "_sparsity_out(casadi_int i)") << " {\n"
2476  << "switch (i) {\n";
2477  for (casadi_int i=0; i<sp_out.size(); ++i) {
2478  *this << "case " << i << ": return " << sparsity(sp_out[i], force_canonical) << ";\n";
2479  }
2480  *this << "default: return 0;\n}\n"
2481  << "}\n\n";
2482  }
casadi::CodeGenerator::sparsity_meta
std::set< std::string > sparsity_meta
Definition: code_generator.hpp:1008
casadi::CodeGenerator::sparsity
std::string sparsity(const Sparsity &sp, bool canonical=true)
Definition: code_generator.cpp:1203

References declare(), force_canonical, name, sparsity(), and sparsity_meta.

Referenced by add(), and casadi::FunctionInternal::codegen_sparsities().

◆ add_sparsity()

casadi_int casadi::CodeGenerator::add_sparsity ( const Sparsity &  sp,
bool  canonical = true 
)

Definition at line 1199 of file code_generator.cpp.

1199  {
1200  return get_constant(sp.compress(canonical), true);
1201  }
casadi::CodeGenerator::get_constant
casadi_int get_constant(const std::vector< double > &v, bool allow_adding=false)
Get or add a constant.
Definition: code_generator.cpp:1243

References casadi::Sparsity::compress(), and get_constant().

Referenced by sparsity().

◆ arg()

std::string casadi::CodeGenerator::arg ( casadi_int  i) const

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

Definition at line 2000 of file code_generator.cpp.

2000  {
2001  return "arg[" + str(i) + "]";
2002  }

References casadi::str().

Referenced by casadi::FiniteDiff::codegen_body(), casadi::OmpMap::codegen_body(), casadi::SXFunction::codegen_body(), casadi::OsqpInterface::codegen_body(), casadi::FastNewton::codegen_body(), casadi::Feasiblesqpmethod::codegen_body(), casadi::LinearInterpolant::codegen_body(), casadi::LinearInterpolantJac::codegen_body(), casadi::Qrqp::codegen_body(), copy(), copy_check(), copy_default(), densify(), from_mex(), casadi::Input::generate(), operator()(), print_canonical(), print_scalar(), print_vector(), printf(), project(), sparsify(), to_mex(), and tri_project().

◆ array()

std::string casadi::CodeGenerator::array ( const std::string &  type,
const std::string &  name,
casadi_int  len,
const std::string &  def = std::string() 
)
static

Declare an array

Definition at line 1025 of file code_generator.cpp.

1026  {
1027  std::stringstream s;
1028  s << type << " ";
1029  if (len==0) {
1030  s << "*" << name << " = 0";
1031  } else {
1032  s << name << "[" << len << "]";
1033  if (!def.empty()) s << " = " << def;
1034  }
1035  s << ";\n";
1036  return s.str();
1037  }

References name.

Referenced by casadi::FunctionInternal::codegen_meta(), and print_vector().

◆ avoid_stack()

bool casadi::CodeGenerator::avoid_stack ( ) const
inline

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

Definition at line 264 of file code_generator.hpp.

264 { return avoid_stack_;}

Referenced by casadi::SXFunction::codegen_body(), and casadi::SXFunction::codegen_sz_w().

◆ axpy()

std::string casadi::CodeGenerator::axpy ( casadi_int  n,
const std::string &  a,
const std::string &  x,
const std::string &  y 
)

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

Definition at line 2185 of file code_generator.cpp.

2186  {
2187  add_auxiliary(AUX_AXPY);
2188  return "casadi_axpy(" + str(n) + ", " + a + ", " + x + ", " + y + ");";
2189  }

References add_auxiliary(), AUX_AXPY, and casadi::str().

Referenced by casadi::FiniteDiff::codegen_body(), casadi::MapSum::codegen_body(), casadi::Feasiblesqpmethod::codegen_body(), casadi::Sqpmethod::codegen_body(), and casadi::Feasiblesqpmethod::codegen_feasibility_iterations().

◆ bilin()

std::string casadi::CodeGenerator::bilin ( const std::string &  A,
const Sparsity &  sp_A,
const std::string &  x,
const std::string &  y 
)

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

Definition at line 2032 of file code_generator.cpp.

2033  {
2034  add_auxiliary(AUX_BILIN);
2035  std::stringstream s;
2036  s << "casadi_bilin(" << A << ", " << sparsity(sp_A) << ", " << x << ", " << y << ")";
2037  return s.str();
2038  }

References add_auxiliary(), AUX_BILIN, and sparsity().

Referenced by casadi::Feasiblesqpmethod::codegen_eval_m_k(), and casadi::Bilin::generate().

◆ bound_consistency()

std::string casadi::CodeGenerator::bound_consistency ( casadi_int  n,
const std::string &  x,
const std::string &  lam,
const std::string &  lbx,
const std::string &  ubx 
)

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

Definition at line 2648 of file code_generator.cpp.

2650  {
2651  add_auxiliary(CodeGenerator::AUX_BOUNDS_CONSISTENCY);
2652  return "casadi_bound_consistency(" + str(n) + ", " + x + ", " + lam +
2653  ", " + lbx + ", " + ubx + ")";
2654  }

References add_auxiliary(), AUX_BOUNDS_CONSISTENCY, and casadi::str().

Referenced by casadi::Feasiblesqpmethod::codegen_body(), and casadi::Nlpsol::codegen_body_exit().

◆ cache_check()

std::string casadi::CodeGenerator::cache_check ( const std::string &  key,
const std::string &  cache,
const std::string &  loc,
casadi_int  stride,
casadi_int  sz,
casadi_int  key_sz,
const std::string &  val 
)

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

Definition at line 2662 of file code_generator.cpp.

2664  {
2665  add_auxiliary(CodeGenerator::AUX_CACHE);
2666  return "cache_check(" + key + ", " + cache + ", " + loc + ", " +
2667  str(stride) + ", " + str(sz) + ", " + str(key_sz) + ", " + val + ")";
2668  }

References add_auxiliary(), AUX_CACHE, and casadi::str().

Referenced by casadi::LinsolQr::generate().

◆ casadi_version()

std::string casadi::CodeGenerator::casadi_version ( )
static

Definition at line 382 of file code_generator.cpp.

382  {
383  std::stringstream ss;
384  ss << CASADI_MAJOR_VERSION << "." << CASADI_MINOR_VERSION << "." << CASADI_PATCH_VERSION;
385  if (!CASADI_IS_RELEASE) ss << "+";
386  return ss.str();
387  }

Referenced by stream_open().

◆ clear()

std::string casadi::CodeGenerator::clear ( const std::string &  res,
std::size_t  n 
)

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

Definition at line 1992 of file code_generator.cpp.

1992  {
1993  std::stringstream s;
1994  // Perform operation
1995  add_auxiliary(AUX_CLEAR);
1996  s << "casadi_clear(" << res << ", " << n << ");";
1997  return s.str();
1998  }
casadi::CodeGenerator::res
std::string res(casadi_int i) const
Refer to resuly.
Definition: code_generator.cpp:2004

References add_auxiliary(), AUX_CLEAR, and res().

Referenced by casadi::Feasiblesqpmethod::codegen_body(), casadi::Sqpmethod::codegen_body(), casadi::OsqpInterface::codegen_init_mem(), casadi::Sqpmethod::codegen_solve_elastic_mode(), fill(), casadi::BSplineCommon::generate(), casadi::Constant< Value >::generate(), and casadi::HorzRepsum::generate().

◆ clip_max()

std::string casadi::CodeGenerator::clip_max ( const std::string &  x,
casadi_int  n,
const std::string &  min,
const std::string &  mask 
)

Definition at line 2197 of file code_generator.cpp.

2198  {
2199  add_auxiliary(AUX_CLIP_MAX);
2200  return "casadi_clip_max(" + x + ", " + str(n) + ", " + min + ", " + mask + ");";
2201  }
casadi::CodeGenerator::min
std::string min(const std::string &x, const std::string &y)
min
Definition: code_generator.cpp:2576

References add_auxiliary(), AUX_CLIP_MAX, min(), and casadi::str().

Referenced by casadi::Feasiblesqpmethod::codegen_body(), and casadi::Feasiblesqpmethod::codegen_feasibility_iterations().

◆ clip_min()

std::string casadi::CodeGenerator::clip_min ( const std::string &  x,
casadi_int  n,
const std::string &  min,
const std::string &  mask 
)

Definition at line 2191 of file code_generator.cpp.

2192  {
2193  add_auxiliary(AUX_CLIP_MIN);
2194  return "casadi_clip_min(" + x + ", " + str(n) + ", " + min + ", " + mask + ");";
2195  }

References add_auxiliary(), AUX_CLIP_MIN, min(), and casadi::str().

Referenced by casadi::Feasiblesqpmethod::codegen_body(), and casadi::Feasiblesqpmethod::codegen_feasibility_iterations().

◆ comment()

void casadi::CodeGenerator::comment ( const std::string &  s)

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

Definition at line 2452 of file code_generator.cpp.

2452  {
2453  if (verbose) {
2454  *this << "/* " << s << " */\n";
2455  }
2456  }

References verbose.

Referenced by casadi::FiniteDiff::codegen_body(), casadi::OsqpInterface::codegen_body(), casadi::FastNewton::codegen_body(), casadi::Feasiblesqpmethod::codegen_body(), casadi::Qrqp::codegen_body(), casadi::Sqpmethod::codegen_body(), casadi::Feasiblesqpmethod::codegen_feasibility_iterations(), casadi::Sqpmethod::codegen_solve_elastic_mode(), casadi::Feasiblesqpmethod::codegen_tr_update(), casadi::LinsolLdl::generate(), casadi::LinsolQr::generate(), and casadi::Lsqr::generate().

◆ constant() [1/9]

std::string casadi::CodeGenerator::constant ( casadi_int  v)

Definition at line 1927 of file code_generator.cpp.

1927  {
1928  return str(v);
1929  }

References casadi::str().

◆ constant() [2/9]

std::string casadi::CodeGenerator::constant ( char  v)

Definition at line 1931 of file code_generator.cpp.

1931  {
1932  return constant(static_cast<casadi_int>(v));
1933  }
casadi::CodeGenerator::constant
std::string constant(const std::vector< casadi_int > &v)
Represent an array constant; adding it when new.
Definition: code_generator.cpp:1334

References constant().

◆ constant() [3/9]

std::string casadi::CodeGenerator::constant ( const std::string &  v)

Definition at line 1920 of file code_generator.cpp.

1920  {
1921  std::string ret = v;
1922  ret = replace(ret, "\\", "\\\\");
1923  ret = replace(ret, "\"", "\\\"");
1924  return "\"" + ret + "\"";
1925  }
casadi::replace
CASADI_EXPORT std::string replace(const std::string &s, const std::string &p, const std::string &r)
Replace all occurences of p with r in s.
Definition: casadi_misc.cpp:289

References casadi::replace().

◆ constant() [4/9]

std::string casadi::CodeGenerator::constant ( const std::vector< casadi_int > &  v)

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

Definition at line 1334 of file code_generator.cpp.

1334  {
1335  return shorthand("s" + str(get_constant(v, true)));
1336  }

References get_constant(), shorthand(), and casadi::str().

Referenced by casadi::BlazingSplineFunction::codegen_body(), casadi::SXFunction::codegen_body(), casadi::HighsInterface::codegen_body(), casadi::OsqpInterface::codegen_body(), casadi::FastNewton::codegen_body(), casadi::Feasiblesqpmethod::codegen_body(), casadi::LinearInterpolant::codegen_body(), casadi::LinearInterpolantJac::codegen_body(), casadi::Qrqp::codegen_body(), casadi::Nlpsol::codegen_body_enter(), casadi::External::codegen_incref(), casadi::FunctionInternal::codegen_meta(), casadi::Sqpmethod::codegen_solve_elastic_mode(), casadi::codegen_unpack_block(), constant(), constant_copy(), casadi::Convexify::generate(), casadi::LinsolLdl::generate(), casadi::LinsolQr::generate(), casadi::BSpline::generate(), casadi::BSplineCommon::generate(), casadi::ConstantDM::generate(), casadi::Constant< Value >::generate(), casadi::GetNonzerosVector::generate(), casadi::GetNonzerosParamVector::generate(), casadi::GetNonzerosSliceParam::generate(), casadi::GetNonzerosParamSlice::generate(), casadi::GetNonzerosParamParam::generate(), casadi::SetNonzerosVector< Add >::generate(), and casadi::FatropInterface::set_fatrop_prob().

◆ constant() [5/9]

std::string casadi::CodeGenerator::constant ( const std::vector< char > &  v)

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

Definition at line 1338 of file code_generator.cpp.

1338  {
1339  return shorthand("b" + str(get_constant(v, true)));
1340  }

References get_constant(), shorthand(), and casadi::str().

◆ constant() [6/9]

std::string casadi::CodeGenerator::constant ( const std::vector< double > &  v)

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

Definition at line 1372 of file code_generator.cpp.

1372  {
1373  return shorthand("c" + str(get_constant(v, true)));
1374  }

References get_constant(), shorthand(), and casadi::str().

◆ constant() [7/9]

std::string casadi::CodeGenerator::constant ( const std::vector< int > &  v)
inline

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

Definition at line 132 of file code_generator.hpp.

132  {
133  return constant(vector_static_cast<casadi_int>(v));
134  }

◆ constant() [8/9]

std::string casadi::CodeGenerator::constant ( const std::vector< std::string > &  v)

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

Definition at line 1342 of file code_generator.cpp.

1342  {
1343  return shorthand("a" + str(get_constant(v, true)));
1344  }

References get_constant(), shorthand(), and casadi::str().

◆ constant() [9/9]

std::string casadi::CodeGenerator::constant ( double  v)

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

Definition at line 1934 of file code_generator.cpp.

1934  {
1935  std::stringstream s;
1936  if (isnan(v)) {
1937  add_auxiliary(AUX_NAN);
1938  s << "casadi_nan";
1939  } else if (isinf(v)) {
1940  add_auxiliary(AUX_INF);
1941  if (v<0) s << "-";
1942  s << "casadi_inf";
1943  } else {
1944  casadi_int v_int = static_cast<casadi_int>(v);
1945  if (static_cast<double>(v_int)==v) {
1946  // Print integer
1947  s << v_int << ".";
1948  } else {
1949  // Print real
1950  std::ios_base::fmtflags fmtfl = s.flags(); // get current format flags
1951  s << std::scientific << std::setprecision(std::numeric_limits<double>::digits10 + 1) << v;
1952  s.flags(fmtfl); // reset current format flags
1953  }
1954  }
1955  return s.str();
1956  }

References add_auxiliary(), AUX_INF, and AUX_NAN.

◆ constant_copy()

void casadi::CodeGenerator::constant_copy ( const std::string &  var_name,
const std::vector< casadi_int > &  v,
const std::string &  type = "casadi_int" 
)

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

Definition at line 1356 of file code_generator.cpp.

1357  {
1358  std::string ref = constant(v);
1359  if (!v.empty()) {
1360  local(name+"[" + str(v.size()) + "]", type);
1361  } else {
1362  local(name, type, "*");
1363  }
1364  if (!v.empty()) {
1365  local("i", type);
1366  (*this) << "for (i=0;i<" << v.size() << ";++i) " + name + "[i] = " + ref + "[i];\n";
1367  } else {
1368  init_local(name, "0");
1369  }
1370  }
casadi::CodeGenerator::local
void local(const std::string &name, const std::string &type, const std::string &ref="")
Declare a local variable.
Definition: code_generator.cpp:2323
casadi::CodeGenerator::init_local
void init_local(const std::string &name, const std::string &def)
Specify the default value for a local variable.
Definition: code_generator.cpp:2350

References constant(), init_local(), local(), name, and casadi::str().

Referenced by casadi::OsqpInterface::codegen_init_mem().

◆ convexify_eval()

std::string casadi::CodeGenerator::convexify_eval ( const ConvexifyData &  d,
const std::string &  Hin,
const std::string &  Hout,
const std::string &  iw,
const std::string &  w 
)

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

Definition at line 2635 of file code_generator.cpp.

2637  {
2638  add_auxiliary(CodeGenerator::AUX_CONVEXIFY);
2639  return Convexify::generate(*this, d, Hin, Hout, iw, w);
2640  }
casadi::Convexify::generate
void generate(CodeGenerator &g, const std::vector< casadi_int > &arg, const std::vector< casadi_int > &res, const std::vector< bool > &arg_is_ref, std::vector< bool > &res_is_ref) const override
Generate code for the operation.
Definition: convexify.cpp:156

References add_auxiliary(), AUX_CONVEXIFY, and casadi::Convexify::generate().

Referenced by casadi::Sqpmethod::codegen_body(), and casadi::Convexify::generate().

◆ copy()

std::string casadi::CodeGenerator::copy ( const std::string &  arg,
std::size_t  n,
const std::string &  res 
)

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

Definition at line 1958 of file code_generator.cpp.

1959  {
1960  std::stringstream s;
1961  // Perform operation
1962  add_auxiliary(AUX_COPY);
1963  s << "casadi_copy(" << arg << ", " << n << ", " << res << ");";
1964  return s.str();
1965  }
casadi::CodeGenerator::arg
std::string arg(casadi_int i) const
Refer to argument.
Definition: code_generator.cpp:2000

References add_auxiliary(), arg(), AUX_COPY, and res().

Referenced by casadi::FiniteDiff::codegen_body(), casadi::JitFunction::codegen_body(), casadi::FastNewton::codegen_body(), casadi::Feasiblesqpmethod::codegen_body(), casadi::Sqpmethod::codegen_body(), casadi::Nlpsol::codegen_body_exit(), casadi::Feasiblesqpmethod::codegen_feasibility_iterations(), casadi::Sqpmethod::codegen_solve_elastic_mode(), casadi::Feasiblesqpmethod::codegen_step_update(), copy_check(), copy_default(), casadi::LinsolQr::generate(), casadi::ConstantDM::generate(), casadi::ConstantFile::generate(), casadi::ConstantPool::generate(), casadi::Einstein::generate(), casadi::Input::generate(), casadi::Output::generate(), casadi::Multiplication::generate(), casadi::DenseMultiplication::generate(), casadi::Rank1::generate(), casadi::HorzRepmat::generate(), casadi::SetNonzerosVector< Add >::generate(), casadi::SetNonzerosSlice< Add >::generate(), casadi::SetNonzerosSlice2< Add >::generate(), casadi::SetNonzerosParam< Add >::generate(), casadi::LinsolCall< Tr >::generate(), casadi::TriuSolve< Tr >::generate(), casadi::TrilSolve< Tr >::generate(), casadi::TriuSolveUnity< Tr >::generate(), casadi::TrilSolveUnity< Tr >::generate(), casadi::Split::generate(), casadi::MXNode::generate_copy(), and project().

◆ copy_check()

void casadi::CodeGenerator::copy_check ( const std::string &  arg,
std::size_t  n,
const std::string &  res,
bool  check_lhs = true,
bool  check_rhs = true 
)

Definition at line 1972 of file code_generator.cpp.

1973  {
1974  std::vector<std::string> checks;
1975  if (check_lhs) checks.push_back(arg);
1976  if (check_rhs) checks.push_back(res);
1977  if (!checks.empty()) *this << "if (" << join(checks, " && ") << ") ";
1978  *this << copy(arg, n, res) << "\n";
1979  }
casadi::CodeGenerator::copy
std::string copy(const std::string &arg, std::size_t n, const std::string &res)
Create a copy operation.
Definition: code_generator.cpp:1958
casadi::join
std::string join(const std::vector< std::string > &l, const std::string &delim)
Definition: casadi_misc.cpp:272

References arg(), copy(), casadi::join(), and res().

Referenced by casadi::OsqpInterface::codegen_body(), casadi::Feasiblesqpmethod::codegen_body(), casadi::Qrqp::codegen_body(), and casadi::Nlpsol::codegen_body_exit().

◆ copy_default()

void casadi::CodeGenerator::copy_default ( const std::string &  arg,
std::size_t  n,
const std::string &  res,
const std::string &  def,
bool  check_rhs = true 
)

Definition at line 1981 of file code_generator.cpp.

1982  {
1983  *this << "if (" << arg << ") {\n";
1984  if (check_rhs) *this << "if (" << res << ") ";
1985  *this << copy(arg, n, res) << "\n";
1986  *this << "} else {\n";
1987  if (check_rhs) *this << "if (" << res << ") ";
1988  *this << fill(res, n, def) << "\n";
1989  *this << "}\n";
1990  }
casadi::CodeGenerator::fill
std::string fill(const std::string &res, std::size_t n, const std::string &v)
Create a fill operation.
Definition: code_generator.cpp:2014

References arg(), copy(), fill(), and res().

Referenced by casadi::OsqpInterface::codegen_body(), casadi::Feasiblesqpmethod::codegen_body(), casadi::Qrqp::codegen_body(), and casadi::Nlpsol::codegen_body_enter().

◆ declare()

std::string casadi::CodeGenerator::declare ( std::string  s)

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

Definition at line 2083 of file code_generator.cpp.

2083  {
2084  // Add c linkage
2085  std::string cpp_prefix = this->cpp ? "extern \"C\" " : "";
2086 
2087  // To header file
2088  if (this->with_header) {
2089  this->header << cpp_prefix << this->dll_import << s << ";\n";
2090  }
2091 
2092  // Return name with declarations
2093  return cpp_prefix + this->dll_export + s;
2094  }

References cpp, dll_import, header, and with_header.

Referenced by add(), add_io_sparsities(), and casadi::FunctionInternal::codegen_meta().

◆ define_pool_double()

void casadi::CodeGenerator::define_pool_double ( const std::string &  name,
const std::vector< double > &  def 
)

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

Definition at line 823 of file code_generator.cpp.

823  {
824  auto it = pool_double_.find(name);
825  if (it==pool_double_.end()) {
826  casadi_int index = pool_double_defaults_.size();
827  pool_double_defaults_.push_back(def);
828  shorthand("pd" + str(index));
829  pool_double_[name] = index;
830  } else {
831  casadi_assert_dev(def==pool_double_defaults_[it->second]);
832  }
833  }
casadi::CodeGenerator::pool_double_
std::map< std::string, casadi_int > pool_double_
Definition: code_generator.hpp:1024
casadi::CodeGenerator::pool_double_defaults_
std::vector< std::vector< double > > pool_double_defaults_
Definition: code_generator.hpp:1023

References name, pool_double_, pool_double_defaults_, shorthand(), and casadi::str().

Referenced by casadi::ConstantPool::add_dependency().

◆ define_rom_double()

void casadi::CodeGenerator::define_rom_double ( const void *  id,
casadi_int  size 
)

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

Definition at line 795 of file code_generator.cpp.

795  {
796  auto it = file_scope_double_.find(id);
797  casadi_assert(it==file_scope_double_.end(), "Already defined.");
798  shorthand("rd" + str(file_scope_double_.size()));
799  file_scope_double_[id] = size;
800  }
casadi::CodeGenerator::file_scope_double_
std::map< const void *, casadi_int > file_scope_double_
Definition: code_generator.hpp:1021

References file_scope_double_, shorthand(), and casadi::str().

Referenced by casadi::ConstantFile::add_dependency().

◆ define_rom_integer()

void casadi::CodeGenerator::define_rom_integer ( const void *  id,
casadi_int  size 
)

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

Definition at line 809 of file code_generator.cpp.

809  {
810  auto it = file_scope_double_.find(id);
811  casadi_assert(it==file_scope_double_.end(), "Already defined.");
812  shorthand("ri" + str(file_scope_double_.size()));
813  file_scope_double_[id] = size;
814  }

References file_scope_double_, shorthand(), and casadi::str().

◆ densify()

std::string casadi::CodeGenerator::densify ( const std::string &  arg,
const Sparsity &  sp_arg,
const std::string &  res,
bool  tr = false 
)

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

Definition at line 2123 of file code_generator.cpp.

2124  {
2125  // Create call
2126  add_auxiliary(AUX_DENSIFY);
2127  std::stringstream s;
2128  s << "casadi_densify(" << arg << ", " << sparsity(sp_arg) << ", " << res << ", "
2129  << (tr ? 1 : 0) << ");";
2130  return s.str();
2131  }

References add_auxiliary(), arg(), AUX_DENSIFY, res(), and sparsity().

Referenced by casadi::Densify::generate().

◆ dot()

std::string casadi::CodeGenerator::dot ( casadi_int  n,
const std::string &  x,
const std::string &  y 
)

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

Definition at line 2024 of file code_generator.cpp.

2025  {
2026  add_auxiliary(AUX_DOT);
2027  std::stringstream s;
2028  s << "casadi_dot(" << n << ", " << x << ", " << y << ")";
2029  return s.str();
2030  }

References add_auxiliary(), and AUX_DOT.

Referenced by casadi::Sqpmethod::codegen_body(), casadi::Feasiblesqpmethod::codegen_eval_m_k(), and casadi::Dot::generate().

◆ dump() [1/2]

std::string casadi::CodeGenerator::dump ( )

Definition at line 376 of file code_generator.cpp.

376  {
377  std::stringstream s;
378  dump(s);
379  return s.str();
380  }
casadi::CodeGenerator::dump
std::string dump()
Generate a file, return code as string.
Definition: code_generator.cpp:376

Referenced by generate().

◆ dump() [2/2]

void casadi::CodeGenerator::dump ( std::ostream &  s)

Definition at line 841 of file code_generator.cpp.

841  {
842  // Consistency check
843  casadi_assert_dev(current_indent_ == 0);
844 
845  // Prefix internal symbols to avoid symbol collisions
846  s << "/* How to prefix internal symbols */\n"
847  << "#ifdef CASADI_CODEGEN_PREFIX\n"
848  << " #define CASADI_NAMESPACE_CONCAT(NS, ID) _CASADI_NAMESPACE_CONCAT(NS, ID)\n"
849  << " #define _CASADI_NAMESPACE_CONCAT(NS, ID) NS ## ID\n"
850  << " #define CASADI_PREFIX(ID) CASADI_NAMESPACE_CONCAT(CODEGEN_PREFIX, ID)\n"
851  << "#else\n"
852  << " #define CASADI_PREFIX(ID) " << this->prefix << "_ ## ID\n"
853  << "#endif\n\n";
854 
855  s << this->includes.str();
856  s << std::endl;
857 
858  // Numeric types after includes: may depend on them. e.g. mex type
859  // Real type (usually double)
860  generate_casadi_real(s);
861 
862  // Integer type (usually long long)
863  generate_casadi_int(s);
864 
865  if (needs_mem_) {
866  s << "#ifndef CASADI_MAX_NUM_THREADS\n";
867  s << "#define CASADI_MAX_NUM_THREADS 1\n";
868  s << "#endif\n\n";
869  }
870 
871  // casadi/mem after numeric types to define derived types
872  // Memory struct entry point
873  if (this->with_mem) {
874  s << "#include <casadi/mem.h>\n" << std::endl;
875  }
876 
877  // Macros
878  if (!added_shorthands_.empty()) {
879  s << "/* Add prefix to internal symbols */\n";
880  for (auto&& i : added_shorthands_) {
881  s << "#define " << "casadi_" << i << " CASADI_PREFIX(" << i << ")\n";
882  }
883  s << std::endl;
884  }
885 
886  if (this->with_export) generate_export_symbol(s);
887 
888  // Check if inf/nan is needed
889  for (const auto& d : double_constants_) {
890  for (double e : d) {
891  if (isinf(e)) add_auxiliary(AUX_INF);
892  if (isnan(e)) add_auxiliary(AUX_NAN);
893  }
894  }
895 
896  // Codegen auxiliary functions
897  s << this->auxiliaries.str();
898 
899  // Print integer constants
900  if (!integer_constants_.empty()) {
901  for (casadi_int i=0; i<integer_constants_.size(); ++i) {
902  print_vector(s, "casadi_s" + str(i), integer_constants_[i]);
903  }
904  s << std::endl;
905  }
906 
907  // Print double constants
908  if (!double_constants_.empty()) {
909  for (casadi_int i=0; i<double_constants_.size(); ++i) {
910  print_vector(s, "casadi_c" + str(i), double_constants_[i]);
911  }
912  s << std::endl;
913  }
914 
915  // Print char constants
916  if (!char_constants_.empty()) {
917  for (casadi_int i=0; i<char_constants_.size(); ++i) {
918  print_vector(s, "casadi_b" + str(i), char_constants_[i]);
919  }
920  s << std::endl;
921  }
922 
923  // Print string constants
924  if (!string_constants_.empty()) {
925  for (casadi_int i=0; i<string_constants_.size(); ++i) {
926  print_vector(s, "casadi_a" + str(i), string_constants_[i]);
927  }
928  s << std::endl;
929  }
930 
931  if (sz_zeros_) {
932  std::vector<double> sz_zeros(sz_zeros_, 0);
933  print_vector(s, "casadi_zeros", std::vector<double>(sz_zeros));
934  s << std::endl;
935  }
936 
937  if (sz_ones_) {
938  std::vector<double> sz_ones(sz_ones_, 0);
939  print_vector(s, "casadi_ones", std::vector<double>(sz_ones));
940  s << std::endl;
941  }
942 
943  // Print file scope double work
944  if (!file_scope_double_.empty()) {
945  casadi_int i=0;
946  for (const auto& it : file_scope_double_) {
947  s << "static casadi_real casadi_rd" + str(i++) + "[" + str(it.second) + "];\n";
948  }
949  s << std::endl;
950  }
951 
952  // Print file scope integer work
953  if (!file_scope_integer_.empty()) {
954  casadi_int i=0;
955  for (const auto& it : file_scope_integer_) {
956  s << "static casadi_real casadi_ri" + str(i++) + "[" + str(it.second) + "];\n";
957  }
958  s << std::endl;
959  }
960 
961  // Print file scope double pool
962  if (!pool_double_.empty()) {
963  casadi_int i=0;
964  for (const auto& v : pool_double_defaults_) {
965  s << "casadi_real casadi_pd" + str(i) +
966  "[" + str(v.size()) + "] = " + initializer(v) + ";\n";
967  i++;
968  }
969  s << std::endl;
970  }
971 
972  // External function declarations
973  if (!added_externals_.empty()) {
974  s << "/* External functions */\n";
975  for (auto&& i : added_externals_) {
976  s << i << std::endl;
977  }
978  s << std::endl << std::endl;
979  }
980 
981  // Codegen body
982  s << this->body.str();
983 
984  // End with new line
985  s << std::endl;
986  }
casadi::CodeGenerator::char_constants_
std::vector< std::vector< char > > char_constants_
Definition: code_generator.hpp:1041
casadi::CodeGenerator::print_vector
void print_vector(std::ostream &s, const std::string &name, const std::vector< casadi_int > &v)
Print casadi_int vector to a c file.
Definition: code_generator.cpp:1039
casadi::CodeGenerator::double_constants_
std::vector< std::vector< double > > double_constants_
Definition: code_generator.hpp:1039
casadi::CodeGenerator::integer_constants_
std::vector< std::vector< casadi_int > > integer_constants_
Definition: code_generator.hpp:1040
casadi::CodeGenerator::string_constants_
std::vector< std::vector< std::string > > string_constants_
Definition: code_generator.hpp:1042
casadi::CodeGenerator::file_scope_integer_
std::map< const void *, casadi_int > file_scope_integer_
Definition: code_generator.hpp:1022
casadi::CodeGenerator::initializer
std::string initializer(const std::vector< T > &v)
Print an initializer.
Definition: code_generator.hpp:283
casadi::CodeGenerator::added_shorthands_
std::set< std::string > added_shorthands_
Definition: code_generator.hpp:1013

References add_auxiliary(), added_externals_, added_shorthands_, AUX_INF, AUX_NAN, auxiliaries, body, char_constants_, current_indent_, double_constants_, file_scope_double_, file_scope_integer_, includes, initializer(), integer_constants_, needs_mem_, pool_double_, pool_double_defaults_, prefix, print_vector(), casadi::str(), string_constants_, sz_ones_, sz_zeros_, with_export, and with_mem.

◆ elide_copy()

bool casadi::CodeGenerator::elide_copy ( casadi_int  sz)

Definition at line 1967 of file code_generator.cpp.

1967  {
1968  if (casadi::GlobalOptions::copy_elision_min_size==-1) return false;
1969  return sz>=casadi::GlobalOptions::copy_elision_min_size;
1970  }
casadi::GlobalOptions::copy_elision_min_size
static casadi_int copy_elision_min_size
Definition: global_options.hpp:75

References casadi::GlobalOptions::copy_elision_min_size.

Referenced by casadi::ConstantDM::generate(), casadi::ConstantFile::generate(), casadi::ConstantPool::generate(), and casadi::Input::generate().

◆ equal()

template<typename T >
static bool casadi::CodeGenerator::equal ( const std::vector< T > &  v1,
const std::vector< T > &  v2 
)
inlinestatic

Definition at line 1057 of file code_generator.hpp.

1057  {
1058  if (v1.size()!=v2.size()) return false;
1059  for (casadi_int j=0; j<v1.size(); ++j) {
1060  if (v1[j]!=v2[j]) return false;
1061  }
1062  return true;
1063  }

Referenced by get_constant().

◆ file_slurp()

std::string casadi::CodeGenerator::file_slurp ( const std::string &  fname,
casadi_int  n,
const std::string &  a 
)

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

Definition at line 2656 of file code_generator.cpp.

2657  {
2658  add_auxiliary(CodeGenerator::AUX_FILE_SLURP);
2659  return "casadi_file_slurp(\"" + fname + "\", " + str(n) + ", " + a + ")";
2660  }

References add_auxiliary(), AUX_FILE_SLURP, and casadi::str().

Referenced by casadi::ConstantFile::codegen_incref().

◆ fill()

std::string casadi::CodeGenerator::fill ( const std::string &  res,
std::size_t  n,
const std::string &  v 
)

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

Definition at line 2014 of file code_generator.cpp.

2015  {
2016  if (v=="0") return clear(res, n);
2017  std::stringstream s;
2018  // Perform operation
2019  add_auxiliary(AUX_FILL);
2020  s << "casadi_fill(" << res << ", " << n << ", " << v << ");";
2021  return s.str();
2022  }
casadi::CodeGenerator::clear
std::string clear(const std::string &res, std::size_t n)
Create a fill operation.
Definition: code_generator.cpp:1992

References add_auxiliary(), AUX_FILL, clear(), and res().

Referenced by casadi::Qrqp::codegen_body(), casadi::Sqpmethod::codegen_body(), casadi::Sqpmethod::codegen_solve_elastic_mode(), copy_default(), and casadi::Constant< Value >::generate().

◆ flush()

void casadi::CodeGenerator::flush ( std::ostream &  s)

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

Definition at line 2318 of file code_generator.cpp.

2318  {
2319  s << this->buffer.str();
2320  this->buffer.str(std::string());
2321  }
casadi::CodeGenerator::buffer
std::stringstream buffer
Definition: code_generator.hpp:989

References buffer.

Referenced by add(), add_dependency(), casadi::FunctionInternal::codegen(), casadi::FatropInterface::codegen_declarations(), casadi::IpoptInterface::codegen_declarations(), and casadi::FunctionInternal::codegen_meta().

◆ fmax()

std::string casadi::CodeGenerator::fmax ( const std::string &  x,
const std::string &  y 
)

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

Definition at line 2533 of file code_generator.cpp.

2534  {
2535  add_auxiliary(CodeGenerator::AUX_FMAX);
2536  return "casadi_fmax(" + x + ", " + y + ");";
2537  }

References add_auxiliary(), and AUX_FMAX.

Referenced by casadi::Sqpmethod::codegen_body(), and casadi::Sqpmethod::codegen_calc_gamma_1().

◆ fmin()

std::string casadi::CodeGenerator::fmin ( const std::string &  x,
const std::string &  y 
)

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

Definition at line 2539 of file code_generator.cpp.

2540  {
2541  add_auxiliary(CodeGenerator::AUX_FMIN);
2542  return "casadi_fmin(" + x + ", " + y + ");";
2543  }

References add_auxiliary(), and AUX_FMIN.

Referenced by casadi::Feasiblesqpmethod::codegen_tr_update().

◆ fmu_helpers()

std::string casadi::CodeGenerator::fmu_helpers ( const std::string &  modelname)
static

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

Definition at line 1904 of file code_generator.cpp.

1904  {
1905  // Process C++ source
1906  std::stringstream ret;
1907  std::string line;
1908  std::istringstream stream(casadi_fmu_str);
1909  while (std::getline(stream, line)) {
1910  // Replacements
1911  if (line.find("MODELNAME") != std::string::npos) {
1912  line = replace(line, "MODELNAME", modelname);
1913  }
1914  // Append to return
1915  ret << line << "\n";
1916  }
1917  return ret.str();
1918  }

References casadi::replace().

Referenced by casadi::DaeBuilderInternal::generate_wrapper().

◆ format_padded()

std::string casadi::CodeGenerator::format_padded ( casadi_int  i) const

Definition at line 1018 of file code_generator.cpp.

1018  {
1019  std::stringstream ss;
1020  ss.str("");
1021  ss << std::setw(padding_length_) << std::setfill('0') << i;
1022  return ss.str();
1023  }

References padding_length_.

Referenced by casadi::MXFunction::codegen_body(), sx_work(), work(), and workel().

◆ from_mex()

std::string casadi::CodeGenerator::from_mex ( std::string &  arg,
const std::string &  res,
std::size_t  res_off,
const Sparsity &  sp_res,
const std::string &  w 
)

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

Definition at line 1891 of file code_generator.cpp.

1893  {
1894  // Handle offset with recursion
1895  if (res_off!=0) return from_mex(arg, res+"+"+str(res_off), 0, sp_res, w);
1896 
1897  add_auxiliary(AUX_FROM_MEX);
1898  std::stringstream s;
1899  s << "casadi_from_mex(" << arg
1900  << ", " << res << ", " << sparsity(sp_res) << ", " << w << ");";
1901  return s.str();
1902  }
casadi::CodeGenerator::from_mex
std::string from_mex(std::string &arg, const std::string &res, std::size_t res_off, const Sparsity &sp_res, const std::string &w)
Get matrix from MATLAB's MEX format.
Definition: code_generator.cpp:1891

References add_auxiliary(), arg(), AUX_FROM_MEX, res(), sparsity(), and casadi::str().

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

◆ generate()

std::string casadi::CodeGenerator::generate ( const std::string &  prefix = "")

The "prefix" argument will be prepended to the generated files and may be a directory or a file prefix. returns the filename

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

Definition at line 463 of file code_generator.cpp.

463  {
464  // Throw an error if the prefix contains the filename, since since syntax
465  // has changed
466  casadi_assert(prefix.find(this->name + this->suffix)==std::string::npos,
467  "The signature of CodeGenerator::generate has changed. "
468  "Instead of providing the filename, only provide the prefix.");
469 
470  // Create c file
471  std::string fullname = prefix + this->name + this->suffix;
472 
473  auto s_ptr = Filesystem::ofstream_ptr(fullname);
474  std::ostream& s = *s_ptr;
475  stream_open(s, this->cpp);
476 
477  // Dump code to file
478  dump(s);
479 
480  if (!pool_double_defaults_.empty()) {
481  s << "CASADI_SYMBOL_EXPORT casadi_real* CASADI_PREFIX(get_pool_double)(const char* name) {\n";
482  for (const auto& e : pool_double_) {
483  casadi_int i = e.second;
484  s << " if (strcmp(name, \"" + e.first + "\")==0) "
485  << "return casadi_pd" + str(i) + ";\n";
486  }
487  s << " return 0;\n";
488  s << "}\n";
489  }
490 
491  // Mex entry point
492  if (this->mex) generate_mex(s);
493 
494  // Main entry point
495  if (this->main) generate_main(s);
496 
497  // Finalize file
498  stream_close(s, this->cpp);
499  s_ptr.reset();
500 
501  // Generate s-function
502  if (this->with_sfunction) {
503  for (unsigned ii=0; ii<this->added_sfunctions.size(); ii++) {
504  std::string sfunction_code = this->added_sfunctions.at(ii);
505  std::string sfunction_name = this->exposed_fname.at(ii);
506  generate_sfunction(sfunction_name, sfunction_code);
507  }
508  }
509 
510  // Generate header
511  if (this->with_header) {
512  auto s_ptr = Filesystem::ofstream_ptr(prefix + this->name + ".h");
513  std::ostream& s = *s_ptr;
514  // Create a header file
515  stream_open(s, this->cpp);
516 
517  // Define the casadi_real type (typically double)
518  generate_casadi_real(s);
519 
520  // Define the casadi_int type
521  generate_casadi_int(s);
522 
523  // Generate export symbol macros
524  if (this->with_import) generate_import_symbol(s);
525 
526  // Add declarations
527  s << this->header.str();
528 
529  // Finalize file
530  stream_close(s, this->cpp);
531  s_ptr.reset();
532  }
533  return fullname;
534  }
casadi::CodeGenerator::stream_open
static void stream_open(std::ostream &f, bool cpp)
Print file header.
Definition: code_generator.cpp:389
casadi::CodeGenerator::stream_close
static void stream_close(std::ostream &f, bool cpp)
Print file header.
Definition: code_generator.cpp:408
casadi::Filesystem::ofstream_ptr
static std::unique_ptr< std::ostream > ofstream_ptr(const std::string &path, std::ios_base::openmode mode=std::ios_base::out)
Definition: filesystem.cpp:115

References added_sfunctions, cpp, dump(), exposed_fname, header, main, mex, name, casadi::Filesystem::ofstream_ptr(), pool_double_, pool_double_defaults_, prefix, casadi::str(), stream_close(), stream_open(), suffix, with_header, with_import, and with_sfunction.

Referenced by casadi::DaeBuilderInternal::export_fmu(), casadi::FunctionInternal::finalize(), casadi::Function::generate(), casadi::OracleFunction::generate_dependencies(), and casadi::Scpgen::init().

◆ get_constant() [1/4]

casadi_int casadi::CodeGenerator::get_constant ( const std::vector< casadi_int > &  v,
bool  allow_adding = false 
)

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

Definition at line 1265 of file code_generator.cpp.

1265  {
1266  // Hash the vector
1267  size_t h = hash(v);
1268 
1269  // Try to locate it in already added constants
1270  std::pair<std::multimap<size_t, size_t>::iterator, std::multimap<size_t, size_t>::iterator> eq =
1271  added_integer_constants_.equal_range(h);
1272  for (std::multimap<size_t, size_t>::iterator i=eq.first; i!=eq.second; ++i) {
1273  if (equal(v, integer_constants_[i->second])) return i->second;
1274  }
1275 
1276  if (allow_adding) {
1277  // Add to constants
1278  casadi_int ind = integer_constants_.size();
1279  integer_constants_.push_back(v);
1280  added_integer_constants_.insert(std::pair<size_t, size_t>(h, ind));
1281  return ind;
1282  } else {
1283  casadi_error("Constant not found");
1284  return -1;
1285  }
1286  }
casadi::CodeGenerator::hash
static size_t hash(const std::vector< double > &v)
Definition: code_generator.cpp:1211
casadi::CodeGenerator::added_integer_constants_
std::multimap< size_t, size_t > added_integer_constants_
Definition: code_generator.hpp:1016
casadi::CodeGenerator::equal
static bool equal(const std::vector< T > &v1, const std::vector< T > &v2)
Definition: code_generator.hpp:1057

References added_integer_constants_, equal(), hash(), and integer_constants_.

◆ get_constant() [2/4]

casadi_int casadi::CodeGenerator::get_constant ( const std::vector< char > &  v,
bool  allow_adding = false 
)

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

Definition at line 1288 of file code_generator.cpp.

1288  {
1289  // Hash the vector
1290  size_t h = hash(v);
1291 
1292  // Try to locate it in already added constants
1293  std::pair<std::multimap<size_t, size_t>::iterator, std::multimap<size_t, size_t>::iterator> eq =
1294  added_char_constants_.equal_range(h);
1295  for (std::multimap<size_t, size_t>::iterator i=eq.first; i!=eq.second; ++i) {
1296  if (equal(v, char_constants_[i->second])) return i->second;
1297  }
1298 
1299  if (allow_adding) {
1300  // Add to constants
1301  casadi_int ind = char_constants_.size();
1302  char_constants_.push_back(v);
1303  added_char_constants_.insert(std::pair<size_t, size_t>(h, ind));
1304  return ind;
1305  } else {
1306  casadi_error("Constant not found");
1307  return -1;
1308  }
1309  }
casadi::CodeGenerator::added_char_constants_
std::multimap< size_t, size_t > added_char_constants_
Definition: code_generator.hpp:1017

References added_char_constants_, char_constants_, equal(), and hash().

◆ get_constant() [3/4]

casadi_int casadi::CodeGenerator::get_constant ( const std::vector< double > &  v,
bool  allow_adding = false 
)

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

Definition at line 1243 of file code_generator.cpp.

1243  {
1244  // Hash the vector
1245  size_t h = hash(v);
1246 
1247  // Try to locate it in already added constants
1248  auto eq = added_double_constants_.equal_range(h);
1249  for (auto i=eq.first; i!=eq.second; ++i) {
1250  if (equal(v, double_constants_[i->second])) return i->second;
1251  }
1252 
1253  if (allow_adding) {
1254  // Add to constants
1255  casadi_int ind = double_constants_.size();
1256  double_constants_.push_back(v);
1257  added_double_constants_.insert(std::make_pair(h, ind));
1258  return ind;
1259  } else {
1260  casadi_error("Constant not found");
1261  return -1;
1262  }
1263  }
casadi::CodeGenerator::added_double_constants_
std::multimap< size_t, size_t > added_double_constants_
Definition: code_generator.hpp:1015

References added_double_constants_, double_constants_, equal(), and hash().

Referenced by add_sparsity(), constant(), and get_sparsity().

◆ get_constant() [4/4]

casadi_int casadi::CodeGenerator::get_constant ( const std::vector< std::string > &  v,
bool  allow_adding = false 
)

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

Definition at line 1311 of file code_generator.cpp.

1311  {
1312  // Hash the vector
1313  size_t h = hash(v);
1314 
1315  // Try to locate it in already added constants
1316  std::pair<std::multimap<size_t, size_t>::iterator, std::multimap<size_t, size_t>::iterator> eq =
1317  added_string_constants_.equal_range(h);
1318  for (std::multimap<size_t, size_t>::iterator i=eq.first; i!=eq.second; ++i) {
1319  if (equal(v, string_constants_[i->second])) return i->second;
1320  }
1321 
1322  if (allow_adding) {
1323  // Add to constants
1324  casadi_int ind = string_constants_.size();
1325  string_constants_.push_back(v);
1326  added_string_constants_.insert(std::pair<size_t, size_t>(h, ind));
1327  return ind;
1328  } else {
1329  casadi_error("Constant not found");
1330  return -1;
1331  }
1332  }
casadi::CodeGenerator::added_string_constants_
std::multimap< size_t, size_t > added_string_constants_
Definition: code_generator.hpp:1018

References added_string_constants_, equal(), hash(), and string_constants_.

◆ get_sparsity()

casadi_int casadi::CodeGenerator::get_sparsity ( const Sparsity &  sp) const

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

Definition at line 1207 of file code_generator.cpp.

1207  {
1208  return const_cast<CodeGenerator&>(*this).get_constant(sp, false);
1209  }
casadi::CodeGenerator::CodeGenerator
CodeGenerator(const std::string &name, const Dict &opts=Dict())
Constructor.
Definition: code_generator.cpp:37

References get_constant().

◆ hash() [1/4]

size_t casadi::CodeGenerator::hash ( const std::vector< casadi_int > &  v)
static

Definition at line 1225 of file code_generator.cpp.

1225  {
1226  size_t seed=0;
1227  hash_combine(seed, v);
1228  return seed;
1229  }
casadi::hash_combine
void hash_combine(std::size_t &seed, T v)
Generate a hash value incrementally (function taken from boost)
Definition: sparsity.hpp:1207

References casadi::hash_combine().

◆ hash() [2/4]

size_t casadi::CodeGenerator::hash ( const std::vector< char > &  v)
static

Definition at line 1231 of file code_generator.cpp.

1231  {
1232  size_t seed=0;
1233  hash_combine(seed, v);
1234  return seed;
1235  }

References casadi::hash_combine().

◆ hash() [3/4]

size_t casadi::CodeGenerator::hash ( const std::vector< double > &  v)
static

Definition at line 1211 of file code_generator.cpp.

1211  {
1212  // Calculate a hash value for the vector
1213  std::size_t seed=0;
1214  if (!v.empty()) {
1215  casadi_assert_dev(sizeof(double) % sizeof(size_t)==0);
1216  const casadi_int int_len = v.size()*(sizeof(double)/sizeof(size_t));
1217  const size_t* int_v = reinterpret_cast<const size_t*>(&v.front());
1218  for (size_t i=0; i<int_len; ++i) {
1219  hash_combine(seed, int_v[i]);
1220  }
1221  }
1222  return seed;
1223  }

References casadi::hash_combine().

Referenced by get_constant().

◆ hash() [4/4]

size_t casadi::CodeGenerator::hash ( const std::vector< std::string > &  v)
static

Definition at line 1237 of file code_generator.cpp.

1237  {
1238  size_t seed=0;
1239  hash_combine(seed, v);
1240  return seed;
1241  }

References casadi::hash_combine().

◆ indent()

void casadi::CodeGenerator::indent ( )
inline

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

Definition at line 254 of file code_generator.hpp.

254 {current_indent_++;}

Referenced by print_formatted().

◆ init_local()

void casadi::CodeGenerator::init_local ( const std::string &  name,
const std::string &  def 
)

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

Definition at line 2350 of file code_generator.cpp.

2350  {
2351  auto it = local_default_.find(name);
2352  if (it!=local_default_.end()) {
2353  casadi_assert(it->second==def, "Initial value mismatch for " + name);
2354  }
2355  local_default_.insert(std::make_pair(name, def));
2356  }
casadi::CodeGenerator::local_default_
std::map< std::string, std::string > local_default_
Definition: code_generator.hpp:1020

References local_default_, and name.

Referenced by casadi::FiniteDiff::codegen_body(), casadi::MXFunction::codegen_body(), casadi::ClarabelInterface::codegen_body(), casadi::DaqpInterface::codegen_body(), casadi::FatropInterface::codegen_body(), casadi::HighsInterface::codegen_body(), casadi::IpoptInterface::codegen_body(), casadi::MadnlpInterface::codegen_body(), casadi::OsqpInterface::codegen_body(), casadi::Feasiblesqpmethod::codegen_body(), casadi::Sqpmethod::codegen_body(), casadi::Nlpsol::codegen_body_exit(), casadi::Feasiblesqpmethod::codegen_feasibility_iterations(), casadi::codegen_local(), and constant_copy().

◆ initializer()

template<typename T >
std::string casadi::CodeGenerator::initializer ( const std::vector< T > &  v)
inline

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

Definition at line 283 of file code_generator.hpp.

283  {
284  std::stringstream s;
285  if (v.size() > max_initializer_elements_per_line) {
286  s << "\n ";
287  }
288 
289  s << "{";
290  for (casadi_int i = 0; i < v.size(); ++i) {
291  if (i != 0) {
292  if (max_initializer_elements_per_line > 1 &&
293  i % max_initializer_elements_per_line == 0) {
294  s << ",\n ";
295  } else {
296  s << ", ";
297  }
298  }
299  s << constant(v[i]);
300  }
301  s << "}";
302  return s.str();
303  }

Referenced by dump(), and print_vector().

◆ interpn()

std::string casadi::CodeGenerator::interpn ( const std::string &  res,
casadi_int  ndim,
const std::string &  grid,
const std::string &  offset,
const std::string &  values,
const std::string &  x,
const std::string &  lookup_mode,
casadi_int  m,
const std::string &  iw,
const std::string &  w 
)

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

Definition at line 2050 of file code_generator.cpp.

2055  {
2056  add_auxiliary(AUX_INTERPN);
2057  std::stringstream s;
2058  s << "casadi_interpn(" << res << ", " << ndim << ", " << grid << ", " << offset << ", "
2059  << values << ", " << x << ", " << lookup_mode << ", " << m << ", " << iw << ", " << w << ");";
2060  return s.str();
2061  }

References add_auxiliary(), AUX_INTERPN, and res().

Referenced by casadi::LinearInterpolant::codegen_body().

◆ interpn_grad()

std::string casadi::CodeGenerator::interpn_grad ( const std::string &  grad,
casadi_int  ndim,
const std::string &  grid,
const std::string &  offset,
const std::string &  values,
const std::string &  x,
const std::string &  lookup_mode,
casadi_int  m,
const std::string &  iw,
const std::string &  w 
)

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

Definition at line 2063 of file code_generator.cpp.

2067  {
2068  add_auxiliary(AUX_INTERPN_GRAD);
2069  std::stringstream s;
2070  s << "casadi_interpn_grad(" << grad << ", " << ndim << ", " << grid << ", " << offset << ", "
2071  << values << ", " << x << ", " << lookup_mode << "," << m << ", " << iw << ", " << w << ");";
2072  return s.str();
2073  }

References add_auxiliary(), and AUX_INTERPN_GRAD.

Referenced by casadi::LinearInterpolantJac::codegen_body().

◆ lb_eig()

std::string casadi::CodeGenerator::lb_eig ( const Sparsity &  sp_h,
const std::string &  h 
)

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

Definition at line 2623 of file code_generator.cpp.

2624  {
2625  add_auxiliary(CodeGenerator::AUX_REGULARIZE);
2626  return "casadi_lb_eig(" + sparsity(sp_h) + ", " + h + ")";
2627  }

References add_auxiliary(), AUX_REGULARIZE, and sparsity().

◆ ldl()

std::string casadi::CodeGenerator::ldl ( const std::string &  sp_a,
const std::string &  a,
const std::string &  sp_lt,
const std::string &  lt,
const std::string &  d,
const std::string &  p,
const std::string &  w 
)

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

Definition at line 2515 of file code_generator.cpp.

2518  {
2519  add_auxiliary(CodeGenerator::AUX_LDL);
2520  return "casadi_ldl(" + sp_a + ", " + a + ", " + sp_lt + ", " + lt + ", "
2521  + d + ", " + p + ", " + w + ");";
2522  }

References add_auxiliary(), and AUX_LDL.

Referenced by casadi::LinsolLdl::generate().

◆ ldl_solve()

std::string casadi::CodeGenerator::ldl_solve ( const std::string &  x,
casadi_int  nrhs,
const std::string &  sp_lt,
const std::string &  lt,
const std::string &  d,
const std::string &  p,
const std::string &  w 
)

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

Definition at line 2524 of file code_generator.cpp.

2527  {
2528  add_auxiliary(CodeGenerator::AUX_LDL);
2529  return "casadi_ldl_solve(" + x + ", " + str(nrhs) + ", " + sp_lt + ", "
2530  + lt + ", " + d + ", " + p + ", " + w + ");";
2531  }

References add_auxiliary(), AUX_LDL, and casadi::str().

Referenced by casadi::LinsolLdl::generate().

◆ local()

void casadi::CodeGenerator::local ( const std::string &  name,
const std::string &  type,
const std::string &  ref = "" 
)

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

Definition at line 2323 of file code_generator.cpp.

2324  {
2325  // Check if the variable already exists
2326  auto it = local_variables_.find(name);
2327  if (it==local_variables_.end()) {
2328  // Add it
2329  local_variables_[name] = std::make_pair(type, ref);
2330  } else {
2331  // Consistency check
2332  casadi_assert(it->second.first==type, "Type mismatch for " + name);
2333  casadi_assert(it->second.second==ref, "Type mismatch for " + name);
2334  }
2335  }
casadi::CodeGenerator::local_variables_
std::map< std::string, std::pair< std::string, std::string > > local_variables_
Definition: code_generator.hpp:1019

References local_variables_, and name.

Referenced by casadi::FiniteDiff::codegen_body(), casadi::JitFunction::codegen_body(), casadi::Map::codegen_body(), casadi::MapSum::codegen_body(), casadi::MXFunction::codegen_body(), casadi::Switch::codegen_body(), 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::FastNewton::codegen_body(), casadi::Feasiblesqpmethod::codegen_body(), casadi::Qrqp::codegen_body(), casadi::Sqpmethod::codegen_body(), casadi::OracleFunction::codegen_body_enter(), casadi::Nlpsol::codegen_body_enter(), casadi::Nlpsol::codegen_body_exit(), casadi::Feasiblesqpmethod::codegen_feasibility_iterations(), casadi::OsqpInterface::codegen_init_mem(), casadi::codegen_local(), casadi::codegen_unpack_block(), constant_copy(), casadi::Convexify::generate(), casadi::BinaryMX< ScX, ScY >::generate(), casadi::Call::generate(), casadi::Find::generate(), casadi::Low::generate(), casadi::Concat::generate(), casadi::Einstein::generate(), casadi::GetNonzerosVector::generate(), casadi::GetNonzerosSlice::generate(), casadi::GetNonzerosSlice2::generate(), casadi::GetNonzerosParamVector::generate(), casadi::GetNonzerosSliceParam::generate(), casadi::GetNonzerosParamSlice::generate(), casadi::GetNonzerosParamParam::generate(), casadi::DenseMultiplication::generate(), casadi::HorzRepmat::generate(), casadi::HorzRepsum::generate(), casadi::SetNonzerosVector< Add >::generate(), casadi::SetNonzerosSlice< Add >::generate(), casadi::SetNonzerosSlice2< Add >::generate(), casadi::SetNonzerosParamVector< Add >::generate(), casadi::SetNonzerosParamSlice< Add >::generate(), casadi::SetNonzerosSliceParam< Add >::generate(), casadi::SetNonzerosParamParam< Add >::generate(), casadi::LinsolCall< Tr >::generate(), casadi::DenseTranspose::generate(), casadi::UnaryMX::generate(), operator()(), casadi::Conic::qp_codegen_body(), and sx_work().

◆ logsumexp()

std::string casadi::CodeGenerator::logsumexp ( const std::string &  A,
casadi_int  n 
)

\brie LogSumExp

Definition at line 2264 of file code_generator.cpp.

2264  {
2265  add_auxiliary(AUX_LOGSUMEXP);
2266  std::stringstream s;
2267  s << "casadi_logsumexp(" << A << ", " << n << ");";
2268  return s.str();
2269  }

References add_auxiliary(), and AUX_LOGSUMEXP.

Referenced by casadi::LogSumExp::generate().

◆ low()

std::string casadi::CodeGenerator::low ( const std::string &  x,
const std::string &  grid,
casadi_int  ng,
casadi_int  lookup_mode 
)

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

Definition at line 2642 of file code_generator.cpp.

2643  {
2644  add_auxiliary(CodeGenerator::AUX_LOW);
2645  return "casadi_low(" + x + ", " + grid + ", " + str(ng) + ", " + str(lookup_mode) + ");";
2646  }

References add_auxiliary(), AUX_LOW, and casadi::str().

Referenced by casadi::Low::generate().

◆ lsqr_solve()

std::string casadi::CodeGenerator::lsqr_solve ( const std::string &  A,
const std::string &  x,
casadi_int  nrhs,
bool  tr,
const std::string &  sp,
const std::string &  w 
)

\brief LSQR solve

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

Definition at line 2507 of file code_generator.cpp.

2509  {
2510  add_auxiliary(CodeGenerator::AUX_LSQR);
2511  return "casadi_lsqr_solve(" + A + ", " + x + ", " + str(nrhs) + ", "
2512  + (tr ? "1" : "0") + ", " + sp + ", " + w + ");";
2513  }

References add_auxiliary(), AUX_LSQR, and casadi::str().

Referenced by casadi::Lsqr::generate().

◆ masked_norm_inf()

std::string casadi::CodeGenerator::masked_norm_inf ( casadi_int  n,
const std::string &  x,
const std::string &  mask 
)

Definition at line 2215 of file code_generator.cpp.

2216  {
2217  add_auxiliary(AUX_MASKED_NORM_INF);
2218  return "casadi_masked_norm_inf(" + str(n) + ", " + x + ", " + mask + ")";
2219  }

References add_auxiliary(), AUX_MASKED_NORM_INF, and casadi::str().

Referenced by casadi::Feasiblesqpmethod::codegen_body(), casadi::Feasiblesqpmethod::codegen_feasibility_iterations(), and casadi::Feasiblesqpmethod::codegen_tr_update().

◆ max()

std::string casadi::CodeGenerator::max ( const std::string &  x,
const std::string &  y 
)

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

Definition at line 2569 of file code_generator.cpp.

2570  {
2571  add_auxiliary(CodeGenerator::AUX_MAX);
2572  return "casadi_max(" + x + ", " + y + ")";
2573  }

References add_auxiliary(), and AUX_MAX.

◆ max_viol()

std::string casadi::CodeGenerator::max_viol ( casadi_int  n,
const std::string &  x,
const std::string &  lb,
const std::string &  ub 
)

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

Definition at line 2593 of file code_generator.cpp.

2594  {
2595  add_auxiliary(CodeGenerator::AUX_MAX_VIOL);
2596  return "casadi_max_viol(" + str(n) + ", " + x+ ", " + lb + ", " + ub + ")";
2597  }

References add_auxiliary(), AUX_MAX_VIOL, and casadi::str().

Referenced by casadi::Feasiblesqpmethod::codegen_body(), casadi::Sqpmethod::codegen_body(), and casadi::Feasiblesqpmethod::codegen_feasibility_iterations().

◆ mem()

std::string casadi::CodeGenerator::mem ( const Function &  f)

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

Definition at line 2008 of file code_generator.cpp.

2008  {
2009  std::string name = f->codegen_name(*this, false);
2010  std::string mem_array = shorthand(name + "_mem");
2011  return mem_array+"[mem]";
2012  }

References casadi::FunctionInternal::codegen_name(), name, and shorthand().

Referenced by operator()().

◆ min()

std::string casadi::CodeGenerator::min ( const std::string &  x,
const std::string &  y 
)

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

Definition at line 2575 of file code_generator.cpp.

2576  {
2577  add_auxiliary(CodeGenerator::AUX_MIN);
2578  return "casadi_min(" + x + ", " + y + ")";
2579  }

References add_auxiliary(), and AUX_MIN.

Referenced by clip_max(), and clip_min().

◆ mmax()

std::string casadi::CodeGenerator::mmax ( const std::string &  x,
casadi_int  n,
bool  is_dense 
)

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

Definition at line 2581 of file code_generator.cpp.

2582  {
2583  add_auxiliary(CodeGenerator::AUX_MMAX);
2584  return "casadi_mmax(" + x + ", " + str(n) + ", " + str(casadi_int(is_dense)) + ")";
2585  }

References add_auxiliary(), AUX_MMAX, and casadi::str().

Referenced by casadi::MMax::generate().

◆ mmin()

std::string casadi::CodeGenerator::mmin ( const std::string &  x,
casadi_int  n,
bool  is_dense 
)

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

Definition at line 2587 of file code_generator.cpp.

2588  {
2589  add_auxiliary(CodeGenerator::AUX_MMIN);
2590  return "casadi_mmin(" + x + ", " + str(n) + ", " + str(casadi_int(is_dense)) + ")";
2591  }

References add_auxiliary(), AUX_MMIN, and casadi::str().

Referenced by casadi::MMin::generate().

◆ mtimes()

std::string casadi::CodeGenerator::mtimes ( const std::string &  x,
const Sparsity &  sp_x,
const std::string &  y,
const Sparsity &  sp_y,
const std::string &  z,
const Sparsity &  sp_z,
const std::string &  w,
bool  tr 
)

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

Definition at line 2240 of file code_generator.cpp.

2243  {
2244  add_auxiliary(AUX_MTIMES);
2245  return "casadi_mtimes(" + x + ", " + sparsity(sp_x) + ", " + y + ", " + sparsity(sp_y) + ", "
2246  + z + ", " + sparsity(sp_z) + ", " + w + ", " + (tr ? "1" : "0") + ");";
2247  }

References add_auxiliary(), AUX_MTIMES, and sparsity().

Referenced by casadi::Multiplication::generate().

◆ mv() [1/2]

std::string casadi::CodeGenerator::mv ( const std::string &  x,
casadi_int  nrow_x,
casadi_int  ncol_x,
const std::string &  y,
const std::string &  z,
bool  tr 
)

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

Definition at line 2233 of file code_generator.cpp.

2234  {
2235  add_auxiliary(AUX_MV_DENSE);
2236  return "casadi_mv_dense(" + x + ", " + str(nrow_x) + ", " + str(ncol_x) + ", "
2237  + y + ", " + z + ", " + (tr ? "1" : "0") + ");";
2238  }

References add_auxiliary(), AUX_MV_DENSE, and casadi::str().

◆ mv() [2/2]

std::string casadi::CodeGenerator::mv ( const std::string &  x,
const Sparsity &  sp_x,
const std::string &  y,
const std::string &  z,
bool  tr 
)

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

Definition at line 2226 of file code_generator.cpp.

2227  {
2228  add_auxiliary(AUX_MV);
2229  return "casadi_mv(" + x + ", " + sparsity(sp_x) + ", " + y + ", "
2230  + z + ", " + (tr ? "1" : "0") + ");";
2231  }

References add_auxiliary(), AUX_MV, and sparsity().

Referenced by casadi::Feasiblesqpmethod::codegen_body(), casadi::Sqpmethod::codegen_body(), casadi::Feasiblesqpmethod::codegen_feasibility_iterations(), and casadi::Sqpmethod::codegen_solve_elastic_mode().

◆ norm_1()

std::string casadi::CodeGenerator::norm_1 ( casadi_int  n,
const std::string &  x 
)

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

Definition at line 2611 of file code_generator.cpp.

2612  {
2613  add_auxiliary(CodeGenerator::AUX_NORM_1);
2614  return "casadi_norm_1(" + str(n) + ", " + x + ")";
2615  }

References add_auxiliary(), AUX_NORM_1, and casadi::str().

Referenced by casadi::Norm1::generate().

◆ norm_2()

std::string casadi::CodeGenerator::norm_2 ( casadi_int  n,
const std::string &  x 
) 
     Extra doc: https://github.com/casadi/casadi/wiki/L_256

Definition at line 2617 of file code_generator.cpp.

2618  {
2619  add_auxiliary(CodeGenerator::AUX_NORM_2);
2620  return "casadi_norm_2(" + str(n) + ", " + x + ")";
2621  }

References add_auxiliary(), AUX_NORM_2, and casadi::str().

Referenced by casadi::Feasiblesqpmethod::codegen_feasibility_iterations(), and casadi::NormF::generate().

◆ norm_inf()

std::string casadi::CodeGenerator::norm_inf ( casadi_int  n,
const std::string &  x 
)

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

Definition at line 2605 of file code_generator.cpp.

2606  {
2607  add_auxiliary(CodeGenerator::AUX_NORM_INF);
2608  return "casadi_norm_inf(" + str(n) + ", " + x + ")";
2609  }

References add_auxiliary(), AUX_NORM_INF, and casadi::str().

Referenced by casadi::Feasiblesqpmethod::codegen_body(), casadi::Sqpmethod::codegen_body(), casadi::Sqpmethod::codegen_calc_gamma_1(), and casadi::NormInf::generate().

◆ ones()

std::string casadi::CodeGenerator::ones ( casadi_int  sz)

Definition at line 1351 of file code_generator.cpp.

1351  {
1352  sz_ones_ = std::max(sz_ones_, sz);
1353  return shorthand("ones");
1354  }

References shorthand(), and sz_ones_.

◆ operator()()

std::string casadi::CodeGenerator::operator() ( const Function &  f,
const std::string &  arg,
const std::string &  res,
const std::string &  iw,
const std::string &  w,
const std::string &  failure_ret = "1" 
)

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

Definition at line 1160 of file code_generator.cpp.

1163  {
1164  std::string name = add_dependency(f);
1165  bool needs_mem = !f->codegen_mem_type().empty();
1166  if (needs_mem) {
1167  std::string mem = "mid";
1168  local("flag", "int");
1169  local(mem, "int");
1170  *this << mem << " = " << name << "_checkout();\n";
1171  *this << "if (" << mem << "<0) return " << failure_ret << ";\n";
1172  *this << "flag = " + name + "(" + arg + ", " + res + ", "
1173  + iw + ", " + w + ", " << mem << ");\n";
1174  *this << name << "_release(" << mem << ");\n";
1175  return "flag";
1176  } else {
1177  return name + "(" + arg + ", " + res + ", "
1178  + iw + ", " + w + ", 0)";
1179  }
1180  }
casadi::CodeGenerator::mem
std::string mem(const Function &f)
Access thread-local memory.
Definition: code_generator.cpp:2008

References add_dependency(), arg(), casadi::FunctionInternal::codegen_mem_type(), local(), mem(), name, and res().

◆ operator<<() [1/2]

CodeGenerator & casadi::CodeGenerator::operator<< ( const std::string &  s)

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

Definition at line 2297 of file code_generator.cpp.

2297  {
2298  // Loop over newline characters
2299  size_t off=0;
2300  while (true) {
2301  size_t pos = s.find('\n', off);
2302  if (pos==std::string::npos) {
2303  // No more newline characters
2304  print_formatted(s.substr(off));
2305  break;
2306  } else {
2307  // Ends with newline
2308  print_formatted(s.substr(off, pos-off));
2309  this->buffer << '\n';
2310  newline_ = true;
2311  off = pos+1;
2312  }
2313  }
2314 
2315  return *this;
2316  }
casadi::CodeGenerator::print_formatted
void print_formatted(const std::string &s)
Print without newline characters.
Definition: code_generator.cpp:2271

References buffer, newline_, and print_formatted().

◆ operator<<() [2/2]

template<typename T >
CodeGenerator& casadi::CodeGenerator::operator<< ( T  s)
inline

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

Definition at line 215 of file code_generator.hpp.

215  {
216  std::stringstream ss;
217  ss << s;
218  return (*this) << ss.str();
219  }

◆ pool_double()

std::string casadi::CodeGenerator::pool_double ( const std::string &  name) const

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

Definition at line 835 of file code_generator.cpp.

835  {
836  auto it = pool_double_.find(name);
837  casadi_assert(it!=pool_double_.end(), "Not defined.");
838  return "casadi_pd" + str(it->second);
839  }

References name, pool_double_, and casadi::str().

Referenced by casadi::ConstantPool::generate().

◆ print_canonical()

std::string casadi::CodeGenerator::print_canonical ( const Sparsity &  sp,
const std::string &  arg 
)

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

Definition at line 1059 of file code_generator.cpp.

1059  {
1060  add_auxiliary(AUX_PRINT_CANONICAL);
1061  std::stringstream s;
1062  s << "casadi_print_canonical(" << sparsity(sp) << ", " << arg << ");";
1063  return s.str();
1064  }

References add_auxiliary(), arg(), AUX_PRINT_CANONICAL, and sparsity().

Referenced by casadi::Monitor::generate(), casadi::MXFunction::print_arg(), and casadi::MXFunction::print_res().

◆ print_formatted()

void casadi::CodeGenerator::print_formatted ( const std::string &  s)

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

Definition at line 2271 of file code_generator.cpp.

2271  {
2272  // Quick return if empty
2273  if (s.empty()) return;
2274 
2275  // If new line, add indentation
2276  if (newline_) {
2277  casadi_int shift = s.front()=='}' ? -1 : 0;
2278  casadi_assert_dev(current_indent_+shift>=0);
2279  this->buffer << std::string(indent_*(current_indent_+shift), ' ');
2280  newline_ = false;
2281  }
2282 
2283  // Print to body
2284  this->buffer << s;
2285 
2286  // Brackets change indentation for next row
2287  // NOTE(@jaeandersson): Should ignore strings, comments
2288  for (char c : s) {
2289  if (c=='{') {
2290  indent();
2291  } else if (c=='}') {
2292  unindent();
2293  }
2294  }
2295  }
casadi::CodeGenerator::indent
void indent()
Increase indentation.
Definition: code_generator.hpp:254
casadi::CodeGenerator::unindent
void unindent()
Decrease indentation.
Definition: code_generator.hpp:259

References buffer, current_indent_, indent(), indent_, newline_, and unindent().

Referenced by operator<<().

◆ print_op() [1/2]

std::string casadi::CodeGenerator::print_op ( casadi_int  op,
const std::string &  a0 
)

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

Definition at line 1081 of file code_generator.cpp.

1081  {
1082  switch (op) {
1083  case OP_FABS:
1084  add_auxiliary(AUX_FABS);
1085  return "casadi_fabs("+a0+")";
1086  case OP_SQ:
1087  add_auxiliary(AUX_SQ);
1088  return "casadi_sq("+a0+")";
1089  case OP_SIGN:
1090  add_auxiliary(AUX_SIGN);
1091  return "casadi_sign("+a0+")";
1092  case OP_LOG1P:
1093  add_auxiliary(AUX_LOG1P);
1094  return "casadi_log1p("+a0+")";
1095  case OP_EXPM1:
1096  add_auxiliary(AUX_EXPM1);
1097  return "casadi_expm1("+a0+")";
1098  default:
1099  return casadi_math<double>::print(op, a0);
1100  }
1101  }
casadi::OP_SIGN
@ OP_SIGN
Definition: calculus.hpp:71
casadi::OP_LOG1P
@ OP_LOG1P
Definition: calculus.hpp:202
casadi::OP_EXPM1
@ OP_EXPM1
Definition: calculus.hpp:204
casadi::OP_FABS
@ OP_FABS
Definition: calculus.hpp:71
casadi::OP_SQ
@ OP_SQ
Definition: calculus.hpp:67
casadi::casadi_math::print
static std::string print(unsigned char op, const std::string &x, const std::string &y)
Print.
Definition: calculus.hpp:1641

References add_auxiliary(), AUX_EXPM1, AUX_FABS, AUX_LOG1P, AUX_SIGN, AUX_SQ, casadi::OP_EXPM1, casadi::OP_FABS, casadi::OP_LOG1P, casadi::OP_SIGN, casadi::OP_SQ, and casadi::casadi_math< T >::print().

Referenced by casadi::SXFunction::codegen_body(), casadi::BinaryMX< ScX, ScY >::generate(), and casadi::UnaryMX::generate().

◆ print_op() [2/2]

std::string casadi::CodeGenerator::print_op ( casadi_int  op,
const std::string &  a0,
const std::string &  a1 
)

Definition at line 1102 of file code_generator.cpp.

1102  {
1103  switch (op) {
1104  case OP_FMIN:
1105  add_auxiliary(AUX_FMIN);
1106  return "casadi_fmin("+a0+","+a1+")";
1107  case OP_FMAX:
1108  add_auxiliary(AUX_FMAX);
1109  return "casadi_fmax("+a0+","+a1+")";
1110  case OP_HYPOT:
1111  add_auxiliary(AUX_HYPOT);
1112  return "casadi_hypot("+a0+","+a1+")";
1113  case OP_PRINTME:
1114  add_auxiliary(AUX_PRINTME);
1115  return "casadi_printme("+a0+","+a1+")";
1116  default:
1117  return casadi_math<double>::print(op, a0, a1);
1118  }
1119  }
casadi::OP_FMAX
@ OP_FMAX
Definition: calculus.hpp:72
casadi::OP_PRINTME
@ OP_PRINTME
Definition: calculus.hpp:190
casadi::OP_HYPOT
@ OP_HYPOT
Definition: calculus.hpp:206
casadi::OP_FMIN
@ OP_FMIN
Definition: calculus.hpp:72

References add_auxiliary(), AUX_FMAX, AUX_FMIN, AUX_HYPOT, AUX_PRINTME, casadi::OP_FMAX, casadi::OP_FMIN, casadi::OP_HYPOT, casadi::OP_PRINTME, and casadi::casadi_math< T >::print().

◆ print_scalar()

std::string casadi::CodeGenerator::print_scalar ( const std::string &  arg)

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

Definition at line 1073 of file code_generator.cpp.

1073  {
1074  add_auxiliary(AUX_PRINT_SCALAR);
1075  std::stringstream s;
1076  s << "casadi_print_scalar(" << arg << ");";
1077  return s.str();
1078  }

References add_auxiliary(), arg(), and AUX_PRINT_SCALAR.

◆ print_vector() [1/5]

std::string casadi::CodeGenerator::print_vector ( casadi_int  sz,
const std::string &  arg 
)

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

Definition at line 1066 of file code_generator.cpp.

1066  {
1067  add_auxiliary(AUX_PRINT_VECTOR);
1068  std::stringstream s;
1069  s << "casadi_print_vector(" << sz << ", " << arg << ");";
1070  return s.str();
1071  }

References add_auxiliary(), arg(), and AUX_PRINT_VECTOR.

◆ print_vector() [2/5]

void casadi::CodeGenerator::print_vector ( std::ostream &  s,
const std::string &  name,
const std::vector< casadi_int > &  v 
)

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

Definition at line 1039 of file code_generator.cpp.

1040  {
1041  s << array("static const casadi_int", name, v.size(), initializer(v));
1042  }
casadi::CodeGenerator::array
static std::string array(const std::string &type, const std::string &name, casadi_int len, const std::string &def=std::string())
Definition: code_generator.cpp:1025

References array(), initializer(), and name.

Referenced by dump(), casadi::SXFunction::print_arg(), and casadi::SXFunction::print_res().

◆ print_vector() [3/5]

void casadi::CodeGenerator::print_vector ( std::ostream &  s,
const std::string &  name,
const std::vector< char > &  v 
)

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

Definition at line 1044 of file code_generator.cpp.

1045  {
1046  s << array("static const char", name, v.size(), initializer(v));
1047  }

References array(), initializer(), and name.

◆ print_vector() [4/5]

void casadi::CodeGenerator::print_vector ( std::ostream &  s,
const std::string &  name,
const std::vector< double > &  v 
)

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

Definition at line 1049 of file code_generator.cpp.

1050  {
1051  s << array("static const casadi_real", name, v.size(), initializer(v));
1052  }

References array(), initializer(), and name.

◆ print_vector() [5/5]

void casadi::CodeGenerator::print_vector ( std::ostream &  s,
const std::string &  name,
const std::vector< std::string > &  v 
)

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

Definition at line 1054 of file code_generator.cpp.

1055  {
1056  s << array("static const char*", name, v.size(), initializer(v));
1057  }

References array(), initializer(), and name.

◆ printf() [1/4]

std::string casadi::CodeGenerator::printf ( const std::string &  str,
const std::string &  arg1 
)

Definition at line 2162 of file code_generator.cpp.

2162  {
2163  std::vector<std::string> arg;
2164  arg.push_back(arg1);
2165  return printf(str, arg);
2166  }
casadi::CodeGenerator::printf
std::string printf(const std::string &str, const std::vector< std::string > &arg=std::vector< std::string >())
Printf.
Definition: code_generator.cpp:2144

References arg(), printf(), and casadi::str().

◆ printf() [2/4]

std::string casadi::CodeGenerator::printf ( const std::string &  str,
const std::string &  arg1,
const std::string &  arg2 
)

Definition at line 2168 of file code_generator.cpp.

2169  {
2170  std::vector<std::string> arg;
2171  arg.push_back(arg1);
2172  arg.push_back(arg2);
2173  return printf(str, arg);
2174  }

References arg(), printf(), and casadi::str().

◆ printf() [3/4]

std::string casadi::CodeGenerator::printf ( const std::string &  str,
const std::string &  arg1,
const std::string &  arg2,
const std::string &  arg3 
)

Definition at line 2176 of file code_generator.cpp.

2177  {
2178  std::vector<std::string> arg;
2179  arg.push_back(arg1);
2180  arg.push_back(arg2);
2181  arg.push_back(arg3);
2182  return printf(str, arg);
2183  }

References arg(), printf(), and casadi::str().

◆ printf() [4/4]

std::string casadi::CodeGenerator::printf ( const std::string &  str,
const std::vector< std::string > &  arg = std::vector<std::string>() 
)

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

Definition at line 2144 of file code_generator.cpp.

2144  {
2145  add_auxiliary(AUX_PRINTF);
2146  std::stringstream s;
2147  s << "CASADI_PRINTF(";
2148  // Loop over lines in str
2149  std::string::size_type pos = 0, prev = 0;
2150  while ((pos = str.find('\n', prev)) != std::string::npos) {
2151  // Any line containing a trailing new line
2152  s << "\"" << str.substr(prev, pos-prev) << "\\n\"\n";
2153  prev = pos + 1;
2154  }
2155  // Remainder without trailing new line
2156  s << "\"" << str.substr(prev) << "\"";
2157  for (casadi_int i=0; i<arg.size(); ++i) s << ", " << arg[i];
2158  s << ");";
2159  return s.str();
2160  }

References add_auxiliary(), arg(), AUX_PRINTF, and casadi::str().

Referenced by casadi::Feasiblesqpmethod::codegen_body(), casadi::Qrqp::codegen_body(), casadi::FunctionInternal::codegen_meta(), casadi::Monitor::generate(), casadi::MXFunction::print_arg(), casadi::SXFunction::print_arg(), casadi::MXFunction::print_res(), casadi::SXFunction::print_res(), and printf().

◆ project()

std::string casadi::CodeGenerator::project ( const std::string &  arg,
const Sparsity &  sp_arg,
const std::string &  res,
const Sparsity &  sp_res,
const std::string &  w 
)

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

Definition at line 2097 of file code_generator.cpp.

2099  {
2100  // If sparsity match, simple copy
2101  if (sp_arg==sp_res) return copy(arg, sp_arg.nnz(), res);
2102 
2103  // Create call
2104  add_auxiliary(AUX_PROJECT);
2105  std::stringstream s;
2106  s << "casadi_project(" << arg << ", " << sparsity(sp_arg) << ", " << res << ", "
2107  << sparsity(sp_res) << ", " << w << ");";
2108  return s.str();
2109  }

References add_auxiliary(), arg(), AUX_PROJECT, copy(), casadi::Sparsity::nnz(), res(), and sparsity().

Referenced by casadi::Switch::codegen_body(), and casadi::Project::generate().

◆ qr()

std::string casadi::CodeGenerator::qr ( const std::string &  sp,
const std::string &  A,
const std::string &  w,
const std::string &  sp_v,
const std::string &  v,
const std::string &  sp_r,
const std::string &  r,
const std::string &  beta,
const std::string &  prinv,
const std::string &  pc 
)

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

Definition at line 2484 of file code_generator.cpp.

2488  {
2489  add_auxiliary(CodeGenerator::AUX_QR);
2490  return "casadi_qr(" + sp + ", " + A + ", " + w + ", "
2491  + sp_v + ", " + v + ", " + sp_r + ", " + r + ", "
2492  + beta + ", " + prinv + ", " + pc + ");";
2493  }

References add_auxiliary(), and AUX_QR.

Referenced by casadi::LinsolQr::generate().

◆ qr_solve()

std::string casadi::CodeGenerator::qr_solve ( const std::string &  x,
casadi_int  nrhs,
bool  tr,
const std::string &  sp_v,
const std::string &  v,
const std::string &  sp_r,
const std::string &  r,
const std::string &  beta,
const std::string &  prinv,
const std::string &  pc,
const std::string &  w 
)

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

Definition at line 2495 of file code_generator.cpp.

2500  {
2501  add_auxiliary(CodeGenerator::AUX_QR);
2502  return "casadi_qr_solve(" + x + ", " + str(nrhs) + ", " + (tr ? "1" : "0") + ", "
2503  + sp_v + ", " + v + ", " + sp_r + ", " + r + ", "
2504  + beta + ", " + prinv + ", " + pc + ", " + w + ");";
2505  }

References add_auxiliary(), AUX_QR, and casadi::str().

Referenced by casadi::LinsolQr::generate().

◆ rank1()

std::string casadi::CodeGenerator::rank1 ( const std::string &  A,
const Sparsity &  sp_A,
const std::string &  alpha,
const std::string &  x,
const std::string &  y 
)

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

Definition at line 2040 of file code_generator.cpp.

2042  {
2043  add_auxiliary(AUX_RANK1);
2044  std::stringstream s;
2045  s << "casadi_rank1(" << A << ", " << sparsity(sp_A) << ", "
2046  << alpha << ", " << x << ", " << y << ");";
2047  return s.str();
2048  }

References add_auxiliary(), AUX_RANK1, and sparsity().

Referenced by casadi::Rank1::generate().

◆ regularize()

std::string casadi::CodeGenerator::regularize ( const Sparsity &  sp_h,
const std::string &  h,
const std::string &  reg 
)

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

Definition at line 2629 of file code_generator.cpp.

2630  {
2631  add_auxiliary(CodeGenerator::AUX_REGULARIZE);
2632  return "casadi_regularize(" + sparsity(sp_h) + ", " + h + ", " + reg + ");";
2633  }

References add_auxiliary(), AUX_REGULARIZE, and sparsity().

◆ res()

std::string casadi::CodeGenerator::res ( casadi_int  i) const

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

Definition at line 2004 of file code_generator.cpp.

2004  {
2005  return "res[" + str(i) + "]";
2006  }

References casadi::str().

Referenced by clear(), casadi::FiniteDiff::codegen_body(), casadi::OmpMap::codegen_body(), casadi::Switch::codegen_body(), casadi::SXFunction::codegen_body(), casadi::OsqpInterface::codegen_body(), casadi::FastNewton::codegen_body(), casadi::Feasiblesqpmethod::codegen_body(), casadi::Qrqp::codegen_body(), casadi::FunctionInternal::codegen_meta(), copy(), copy_check(), copy_default(), densify(), fill(), from_mex(), casadi::Output::generate(), interpn(), operator()(), project(), sparsify(), and tri_project().

◆ reserve_work()

void casadi::CodeGenerator::reserve_work ( casadi_int  n)

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

Definition at line 1009 of file code_generator.cpp.

1009  {
1010  if (n == 0) {
1011  padding_length_ = 1;
1012  } else {
1013  // Zero based counting. The 10th entry is to be rendered as '9'
1014  padding_length_ = str(n-1).length();
1015  }
1016  }

References padding_length_, and casadi::str().

Referenced by casadi::MXFunction::codegen_body(), and casadi::SXFunction::codegen_body().

◆ rom_double()

std::string casadi::CodeGenerator::rom_double ( const void *  id) const

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

Definition at line 802 of file code_generator.cpp.

802  {
803  auto it = file_scope_double_.find(id);
804  casadi_assert(it!=file_scope_double_.end(), "Not defined.");
805  casadi_int size = std::distance(file_scope_double_.begin(), it);
806  return "casadi_rd" + str(size);
807  }

References file_scope_double_, and casadi::str().

Referenced by casadi::ConstantFile::codegen_incref(), and casadi::ConstantFile::generate().

◆ rom_integer()

std::string casadi::CodeGenerator::rom_integer ( const void *  id) const

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

Definition at line 816 of file code_generator.cpp.

816  {
817  auto it = file_scope_double_.find(id);
818  casadi_assert(it!=file_scope_double_.end(), "Not defined.");
819  casadi_int size = std::distance(file_scope_double_.begin(), it);
820  return "casadi_ri" + str(size);
821  }

References file_scope_double_, and casadi::str().

◆ sanitize_source()

std::string casadi::CodeGenerator::sanitize_source ( const std::string &  src,
const std::vector< std::string > &  inst,
bool  add_shorthand = true 
)

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

Definition at line 2358 of file code_generator.cpp.

2360  {
2361  // Create suffix if templates type are not all "casadi_real"
2362  std::string suffix;
2363  for (const std::string& s : inst) {
2364  if (s!="casadi_real") {
2365  for (const std::string& s : inst) suffix += "_" + s;
2366  break;
2367  }
2368  }
2369 
2370  // Construct map of name replacements
2371  std::vector<std::pair<std::string, std::string> > rep;
2372  for (casadi_int i=0; i<inst.size(); ++i) {
2373  rep.push_back(std::make_pair("T" + str(i+1), inst[i]));
2374  }
2375 
2376  // Return object
2377  std::stringstream ret;
2378  // Process C++ source
2379  std::string line;
2380  std::istringstream stream(src);
2381  while (std::getline(stream, line)) {
2382  size_t n1, n2;
2383 
2384  // C++ template declarations are ignored
2385  if (line.find("template")==0) continue;
2386 
2387  // Macro definitions are ignored
2388  if (line.find("#define")==0) continue;
2389  if (line.find("#undef")==0) continue;
2390 
2391  // Inline declaration
2392  if (line == "inline") continue;
2393 
2394  // If line starts with "// SYMBOL", add shorthand
2395  if (line.find("// SYMBOL") != std::string::npos) {
2396  n1 = line.find("\"");
2397  n2 = line.find("\"", n1+1);
2398  std::string sym = line.substr(n1+1, n2-n1-1);
2399  if (add_shorthand) shorthand(sym + suffix);
2400  if (!suffix.empty()) {
2401  rep.push_back(std::make_pair(sym, sym + suffix));
2402  }
2403  continue;
2404  }
2405 
2406  // If line starts with "// C-REPLACE", add to list of replacements
2407  if (line.find("// C-REPLACE") != std::string::npos) {
2408  // Get C++ string
2409  n1 = line.find("\"");
2410  n2 = line.find("\"", n1+1);
2411  std::string key = line.substr(n1+1, n2-n1-1);
2412  // Get C string
2413  n1 = line.find("\"", n2+1);
2414  n2 = line.find("\"", n1+1);
2415  std::string sub = line.substr(n1+1, n2-n1-1);
2416  // Add to replacements
2417  rep.push_back(std::make_pair(key, sub));
2418  continue;
2419  }
2420 
2421  // If line starts with "// C-VERBOSE", skip the next line
2422  if (!verbose_runtime && line.find("// C-VERBOSE") != std::string::npos) {
2423  // Ignore next line
2424  std::getline(stream, line);
2425  continue;
2426  }
2427 
2428  // Ignore other C++ style comment
2429  if ((n1 = line.find("//")) != std::string::npos) line.erase(n1);
2430 
2431  // Remove trailing spaces
2432  if ((n1 = line.find_last_not_of(' ')) != std::string::npos) {
2433  line.erase(n1 + 1);
2434  } else {
2435  continue;
2436  }
2437 
2438  // Perform string replacements
2439  for (auto&& it = rep.rbegin(); it!=rep.rend(); ++it) {
2440  line = replace(line, it->first, it->second);
2441  }
2442 
2443  // Append to return
2444  ret << line << "\n";
2445  }
2446 
2447  // Trailing newline
2448  ret << "\n";
2449  return ret.str();
2450  }

References casadi::replace(), shorthand(), casadi::str(), suffix, and verbose_runtime.

Referenced by add_auxiliary(), casadi::ClarabelInterface::codegen_body(), casadi::DaqpInterface::codegen_body(), casadi::FatropInterface::codegen_body(), casadi::HighsInterface::codegen_body(), casadi::HpipmInterface::codegen_body(), casadi::IpoptInterface::codegen_body(), and casadi::MadnlpInterface::codegen_body().

◆ scal()

std::string casadi::CodeGenerator::scal ( casadi_int  n,
const std::string &  alpha,
const std::string &  x 
)

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

Definition at line 2221 of file code_generator.cpp.

2221  {
2222  add_auxiliary(AUX_SCAL);
2223  return "casadi_scal(" + str(n) + ", " + alpha + ", " + x + ");";
2224  }

References add_auxiliary(), AUX_SCAL, and casadi::str().

Referenced by casadi::Sqpmethod::codegen_body(), and casadi::Nlpsol::codegen_body_exit().

◆ scope_enter()

void casadi::CodeGenerator::scope_enter ( )

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

Definition at line 203 of file code_generator.cpp.

203  {
204  local_variables_.clear();
205  local_default_.clear();
206  }

References local_default_, and local_variables_.

Referenced by add_dependency(), casadi::FunctionInternal::codegen(), casadi::FatropInterface::codegen_declarations(), and casadi::IpoptInterface::codegen_declarations().

◆ scope_exit()

void casadi::CodeGenerator::scope_exit ( )

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

Definition at line 208 of file code_generator.cpp.

208  {
209  // Order local variables
210  std::map<std::string, std::set<std::pair<std::string, std::string>>> local_variables_by_type;
211  for (auto&& e : local_variables_) {
212  local_variables_by_type[e.second.first].insert(std::make_pair(e.first, e.second.second));
213  }
214 
215  // Codegen local variables
216  for (auto&& e : local_variables_by_type) {
217  casadi_int cnt = 0;
218  for (auto it=e.second.begin(); it!=e.second.end(); ++it) {
219  bool split_declaration = it==e.second.begin() ||
220  (max_declarations_per_line>1 && cnt % max_declarations_per_line==0);
221  if (split_declaration) {
222  if (it!=e.second.begin()) body << ";\n";
223  body << " " << e.first << " ";
224  } else {
225  body << ", ";
226  }
227  body << it->second << it->first;
228  // Insert definition, if any
229  auto k=local_default_.find(it->first);
230  if (k!=local_default_.end()) body << "=" << k->second;
231  cnt++;
232  }
233  body << ";\n";
234  }
235  }

References body, local_default_, local_variables_, and max_declarations_per_line.

Referenced by add_dependency(), casadi::FunctionInternal::codegen(), casadi::FatropInterface::codegen_declarations(), and casadi::IpoptInterface::codegen_declarations().

◆ setup_callback()

void casadi::CodeGenerator::setup_callback ( const std::string &  s,
const Function &  f 
)

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

Definition at line 1143 of file code_generator.cpp.

1143  {
1144  std::string name = add_dependency(f);
1145  bool needs_mem = !f->codegen_mem_type().empty();
1146  if (needs_mem) {
1147  *this << s << ".checkout = " << name << "_checkout;\n";
1148  } else {
1149  *this << s << ".checkout = 0;\n";
1150  }
1151 
1152  *this << s << ".eval = " << name << ";\n";
1153  if (needs_mem) {
1154  *this << s << ".release = " << name << "_release;\n";
1155  } else {
1156  *this << s << ".release = 0;\n";
1157  }
1158  }

References add_dependency(), casadi::FunctionInternal::codegen_mem_type(), and name.

Referenced by casadi::FatropInterface::set_fatrop_prob(), and casadi::MadnlpInterface::set_madnlp_prob().

◆ shorthand() [1/2]

std::string casadi::CodeGenerator::shorthand ( const std::string &  name) const

Definition at line 1186 of file code_generator.cpp.

1186  {
1187  casadi_assert(added_shorthands_.count(name), "No such macro: " + name);
1188  return "casadi_" + name;
1189  }

References added_shorthands_, and name.

Referenced by add_auxiliary(), add_dependency(), casadi::FunctionInternal::codegen_alloc_mem(), casadi::Nlpsol::codegen_body_enter(), casadi::FunctionInternal::codegen_checkout(), casadi::Nlpsol::codegen_declarations(), casadi::FatropInterface::codegen_declarations(), casadi::IpoptInterface::codegen_declarations(), casadi::FunctionInternal::codegen_mem(), casadi::FunctionInternal::codegen_release(), constant(), define_pool_double(), define_rom_double(), define_rom_integer(), mem(), ones(), sanitize_source(), casadi::FatropInterface::set_fatrop_prob(), casadi::IpoptInterface::set_ipopt_prob(), sparsity(), and zeros().

◆ shorthand() [2/2]

std::string casadi::CodeGenerator::shorthand ( const std::string &  name,
bool  allow_adding = true 
)

Definition at line 1191 of file code_generator.cpp.

1191  {
1192  bool added = added_shorthands_.insert(name).second;
1193  if (!allow_adding) {
1194  casadi_assert(added, "Duplicate macro: " + name);
1195  }
1196  return "casadi_" + name;
1197  }

References added_shorthands_, and name.

◆ sparsify()

std::string casadi::CodeGenerator::sparsify ( const std::string &  arg,
const std::string &  res,
const Sparsity &  sp_res,
bool  tr = false 
)

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

Definition at line 2134 of file code_generator.cpp.

2135  {
2136  // Create call
2137  add_auxiliary(AUX_SPARSIFY);
2138  std::stringstream s;
2139  s << "casadi_sparsify(" << arg << ", " << res << ", "
2140  << sparsity(sp_res) << ", " << (tr ? 1 : 0) << ");";
2141  return s.str();
2142  }

References add_auxiliary(), arg(), AUX_SPARSIFY, res(), and sparsity().

Referenced by casadi::Sparsify::generate().

◆ sparsity()

std::string casadi::CodeGenerator::sparsity ( const Sparsity &  sp,
bool  canonical = true 
)

Definition at line 1203 of file code_generator.cpp.

1203  {
1204  return shorthand("s" + str(add_sparsity(sp, canonical)));
1205  }
casadi::CodeGenerator::add_sparsity
casadi_int add_sparsity(const Sparsity &sp, bool canonical=true)
Definition: code_generator.cpp:1199

References add_sparsity(), shorthand(), and casadi::str().

Referenced by add_io_sparsities(), bilin(), casadi::FastNewton::codegen_body(), casadi::Feasiblesqpmethod::codegen_body(), casadi::Qrqp::codegen_body(), casadi::Sqpmethod::codegen_body(), densify(), from_mex(), casadi::Convexify::generate(), casadi::LinsolLdl::generate(), casadi::LinsolQr::generate(), casadi::Lsqr::generate(), casadi::Find::generate(), lb_eig(), mtimes(), mv(), print_canonical(), project(), casadi::Conic::qp_codegen_body(), rank1(), regularize(), casadi::FatropInterface::set_fatrop_prob(), casadi::HpipmInterface::set_hpipm_prob(), casadi::IpoptInterface::set_ipopt_prob(), casadi::MadnlpInterface::set_madnlp_prob(), sparsify(), to_mex(), trans(), tri_project(), trilsolve(), and triusolve().

◆ stream_close()

void casadi::CodeGenerator::stream_close ( std::ostream &  f,
bool  cpp 
)
static

Definition at line 408 of file code_generator.cpp.

408  {
409  // C linkage
410  if (!cpp) {
411  f << "#ifdef __cplusplus\n"
412  << "} /* extern \"C\" */\n"
413  << "#endif\n";
414  }
415  }

References cpp.

Referenced by generate(), and casadi::DaeBuilderInternal::generate_wrapper().

◆ stream_open()

void casadi::CodeGenerator::stream_open ( std::ostream &  f,
bool  cpp 
)
static

Definition at line 389 of file code_generator.cpp.

389  {
390 
391  // Print header
392  f << "/* This file was automatically generated by CasADi " << casadi_version() << ".\n"
393  << " * It consists of: \n"
394  << " * 1) content generated by CasADi runtime: not copyrighted\n"
395  << " * 2) template code copied from CasADi source: permissively licensed (MIT-0)\n"
396  << " * 3) user code: owned by the user\n"
397  << " *\n"
398  << " */\n";
399 
400  // C linkage
401  if (!cpp) {
402  f << "#ifdef __cplusplus\n"
403  << "extern \"C\" {\n"
404  << "#endif\n\n";
405  }
406  }
casadi::CodeGenerator::casadi_version
static std::string casadi_version()
Current CasADi version as string.
Definition: code_generator.cpp:382

References casadi_version(), and cpp.

Referenced by generate(), and casadi::DaeBuilderInternal::generate_wrapper().

◆ sum_viol()

std::string casadi::CodeGenerator::sum_viol ( casadi_int  n,
const std::string &  x,
const std::string &  lb,
const std::string &  ub 
)

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

Definition at line 2599 of file code_generator.cpp.

2600  {
2601  add_auxiliary(CodeGenerator::AUX_SUM_VIOL);
2602  return "casadi_sum_viol(" + str(n) + ", " + x+ ", " + lb + ", " + ub + ")";
2603  }

References add_auxiliary(), AUX_SUM_VIOL, and casadi::str().

Referenced by casadi::Sqpmethod::codegen_body().

◆ sx_work()

std::string casadi::CodeGenerator::sx_work ( casadi_int  i)

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

Definition at line 2337 of file code_generator.cpp.

2337  {
2338  if (avoid_stack_) {
2339  return "w[" + str(i) + "]";
2340  } else {
2341  std::string name = "a"+format_padded(i);
2342 
2343  // Make sure work vector element has been declared
2344  local(name, "casadi_real");
2345 
2346  return name;
2347  }
2348  }
casadi::CodeGenerator::format_padded
std::string format_padded(casadi_int i) const
Definition: code_generator.cpp:1018

References avoid_stack_, format_padded(), local(), name, and casadi::str().

Referenced by casadi::SXFunction::codegen_body(), casadi::SXFunction::print_arg(), and casadi::SXFunction::print_res().

◆ sz_work()

void casadi::CodeGenerator::sz_work ( size_t &  sz_arg,
size_t &  sz_res,
size_t &  sz_iw,
size_t &  sz_w 
) const

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

Definition at line 2670 of file code_generator.cpp.

2670  {
2671  sz_arg = sz_res = sz_iw = sz_w = 0;
2672  for (auto&& f : added_functions_) {
2673  sz_arg = std::max(sz_arg, f.f.sz_arg());
2674  sz_res = std::max(sz_res, f.f.sz_res());
2675  sz_iw = std::max(sz_iw, f.f.sz_iw());
2676  sz_w = std::max(sz_w, f.f.sz_w());
2677  }
2678  }

References added_functions_.

Referenced by casadi::DaeBuilderInternal::generate_wrapper().

◆ to_mex()

std::string casadi::CodeGenerator::to_mex ( const Sparsity &  sp,
const std::string &  arg 
)

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

Definition at line 1884 of file code_generator.cpp.

1884  {
1885  add_auxiliary(AUX_TO_MEX);
1886  std::stringstream s;
1887  s << "casadi_to_mex(" << sparsity(sp) << ", " << arg << ");";
1888  return s.str();
1889  }

References add_auxiliary(), arg(), AUX_TO_MEX, and sparsity().

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

◆ trans()

std::string casadi::CodeGenerator::trans ( const std::string &  x,
const Sparsity &  sp_x,
const std::string &  y,
const Sparsity &  sp_y,
const std::string &  iw 
)

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

Definition at line 2075 of file code_generator.cpp.

2077  {
2078  add_auxiliary(CodeGenerator::AUX_TRANS);
2079  return "casadi_trans(" + x + "," + sparsity(sp_x) + ", "
2080  + y + ", " + sparsity(sp_y) + ", " + iw + ")";
2081  }

References add_auxiliary(), AUX_TRANS, and sparsity().

Referenced by casadi::Transpose::generate().

◆ tri_project()

std::string casadi::CodeGenerator::tri_project ( const std::string &  arg,
const Sparsity &  sp_arg,
const std::string &  res,
bool  lower 
)

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

Definition at line 2112 of file code_generator.cpp.

2113  {
2114  // Create call
2115  add_auxiliary(AUX_TRI_PROJECT);
2116  std::stringstream s;
2117  s << "casadi_tri_project(" << arg << ", " << sparsity(sp_arg) << ", ";
2118  s << res << ", " << (lower ? 1: 0) << ");";
2119  return s.str();
2120  }

References add_auxiliary(), arg(), AUX_TRI_PROJECT, res(), and sparsity().

Referenced by casadi::OsqpInterface::codegen_body().

◆ trilsolve()

std::string casadi::CodeGenerator::trilsolve ( const Sparsity &  sp_x,
const std::string &  x,
const std::string &  y,
bool  tr,
bool  unity,
casadi_int  nrhs 
)

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

Definition at line 2249 of file code_generator.cpp.

2250  {
2251  add_auxiliary(AUX_TRILSOLVE);
2252  return "casadi_trilsolve(" + sparsity(sp_x) + ", " + x + ", " + y + ", " + str(tr) + ", "
2253  + str(unity) + ", " + str(nrhs) + ");";
2254  }

References add_auxiliary(), AUX_TRILSOLVE, sparsity(), and casadi::str().

Referenced by casadi::TrilSolve< Tr >::generate(), and casadi::TrilSolveUnity< Tr >::generate().

◆ triusolve()

std::string casadi::CodeGenerator::triusolve ( const Sparsity &  sp_x,
const std::string &  x,
const std::string &  y,
bool  tr,
bool  unity,
casadi_int  nrhs 
)

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

Definition at line 2256 of file code_generator.cpp.

2257  {
2258  add_auxiliary(AUX_TRIUSOLVE);
2259  return "casadi_triusolve(" + sparsity(sp_x) + ", " + x + ", " + y + ", " + str(tr) + ", "
2260  + str(unity) + ", " + str(nrhs) + ");";
2261  }

References add_auxiliary(), AUX_TRIUSOLVE, sparsity(), and casadi::str().

Referenced by casadi::TriuSolve< Tr >::generate(), and casadi::TriuSolveUnity< Tr >::generate().

◆ unindent()

void casadi::CodeGenerator::unindent ( )
inline

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

Definition at line 259 of file code_generator.hpp.

259 {current_indent_--;}

Referenced by print_formatted().

◆ vector_fmax()

std::string casadi::CodeGenerator::vector_fmax ( casadi_int  n,
const std::string &  x,
const std::string &  y,
const std::string &  z 
)

Definition at line 2203 of file code_generator.cpp.

2204  {
2205  add_auxiliary(AUX_VECTOR_FMAX);
2206  return "casadi_vector_fmax(" + str(n) + ", " + x + ", " + y + ", " + z + ");";
2207  }

References add_auxiliary(), AUX_VECTOR_FMAX, and casadi::str().

Referenced by casadi::Feasiblesqpmethod::codegen_feasibility_iterations().

◆ vector_fmin()

std::string casadi::CodeGenerator::vector_fmin ( casadi_int  n,
const std::string &  x,
const std::string &  y,
const std::string &  z 
)

Definition at line 2209 of file code_generator.cpp.

2210  {
2211  add_auxiliary(AUX_VECTOR_FMIN);
2212  return "casadi_vector_fmin(" + str(n) + ", " + x + ", " + y + ", " + z + ");";
2213  }

References add_auxiliary(), AUX_VECTOR_FMIN, and casadi::str().

Referenced by casadi::Feasiblesqpmethod::codegen_feasibility_iterations().

◆ vfmax() [1/2]

std::string casadi::CodeGenerator::vfmax ( const std::string &  x,
casadi_int  n,
const std::string &  y 
)

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

Definition at line 2545 of file code_generator.cpp.

2546  {
2547  add_auxiliary(CodeGenerator::AUX_VFMAX);
2548  return "casadi_vfmax(" + x + ", " + str(n) + ", " + y + ");";
2549  }

References add_auxiliary(), AUX_VFMAX, and casadi::str().

◆ vfmax() [2/2]

std::string casadi::CodeGenerator::vfmax ( const std::string &  x,
const std::string &  n,
const std::string &  y 
)

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

Definition at line 2557 of file code_generator.cpp.

2558  {
2559  add_auxiliary(CodeGenerator::AUX_VFMAX);
2560  return "casadi_vfmax(" + x + ", " + n + ", " + y + ");";
2561  }

References add_auxiliary(), and AUX_VFMAX.

◆ vfmin() [1/2]

std::string casadi::CodeGenerator::vfmin ( const std::string &  x,
casadi_int  n,
const std::string &  y 
)

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

Definition at line 2551 of file code_generator.cpp.

2552  {
2553  add_auxiliary(CodeGenerator::AUX_VFMIN);
2554  return "casadi_vfmin(" + x + ", " + str(n) + ", " + y + ");";
2555  }

References add_auxiliary(), AUX_VFMIN, and casadi::str().

◆ vfmin() [2/2]

std::string casadi::CodeGenerator::vfmin ( const std::string &  x,
const std::string &  n,
const std::string &  y 
)

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

Definition at line 2563 of file code_generator.cpp.

2564  {
2565  add_auxiliary(CodeGenerator::AUX_VFMIN);
2566  return "casadi_vfmin(" + x + ", " + n + ", " + y + ");";
2567  }

References add_auxiliary(), and AUX_VFMIN.

◆ work()

std::string casadi::CodeGenerator::work ( casadi_int  n,
casadi_int  sz,
bool  is_ref 
) const

Get work vector name from index

Definition at line 988 of file code_generator.cpp.

988  {
989  if (is_ref) {
990  return "wr" + format_padded(n);
991  }
992  if (n<0 || sz==0) {
993  return "0";
994  } else if (sz==1 && !this->codegen_scalars) {
995  return "(&w" + format_padded(n) + ")";
996  } else {
997  return "w" + format_padded(n);
998  }
999  }

References codegen_scalars, and format_padded().

Referenced by casadi::BSplineParametric::generate(), casadi::Bilin::generate(), casadi::BinaryMX< ScX, ScY >::generate(), casadi::BSplineCommon::generate(), casadi::Call::generate(), casadi::Find::generate(), casadi::Low::generate(), casadi::Concat::generate(), casadi::ConstantDM::generate(), casadi::ConstantFile::generate(), casadi::ConstantPool::generate(), casadi::Constant< Value >::generate(), casadi::Convexify::generate(), casadi::Dot::generate(), casadi::Einstein::generate(), casadi::GetNonzerosVector::generate(), casadi::GetNonzerosSlice::generate(), casadi::GetNonzerosSlice2::generate(), casadi::GetNonzerosParamVector::generate(), casadi::GetNonzerosSliceParam::generate(), casadi::GetNonzerosParamSlice::generate(), casadi::GetNonzerosParamParam::generate(), casadi::Input::generate(), casadi::Output::generate(), casadi::LogSumExp::generate(), casadi::MMin::generate(), casadi::MMax::generate(), casadi::Monitor::generate(), casadi::Multiplication::generate(), casadi::DenseMultiplication::generate(), casadi::NormF::generate(), casadi::Norm1::generate(), casadi::NormInf::generate(), casadi::Project::generate(), casadi::Densify::generate(), casadi::Sparsify::generate(), casadi::Rank1::generate(), casadi::HorzRepmat::generate(), casadi::HorzRepsum::generate(), casadi::SetNonzerosVector< Add >::generate(), casadi::SetNonzerosSlice< Add >::generate(), casadi::SetNonzerosSlice2< Add >::generate(), casadi::SetNonzerosParam< Add >::generate(), casadi::SetNonzerosParamVector< Add >::generate(), casadi::SetNonzerosParamSlice< Add >::generate(), casadi::SetNonzerosSliceParam< Add >::generate(), casadi::SetNonzerosParamParam< Add >::generate(), casadi::LinsolCall< Tr >::generate(), casadi::TriuSolve< Tr >::generate(), casadi::TrilSolve< Tr >::generate(), casadi::TriuSolveUnity< Tr >::generate(), casadi::TrilSolveUnity< Tr >::generate(), casadi::Split::generate(), casadi::Transpose::generate(), casadi::DenseTranspose::generate(), casadi::UnaryMX::generate(), casadi::MXNode::generate_copy(), casadi::MXFunction::print_arg(), and casadi::MXFunction::print_res().

◆ workel()

std::string casadi::CodeGenerator::workel ( casadi_int  n) const

Get work vector element from index

Definition at line 1001 of file code_generator.cpp.

1001  {
1002  if (n<0) return "0";
1003  std::stringstream s;
1004  if (this->codegen_scalars) s << "*";
1005  s << "w" << format_padded(n);
1006  return s.str();
1007  }

References codegen_scalars, and format_padded().

Referenced by casadi::Assertion::generate(), casadi::Bilin::generate(), casadi::BinaryMX< ScX, ScY >::generate(), casadi::Find::generate(), casadi::Concat::generate(), casadi::ConstantFile::generate(), casadi::ConstantPool::generate(), casadi::Constant< Value >::generate(), casadi::Dot::generate(), casadi::GetNonzerosSlice::generate(), casadi::GetNonzerosSliceParam::generate(), casadi::Input::generate(), casadi::Output::generate(), casadi::LogSumExp::generate(), casadi::MMin::generate(), casadi::MMax::generate(), casadi::NormF::generate(), casadi::Norm1::generate(), casadi::NormInf::generate(), casadi::Rank1::generate(), casadi::Split::generate(), casadi::UnaryMX::generate(), and casadi::MXNode::generate_copy().

◆ wrapper()

std::string casadi::CodeGenerator::wrapper ( const Function &  base,
const std::string &  name 
)

Definition at line 237 of file code_generator.cpp.

237  {
238  FunctionInternal* f = base.get();
239  std::map<FunctionInternal*, casadi_int>& funs = added_wrappers_[name];
240  auto it = funs.find(f);
241  if (it==funs.end()) {
242  casadi_int n = funs.size();
243  funs[f] = n;
244  return name + str(n);
245  } else {
246  return name + str(it->second);
247  }
248  }
casadi::CodeGenerator::added_wrappers_
std::map< std::string, std::map< FunctionInternal *, casadi_int > > added_wrappers_
Definition: code_generator.hpp:1036

References added_wrappers_, casadi::Function::get(), name, and casadi::str().

Referenced by casadi::Nlpsol::codegen_body_enter(), casadi::Nlpsol::codegen_declarations(), casadi::IpoptInterface::codegen_declarations(), and casadi::IpoptInterface::set_ipopt_prob().

◆ zeros()

std::string casadi::CodeGenerator::zeros ( casadi_int  sz)

Definition at line 1346 of file code_generator.cpp.

1346  {
1347  sz_zeros_ = std::max(sz_zeros_, sz);
1348  return shorthand("zeros");
1349  }

References shorthand(), and sz_zeros_.

Referenced by casadi::Input::generate().

Member Data Documentation

◆ added_auxiliaries_

std::multimap<Auxiliary, std::vector<std::string> > casadi::CodeGenerator::added_auxiliaries_

Definition at line 1014 of file code_generator.hpp.

Referenced by add_auxiliary().

◆ added_char_constants_

std::multimap<size_t, size_t> casadi::CodeGenerator::added_char_constants_

Definition at line 1017 of file code_generator.hpp.

Referenced by get_constant().

◆ added_double_constants_

std::multimap<size_t, size_t> casadi::CodeGenerator::added_double_constants_

Definition at line 1015 of file code_generator.hpp.

Referenced by get_constant().

◆ added_externals_

std::set<std::string> casadi::CodeGenerator::added_externals_

Definition at line 1012 of file code_generator.hpp.

Referenced by add_external(), and dump().

◆ added_functions_

std::vector<FunctionMeta> casadi::CodeGenerator::added_functions_

Definition at line 1033 of file code_generator.hpp.

Referenced by add_dependency(), casadi::FunctionInternal::codegen_name(), and sz_work().

◆ added_includes_

std::set<std::string> casadi::CodeGenerator::added_includes_

Definition at line 1011 of file code_generator.hpp.

Referenced by add_include().

◆ added_integer_constants_

std::multimap<size_t, size_t> casadi::CodeGenerator::added_integer_constants_

Definition at line 1016 of file code_generator.hpp.

Referenced by get_constant().

◆ added_sfunctions

std::vector<std::string> casadi::CodeGenerator::added_sfunctions

Definition at line 933 of file code_generator.hpp.

Referenced by add(), and generate().

◆ added_shorthands_

std::set<std::string> casadi::CodeGenerator::added_shorthands_

Definition at line 1013 of file code_generator.hpp.

Referenced by dump(), and shorthand().

◆ added_string_constants_

std::multimap<size_t, size_t> casadi::CodeGenerator::added_string_constants_

Definition at line 1018 of file code_generator.hpp.

Referenced by get_constant().

◆ added_wrappers_

std::map<std::string, std::map<FunctionInternal*, casadi_int> > casadi::CodeGenerator::added_wrappers_

Definition at line 1036 of file code_generator.hpp.

Referenced by wrapper().

◆ auxiliaries

std::stringstream casadi::CodeGenerator::auxiliaries

Definition at line 986 of file code_generator.hpp.

Referenced by add_auxiliary(), 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::FunctionInternal::codegen_checkout(), and dump().

◆ avoid_stack_

bool casadi::CodeGenerator::avoid_stack_

Definition at line 954 of file code_generator.hpp.

Referenced by CodeGenerator(), and sx_work().

◆ body

std::stringstream casadi::CodeGenerator::body

Definition at line 987 of file code_generator.hpp.

Referenced by add(), add_dependency(), casadi::FunctionInternal::codegen(), casadi::FatropInterface::codegen_declarations(), casadi::IpoptInterface::codegen_declarations(), casadi::FunctionInternal::codegen_meta(), dump(), and scope_exit().

◆ buffer

std::stringstream casadi::CodeGenerator::buffer

Definition at line 989 of file code_generator.hpp.

Referenced by flush(), operator<<(), and print_formatted().

◆ casadi_int_type

std::string casadi::CodeGenerator::casadi_int_type

Definition at line 920 of file code_generator.hpp.

Referenced by CodeGenerator().

◆ casadi_real_type

std::string casadi::CodeGenerator::casadi_real_type

Definition at line 917 of file code_generator.hpp.

Referenced by CodeGenerator().

◆ char_constants_

std::vector<std::vector<char> > casadi::CodeGenerator::char_constants_

Definition at line 1041 of file code_generator.hpp.

Referenced by dump(), and get_constant().

◆ codegen_scalars

bool casadi::CodeGenerator::codegen_scalars

Use the work vector for storing work vector elements of length 1 (typically scalar) instead of using local variables

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

Definition at line 964 of file code_generator.hpp.

Referenced by casadi::MXFunction::codegen_body(), CodeGenerator(), casadi::BinaryMX< ScX, ScY >::generate(), work(), and workel().

◆ cpp

bool casadi::CodeGenerator::cpp

Definition at line 945 of file code_generator.hpp.

Referenced by add_auxiliary(), CodeGenerator(), declare(), generate(), stream_close(), and stream_open().

◆ current_indent_

casadi_int casadi::CodeGenerator::current_indent_

Definition at line 996 of file code_generator.hpp.

Referenced by CodeGenerator(), dump(), and print_formatted().

◆ dll_export

std::string casadi::CodeGenerator::dll_export

Definition at line 979 of file code_generator.hpp.

Referenced by CodeGenerator().

◆ dll_import

std::string casadi::CodeGenerator::dll_import

Definition at line 979 of file code_generator.hpp.

Referenced by CodeGenerator(), and declare().

◆ double_constants_

std::vector<std::vector<double> > casadi::CodeGenerator::double_constants_

Definition at line 1039 of file code_generator.hpp.

Referenced by dump(), and get_constant().

◆ exposed_fname

std::vector<std::string> casadi::CodeGenerator::exposed_fname

Definition at line 1005 of file code_generator.hpp.

Referenced by add(), and generate().

◆ file_scope_double_

std::map<const void *, casadi_int> casadi::CodeGenerator::file_scope_double_

Definition at line 1021 of file code_generator.hpp.

Referenced by define_rom_double(), define_rom_integer(), dump(), rom_double(), and rom_integer().

◆ file_scope_integer_

std::map<const void *, casadi_int> casadi::CodeGenerator::file_scope_integer_

Definition at line 1022 of file code_generator.hpp.

Referenced by dump().

◆ force_canonical

bool casadi::CodeGenerator::force_canonical

Definition at line 976 of file code_generator.hpp.

Referenced by add_io_sparsities(), and CodeGenerator().

◆ header

std::stringstream casadi::CodeGenerator::header

Definition at line 988 of file code_generator.hpp.

Referenced by casadi::FunctionInternal::codegen_meta(), CodeGenerator(), declare(), and generate().

◆ include_math

bool casadi::CodeGenerator::include_math

Definition at line 951 of file code_generator.hpp.

Referenced by CodeGenerator().

◆ includes

std::stringstream casadi::CodeGenerator::includes

Definition at line 985 of file code_generator.hpp.

Referenced by add_include(), and dump().

◆ indent_

casadi_int casadi::CodeGenerator::indent_

Definition at line 995 of file code_generator.hpp.

Referenced by CodeGenerator(), and print_formatted().

◆ infinity

std::string casadi::CodeGenerator::infinity

Definition at line 956 of file code_generator.hpp.

Referenced by add_auxiliary(), and CodeGenerator().

◆ integer_constants_

std::vector<std::vector<casadi_int> > casadi::CodeGenerator::integer_constants_

Definition at line 1040 of file code_generator.hpp.

Referenced by dump(), and get_constant().

◆ local_default_

std::map<std::string, std::string> casadi::CodeGenerator::local_default_

Definition at line 1020 of file code_generator.hpp.

Referenced by init_local(), scope_enter(), and scope_exit().

◆ local_variables_

std::map<std::string, std::pair<std::string, std::string> > casadi::CodeGenerator::local_variables_

Definition at line 1019 of file code_generator.hpp.

Referenced by local(), scope_enter(), and scope_exit().

◆ main

bool casadi::CodeGenerator::main

Definition at line 948 of file code_generator.hpp.

Referenced by casadi::FunctionInternal::codegen_meta(), CodeGenerator(), and generate().

◆ max_declarations_per_line

casadi_int casadi::CodeGenerator::max_declarations_per_line

Definition at line 970 of file code_generator.hpp.

Referenced by CodeGenerator(), and scope_exit().

◆ max_initializer_elements_per_line

casadi_int casadi::CodeGenerator::max_initializer_elements_per_line

Definition at line 973 of file code_generator.hpp.

Referenced by CodeGenerator().

◆ mex

bool casadi::CodeGenerator::mex

Definition at line 929 of file code_generator.hpp.

Referenced by add_auxiliary(), casadi::FunctionInternal::codegen_meta(), CodeGenerator(), and generate().

◆ name

std::string casadi::CodeGenerator::name

Definition at line 914 of file code_generator.hpp.

Referenced by add_io_sparsities(), array(), CodeGenerator(), constant_copy(), define_pool_double(), generate(), init_local(), local(), mem(), operator()(), pool_double(), print_vector(), setup_callback(), shorthand(), sx_work(), and wrapper().

◆ nan

std::string casadi::CodeGenerator::nan

Definition at line 956 of file code_generator.hpp.

Referenced by add_auxiliary(), and CodeGenerator().

◆ needs_mem_

bool casadi::CodeGenerator::needs_mem_

Definition at line 1045 of file code_generator.hpp.

Referenced by add_dependency(), CodeGenerator(), and dump().

◆ newline_

bool casadi::CodeGenerator::newline_

Definition at line 992 of file code_generator.hpp.

Referenced by CodeGenerator(), operator<<(), and print_formatted().

◆ padding_length_

casadi_int casadi::CodeGenerator::padding_length_

Definition at line 1002 of file code_generator.hpp.

Referenced by format_padded(), and reserve_work().

◆ pool_double_

std::map<std::string, casadi_int> casadi::CodeGenerator::pool_double_

Definition at line 1024 of file code_generator.hpp.

Referenced by define_pool_double(), dump(), generate(), and pool_double().

◆ pool_double_defaults_

std::vector< std::vector<double> > casadi::CodeGenerator::pool_double_defaults_

Definition at line 1023 of file code_generator.hpp.

Referenced by define_pool_double(), dump(), and generate().

◆ prefix

std::string casadi::CodeGenerator::prefix

Definition at line 982 of file code_generator.hpp.

Referenced by CodeGenerator(), dump(), and generate().

◆ real_min

std::string casadi::CodeGenerator::real_min

Definition at line 956 of file code_generator.hpp.

Referenced by add_auxiliary(), and CodeGenerator().

◆ sparsity_meta

std::set<std::string> casadi::CodeGenerator::sparsity_meta

Definition at line 1008 of file code_generator.hpp.

Referenced by add_io_sparsities().

◆ string_constants_

std::vector<std::vector<std::string> > casadi::CodeGenerator::string_constants_

Definition at line 1042 of file code_generator.hpp.

Referenced by dump(), and get_constant().

◆ suffix

std::string casadi::CodeGenerator::suffix

Definition at line 914 of file code_generator.hpp.

Referenced by CodeGenerator(), generate(), and sanitize_source().

◆ sz_ones_

casadi_int casadi::CodeGenerator::sz_ones_

Definition at line 1000 of file code_generator.hpp.

Referenced by CodeGenerator(), dump(), and ones().

◆ sz_zeros_

casadi_int casadi::CodeGenerator::sz_zeros_

Definition at line 999 of file code_generator.hpp.

Referenced by CodeGenerator(), dump(), and zeros().

◆ unroll_args

bool casadi::CodeGenerator::unroll_args

Definition at line 936 of file code_generator.hpp.

Referenced by add(), and CodeGenerator().

◆ verbose

bool casadi::CodeGenerator::verbose

Definition at line 939 of file code_generator.hpp.

Referenced by casadi::MXFunction::codegen_body(), CodeGenerator(), and comment().

◆ verbose_runtime

bool casadi::CodeGenerator::verbose_runtime

Definition at line 942 of file code_generator.hpp.

Referenced by CodeGenerator(), and sanitize_source().

◆ with_export

bool casadi::CodeGenerator::with_export

Definition at line 967 of file code_generator.hpp.

Referenced by CodeGenerator(), and dump().

◆ with_header

bool casadi::CodeGenerator::with_header

Definition at line 926 of file code_generator.hpp.

Referenced by casadi::FunctionInternal::codegen_meta(), CodeGenerator(), declare(), and generate().

◆ with_import

bool casadi::CodeGenerator::with_import

Definition at line 967 of file code_generator.hpp.

Referenced by CodeGenerator(), and generate().

◆ with_mem

bool casadi::CodeGenerator::with_mem

Definition at line 923 of file code_generator.hpp.

Referenced by casadi::FunctionInternal::codegen_meta(), CodeGenerator(), and dump().

◆ with_sfunction

bool casadi::CodeGenerator::with_sfunction

Definition at line 932 of file code_generator.hpp.

Referenced by add(), CodeGenerator(), and generate().

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