casadi 3.5.6.pre2__cp39-none-win_amd64.whl → 3.6.0__cp39-none-win_amd64.whl

casadi/include/casadi/core/code_generator.hpp

@@ -2,8 +2,8 @@
  *    This file is part of CasADi.
  *
  *    CasADi -- A symbolic framework for dynamic optimization.
- *    Copyright (C) 2010-2014 Joel Andersson, Joris Gillis, Moritz Diehl,
- *                            K.U. Leuven. All rights reserved.
+ *    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,
+ *                            KU Leuven. All rights reserved.
  *    Copyright (C) 2011-2014 Greg Horn
  *
  *    CasADi is free software; you can redistribute it and/or
@@ -35,9 +35,11 @@
 namespace casadi {
 
   /** \brief Helper class for C code generation
+
       \author Joel Andersson
       \date 2016
-  */
+
+      \identifier{ru} */
   class CASADI_EXPORT CodeGenerator {
   public:
     /// Constructor
@@ -55,10 +57,12 @@ namespace casadi {
     std::string dump();
 
     /** \brief Generate file(s)
+
       The "prefix" argument will be prepended to the generated files and may
       be a directory or a file prefix.
       returns the filename
-    */
+
+        \identifier{rv} */
     std::string generate(const std::string& prefix="");
 
     /// Add an include file optionally using a relative path "..." instead of an absolute path <...>
@@ -84,48 +88,86 @@ namespace casadi {
     // Add a sparsity pattern, get index
     casadi_int add_sparsity(const Sparsity& sp);
 
-    /** \brief Get the index of an existing sparsity pattern */
+    /** \brief Get the index of an existing sparsity pattern
+
+        \identifier{rw} */
     casadi_int get_sparsity(const Sparsity& sp) const;
 
-    /** \brief Get or add a constant */
+    /** \brief Get or add a constant
+
+        \identifier{rx} */
     casadi_int get_constant(const std::vector<double>& v, bool allow_adding=false);
 
-    /** \brief Get or add an integer constant */
+    /** \brief Get or add an integer constant
+
+        \identifier{ry} */
     casadi_int get_constant(const std::vector<casadi_int>& v, bool allow_adding=false);
 
-    /** \brief Represent an array constant; adding it when new */
+    /** \brief Represent an array constant; adding it when new
+
+        \identifier{rz} */
     std::string constant(const std::vector<casadi_int>& v);
 
-    /** \brief Represent an array constant; adding it when new */
-    void constant_copy(const std::string& var_name, const std::vector<casadi_int>& v);
+    /** \brief Represent an array constant; adding it when new
 
-    /** \brief Represent an array constant; adding it when new */
+        \identifier{255} */
+    std::string constant(const std::vector<int>& v) {
+        return constant(vector_static_cast<casadi_int>(v));
+    }
+
+    /** \brief Represent an array constant; adding it when new
+
+        \identifier{s0} */
+    void constant_copy(
+        const std::string& var_name,
+        const std::vector<casadi_int>& v,
+        const std::string& type="casadi_int");
+
+    /** \brief Represent an array constant; adding it when new
+
+        \identifier{s1} */
     std::string constant(const std::vector<double>& v);
 
-    /** \brief Allocate file scope double read-only memory */
+    /** \brief Allocate file scope double read-only memory
+
+        \identifier{s2} */
     void define_rom_double(const void* id, casadi_int size);
 
-    /** \brief Access file scope double read-only memory */
+    /** \brief Access file scope double read-only memory
+
+        \identifier{s3} */
     std::string rom_double(const void* id) const;
 
-    /** \brief Allocate file scope integer read-only memory */
+    /** \brief Allocate file scope integer read-only memory
+
+        \identifier{s4} */
     void define_rom_integer(const void* id, casadi_int size);
 
-    /** \brief Access file scope integer read-only memory */
+    /** \brief Access file scope integer read-only memory
+
+        \identifier{s5} */
     std::string rom_integer(const void* id) const;
 
-    /** \brief Generate a call to a function (generic signature) */
+    /** \brief Generate a call to a function (generic signature)
+
+        \identifier{s6} */
     std::string operator()(const Function& f, const std::string& arg,
                            const std::string& res, const std::string& iw,
                            const std::string& w);
 
-    /** \brief Print a string to buffer  */
+    /** \brief Print a string to buffer
+
+        \identifier{s7} */
     CodeGenerator& operator<<(const std::string& s);
 
-    /** \brief Print without newline characters */
+    /** \brief Print without newline characters
+
+        \identifier{s8} */
     void print_formatted(const std::string& s);
 
-    /** \brief Print an arbitrary type to buffer */
+    /** \brief Print an arbitrary type to buffer
+
+        \identifier{s9} */
     template<typename T>
     CodeGenerator& operator<<(T s) {
       std::stringstream ss;
@@ -133,86 +175,184 @@ namespace casadi {
       return (*this) << ss.str();
     }
 
-    /** \brief Flush the buffer to a stream of choice */
+    /** \brief Flush the buffer to a stream of choice
+
+        \identifier{sa} */
     void flush(std::ostream &s);
 
-    /** \brief Declare a local variable */
+    /** \brief Declare a local variable
+
+        \identifier{sb} */
     void local(const std::string& name, const std::string& type, const std::string& ref="");
 
-    /** \brief Enter a local scope */
+    /** \brief Enter a local scope
+
+        \identifier{sc} */
     void scope_enter();
 
-    /** \brief Exit a local scope */
+    /** \brief Exit a local scope
+
+        \identifier{sd} */
     void scope_exit();
 
-    /** \brief Declare a work vector element */
+    /** \brief Declare a work vector element
+
+        \identifier{se} */
     std::string sx_work(casadi_int i);
 
-    /** \brief Specify the default value for a local variable */
+    /** \brief Specify the default value for a local variable
+
+        \identifier{sf} */
     void init_local(const std::string& name, const std::string& def);
 
-    /** \brief Increase indentation */
+    /** \brief Increase indentation
+
+        \identifier{sg} */
     void indent() {current_indent_++;}
 
-    /** \brief Decrease indentation */
+    /** \brief Decrease indentation
+
+        \identifier{sh} */
     void unindent() {current_indent_--;}
 
-    /** \brief Avoid stack? */
+    /** \brief Avoid stack?
+
+        \identifier{si} */
     bool avoid_stack() { return avoid_stack_;}
 
-    /** \brief Print a constant in a lossless but compact manner */
+    /** \brief Print a constant in a lossless but compact manner
+
+        \identifier{sj} */
     std::string constant(double v);
     std::string constant(casadi_int v);
+    std::string constant(const std::string& v);
 
-    /** \brief Print an intializer */
+    /** \brief Print an intializer
+
+        \identifier{sk} */
     std::string initializer(const std::vector<double>& v);
     std::string initializer(const std::vector<casadi_int>& v);
 
-    /** \brief Sanitize source files for codegen */
+    /** \brief Sanitize source files for codegen
+
+        \identifier{sl} */
     std::string sanitize_source(const std::string& src,
                                 const std::vector<std::string>& inst,
                                 bool add_shorthand=true);
 
-    /** \brief Codegen inner product */
+    /** \brief Codegen inner product
+
+        \identifier{sm} */
     std::string dot(casadi_int n, const std::string& x, const std::string& y);
 
-    /** \brief Codegen sparse matrix-vector multiplication */
+    /** \brief Codegen sparse matrix-vector multiplication
+
+        \identifier{sn} */
     std::string mv(const std::string& x, const Sparsity& sp_x,
                    const std::string& y, const std::string& z, bool tr);
 
-    /** \brief Codegen dense matrix-vector multiplication */
+    /** \brief Codegen dense matrix-vector multiplication
+
+        \identifier{so} */
     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);
 
-    /** \brief Codegen axpy: y += a*x */
+    /** \brief Codegen axpy: y += a*x
+
+        \identifier{sp} */
     std::string axpy(casadi_int n, const std::string& a,
                      const std::string& x, const std::string& y);
 
-    /** \brief Codegen axpy: x *= alpha */
+    /**
+     * @brief Codegen clip_min: Clips the smaller entries in a vector than min
+     * to the min
+     
+     */
+    std::string clip_min(const std::string& x, casadi_int n,
+                                  const std::string& min, const std::string& mask);
+
+    /**
+     * @brief Codegen clip_max: Clips the larger entries in a vector than max
+     * to the max
+     
+     */
+    std::string clip_max(const std::string& x, casadi_int n,
+                                    const std::string& min, const std::string& mask);
+
+    /**
+     * @brief Codegen vector_fmax: Takes vectorwise max of a vector and writes
+     * the result to second vector
+     */
+    std::string vector_fmax(casadi_int n, const std::string& x,
+                                    const std::string& y, const std::string& z);
+
+    /**
+     * @brief Codegen vector_fmin: Takes vectorwise min of a vector and writes
+     * the result to second vector
+     */
+    std::string vector_fmin(casadi_int n, const std::string& x,
+                                    const std::string& y, const std::string& z);
+
+    /**
+     * @brief codegen masked_norm_inf: The mask tells what entry is used in the
+     * inf-norm.
+     */
+    std::string masked_norm_inf(casadi_int n, const std::string& x,
+                                    const std::string& mask);
+
+
+    /** \brief What does scal do??
+
+        \identifier{sq} */
     std::string scal(casadi_int n, const std::string& alpha, const std::string& x);
 
-    /** \brief Codegen sparse matrix-matrix multiplication */
+    /** \brief Codegen sparse matrix-matrix multiplication
+
+        \identifier{sr} */
     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);
 
-    /** \brief Codegen bilinear form */
+    /** \brief Codegen lower triangular solve
+
+        \identifier{ss} */
+    std::string trilsolve(const Sparsity& sp_x, const std::string& x, const std::string& y,
+                          bool tr, bool unity, casadi_int nrhs);
+
+    /** \brief Codegen upper triangular solve
+
+        \identifier{st} */
+    std::string triusolve(const Sparsity& sp_x, const std::string& x, const std::string& y,
+                          bool tr, bool unity, casadi_int nrhs);
+
+    /** \brief Codegen bilinear form
+
+        \identifier{su} */
     std::string bilin(const std::string& A, const Sparsity& sp_A,
                       const std::string& x, const std::string& y);
 
-    /** \brief Rank-1 update */
+    /** \brief Rank-1 update
+
+        \identifier{sv} */
     std::string rank1(const std::string& A, const Sparsity& sp_A, const std::string& alpha,
                       const std::string& x, const std::string& y);
 
-    /** \brief Multilinear interpolation */
+    /** \brie LogSumExp */
+    std::string logsumexp(const std::string& A, casadi_int n);
+
+    /** \brief Multilinear interpolation
+
+        \identifier{sw} */
     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);
 
-    /** \brief Multilinear interpolation - calculate gradient */
+    /** \brief Multilinear interpolation - calculate gradient
+
+        \identifier{sx} */
     std::string interpn_grad(const std::string& grad,
       casadi_int ndim, const std::string& grid,
       const std::string& offset,
@@ -220,100 +360,167 @@ namespace casadi {
       const std::string& lookup_mode, casadi_int m,
       const std::string& iw, const std::string& w);
 
-    /** \brief Transpose */
+    /** \brief Transpose
+
+        \identifier{sy} */
     std::string trans(const std::string& x, const Sparsity& sp_x,
       const std::string& y, const Sparsity& sp_y, const std::string& iw);
 
-    /** \brief QR factorization */
+    /** \brief QR factorization
+
+        \identifier{sz} */
     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);
 
-    /** \brief QR solve */
+    /** \brief QR solve
+
+        \identifier{t0} */
     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);
 
-    /** \\brief LSQR solve */
+    /** \\brief LSQR solve
+
+         \identifier{t1} */
     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);
 
-    /** \brief LDL factorization */
+    /** \brief LDL factorization
+
+        \identifier{t2} */
     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);
 
-    /** \brief LDL solve */
+    /** \brief LDL solve
+
+        \identifier{t3} */
     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);
 
-    /** \brief fmax */
+    /** \brief fmax
+
+        \identifier{t4} */
     std::string fmax(const std::string& x, const std::string& y);
 
-    /** \brief fmin */
+    /** \brief fmin
+
+        \identifier{t5} */
     std::string fmin(const std::string& x, const std::string& y);
 
-    /** \brief vfmax */
+    /** \brief mmax
+
+        \identifier{t6} */
+    std::string mmax(const std::string& x, casadi_int n, bool is_dense);
+
+    /** \brief mmin
+
+        \identifier{t7} */
+    std::string mmin(const std::string& x, casadi_int n, bool is_dense);
+
+    /** \brief vfmax
+
+        \identifier{t8} */
     std::string vfmax(const std::string& x, casadi_int n, const std::string& y);
 
-    /** \brief vfmin */
+    /** \brief vfmin
+
+        \identifier{t9} */
     std::string vfmin(const std::string& x, casadi_int n, const std::string& y);
 
-    /** \brief vfmax */
+    /** \brief vfmax
+
+        \identifier{ta} */
     std::string vfmax(const std::string& x, const std::string& n, const std::string& y);
 
-    /** \brief vfmin */
+    /** \brief vfmin
+
+        \identifier{tb} */
     std::string vfmin(const std::string& x, const std::string& n, const std::string& y);
 
-    /** \brief max */
+    /** \brief max
+
+        \identifier{tc} */
     std::string max(const std::string& x, const std::string& y);
 
-    /** \brief min */
+    /** \brief min
+
+        \identifier{td} */
     std::string min(const std::string& x, const std::string& y);
 
-    /** \brief norm_inf */
+    /** \brief norm_inf
+
+        \identifier{te} */
     std::string norm_inf(casadi_int n, const std::string& x);
 
-    /** \brief max_viol */
+    /** 
+
+     * \brief norm_2
+
+                \identifier{256} */
+    std::string norm_2(casadi_int n, const std::string& x);
+
+    /** \brief max_viol
+
+        \identifier{tf} */
     std::string max_viol(casadi_int n, const std::string& x,
       const std::string& lb, const std::string& ub);
 
-    /** \brief sum_viol */
+    /** \brief sum_viol
+
+        \identifier{tg} */
     std::string sum_viol(casadi_int n, const std::string& x,
       const std::string& lb, const std::string& ub);
 
-    /** \brief bound_consistency */
+    /** \brief bound_consistency
+
+        \identifier{th} */
     std::string bound_consistency(casadi_int n, const std::string& x,
       const std::string& lam, const std::string& lbx, const std::string& ubx);
 
-    /** \brief lb_eig */
+    /** \brief lb_eig
+
+        \identifier{ti} */
     std::string lb_eig(const Sparsity& sp_h, const std::string& h);
 
-    /** \brief regularize */
+    /** \brief regularize
+
+        \identifier{tj} */
     std::string regularize(const Sparsity& sp_h, const std::string& h, const std::string& reg);
 
-    /** \brief convexify */
+    /** \brief convexify
+
+        \identifier{tk} */
     std::string convexify_eval(const ConvexifyData& d,
       const std::string& Hin, const std::string& Hout, const std::string& iw, const std::string& w);
 
-    /** \brief low */
+    /** \brief low
+
+        \identifier{tl} */
     std::string low(const std::string& x, const std::string& grid,
       casadi_int ng, casadi_int lookup_mode);
 
-    /** \brief Declare a function */
+    /** \brief Declare a function
+
+        \identifier{tm} */
     std::string declare(std::string s);
 
-    /** \brief Write a comment line (ignored if not verbose) */
+    /** \brief Write a comment line (ignored if not verbose)
+
+        \identifier{tn} */
     void comment(const std::string& s);
 
-    /** \brief Auxiliary functions */
+    /** \brief Auxiliary functions
+
+        \identifier{to} */
     enum Auxiliary {
       AUX_COPY,
       AUX_CVX,
@@ -326,13 +533,20 @@ namespace casadi {
       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,
@@ -351,8 +565,10 @@ namespace casadi {
       AUX_FINITE_DIFF,
       AUX_QR,
       AUX_QP,
+      AUX_QRQP,
       AUX_NLP,
       AUX_SQPMETHOD,
+      AUX_FEASIBLESQPMETHOD,
       AUX_LDL,
       AUX_NEWTON,
       AUX_TO_DOUBLE,
@@ -371,6 +587,7 @@ namespace casadi {
       AUX_VFMAX,
       AUX_MAX_VIOL,
       AUX_SUM_VIOL,
+      AUX_SUM,
       AUX_REGULARIZE,
       AUX_INF,
       AUX_NAN,
@@ -379,13 +596,24 @@ namespace casadi {
       AUX_BOUNDS_CONSISTENCY,
       AUX_LSQR,
       AUX_FILE_SLURP,
-      AUX_CACHE
+      AUX_CACHE,
+      AUX_LOG1P,
+      AUX_EXPM1,
+      AUX_HYPOT,
+      AUX_MMIN,
+      AUX_MMAX,
+      AUX_LOGSUMEXP,
+      AUX_SPARSITY
     };
 
-    /** \brief Add a built-in auxiliary function */
+    /** \brief Add a built-in auxiliary function
+
+        \identifier{tp} */
     void add_auxiliary(Auxiliary f, const std::vector<std::string>& inst = {"casadi_real"});
 
-    /** \brief Add io sparsity patterns of a function */
+    /** \brief Add io sparsity patterns of a function
+
+        \identifier{tq} */
     void add_io_sparsities(const std::string& name,
                            const std::vector<Sparsity>& sp_in,
                            const std::vector<Sparsity>& sp_out);
@@ -400,62 +628,97 @@ namespace casadi {
     static std::string array(const std::string& type, const std::string& name, casadi_int len,
                              const std::string& def=std::string());
 
-    /** \brief  Print casadi_int vector to a c file */
+    /** \brief  Print casadi_int vector to a c file
+
+        \identifier{tr} */
     void print_vector(std::ostream &s, const std::string& name,
                              const std::vector<casadi_int>& v);
 
-    /** \brief  Print real vector to a c file */
+    /** \brief  Print real vector to a c file
+
+        \identifier{ts} */
     void print_vector(std::ostream &s, const std::string& name,
                              const std::vector<double>& v);
 
-    /** \brief Create a copy operation */
+    /** \brief Create a copy operation
+
+        \identifier{tt} */
     std::string copy(const std::string& arg, std::size_t n, const std::string& res);
     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);
 
-    /** \brief Create a fill operation */
+    /** \brief Create a fill operation
+
+        \identifier{tu} */
     std::string fill(const std::string& res, std::size_t n, const std::string& v);
 
-    /** \brief Create a fill operation */
+    /** \brief Create a fill operation
+
+        \identifier{tv} */
     std::string clear(const std::string& res, std::size_t n);
 
-    /** \brief Refer to argument */
+    /** \brief Refer to argument
+
+        \identifier{tw} */
     std::string arg(casadi_int i) const;
 
-    /** \brief Refer to resuly */
+    /** \brief Refer to resuly
+
+        \identifier{tx} */
     std::string res(casadi_int i) const;
 
-    /** \brief Access thread-local memory */
+    /** \brief Access thread-local memory
+
+        \identifier{ty} */
     std::string mem(const Function& f);
 
-    /** \brief Sparse assignment */
+    /** \brief Sparse assignment
+
+        \identifier{tz} */
     std::string project(const std::string& arg, const Sparsity& sp_arg,
                         const std::string& res, const Sparsity& sp_res,
                         const std::string& w);
 
-    /** \brief Project triangular part */
+    /** \brief Project triangular part
+
+        \identifier{u0} */
     std::string tri_project(const std::string& arg, const Sparsity& sp_arg,
                         const std::string& res, bool lower);
 
-    /** \brief Densify */
+    /** \brief Densify
+
+        \identifier{u1} */
     std::string densify(const std::string& arg, const Sparsity& sp_arg,
                         const std::string& res, bool tr=false);
 
-    /** \brief Sparsify */
+    /** \brief Sparsify
+
+        \identifier{u2} */
     std::string sparsify(const std::string& arg, const std::string& res,
                          const Sparsity& sp_res, bool tr=false);
 
-    /** \brief Create matrix in MATLAB's MEX format */
+    /** \brief Create matrix in MATLAB's MEX format
+
+        \identifier{u3} */
     std::string to_mex(const Sparsity& sp, const std::string& arg);
 
-    /** \brief Get matrix from MATLAB's MEX format */
+    /** \brief Get matrix from MATLAB's MEX format
+
+        \identifier{u4} */
     std::string from_mex(std::string& arg,
                          const std::string& res, std::size_t res_off, const Sparsity& sp_res,
                          const std::string& w);
 
-    /** \brief Printf */
+    /** \brief FMU helper functions
+
+        \identifier{257} */
+    static std::string fmu_helpers(const std::string& modelname);
+
+    /** \brief Printf
+
+        \identifier{u5} */
     std::string printf(const std::string& str,
                        const std::vector<std::string>& arg=std::vector<std::string>());
     std::string printf(const std::string& str, const std::string& arg1);
@@ -463,24 +726,36 @@ namespace casadi {
     std::string printf(const std::string& str, const std::string& arg1, const std::string& arg2,
                        const std::string& arg3);
 
-    /** \brief Print an operation to a c file */
+    /** \brief Print an operation to a c file
+
+        \identifier{u6} */
     std::string print_op(casadi_int op, const std::string& a0);
     std::string print_op(casadi_int op, const std::string& a0, const std::string& a1);
 
-    /** \brief Slurp a file */
+    /** \brief Slurp a file
+
+        \identifier{u7} */
     std::string file_slurp(const std::string& fname, casadi_int n, const std::string& a);
 
-    /** \brief cache check */
+    /** \brief cache check
+
+        \identifier{u8} */
     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);
-  private:
 
     /// Print file header
-    void file_open(std::ofstream& f, const std::string& name) const;
+    static void file_open(std::ofstream& f, const std::string& name, bool cpp);
 
     /// Print file header
-    void file_close(std::ofstream& f) const;
+    static void file_close(std::ofstream& f, bool cpp);
+
+    /** \brief Get number of temporary variables needed for all functions
+
+        \identifier{258} */
+    void sz_work(size_t& sz_arg, size_t& sz_res, size_t& sz_iw, size_t& sz_w) const;
+
+  private:
 
     // Generate casadi_real definition
     void generate_casadi_real(std::ostream &s) const;
@@ -543,9 +818,11 @@ namespace casadi {
     std::string infinity, nan, real_min;
 
     /** \brief Codegen scalar
+
      * Use the work vector for storing work vector elements of length 1
      * (typically scalar) instead of using local variables
-     */
+
+        \identifier{u9} */
     bool codegen_scalars;
 
     // Have a flag for exporting/importing symbols
@@ -557,7 +834,7 @@ namespace casadi {
     // Prefix
     std::string prefix;
 
-    // Stringstreams holding the different parts of the file being generated
+    // std::stringstreams holding the different parts of the file being generated
     std::stringstream includes;
     std::stringstream auxiliaries;
     std::stringstream body;