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

casadi/include/casadi/core/function.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
@@ -41,6 +41,7 @@ namespace casadi {
 #endif // SWIG
 
   /** \brief Function object
+
       A Function instance is a general multiple-input, multiple-output function
       where each input and output can be a sparse matrix.\n
 
@@ -52,22 +53,31 @@ namespace casadi {
 
       \author Joel Andersson
       \date 2010-2017
-  */
+
+      \identifier{1uw} */
   class CASADI_EXPORT Function :
     public SharedObject,
     public SWIG_IF_ELSE(PrintableCommon, Printable<Function>) {
   public:
-    /** \brief Get type name */
+    /** \brief Get type name
+
+        \identifier{1ux} */
     static std::string type_name() {return "Function";}
 
-    /** \brief Default constructor, null pointer */
+    /** \brief Default constructor, null pointer
+
+        \identifier{1uy} */
     Function();
 
-    /** \brief Construct from a file */
+    /** \brief Construct from a file
+
+        \identifier{1uz} */
     Function(const std::string& fname);
 
     ///@{
-    /** \brief Construct an SX function */
+    /** \brief Construct an SX function
+
+        \identifier{1v0} */
     Function(const std::string& name,
              const std::vector<SX>& ex_in,
              const std::vector<SX>& ex_out,
@@ -85,7 +95,9 @@ namespace casadi {
     ///@}
 
     ///@{
-    /** \brief Construct an MX function */
+    /** \brief Construct an MX function
+
+        \identifier{1v1} */
     Function(const std::string& name,
              const std::vector<MX>& ex_in,
              const std::vector<MX>& ex_out,
@@ -103,7 +115,9 @@ namespace casadi {
     ///@}
 
     ///@{
-    /** \brief To resolve ambiguity on some compilers */
+    /** \brief To resolve ambiguity on some compilers
+
+        \identifier{1v2} */
 #ifndef SWIG
     Function(const std::string& name, SXIList ex_in,
       const SXVector& ex_out, const Dict& opts=Dict());
@@ -140,6 +154,7 @@ namespace casadi {
 
     ///@{
     /** \brief Create a just-in-time compiled function from a C language string
+
      * The names and sparsity patterns of all the inputs and outputs must be provided.
      * If sparsities are not provided, all inputs and outputs are assumed to be scalar.
      * Only specify the function body, assuming that input and output nonzeros are
@@ -166,7 +181,7 @@ namespace casadi {
      *   return 0;
      * }
      *
-     */
+        \identifier{1v3} */
     static Function jit(const std::string& name, const std::string& body,
              const std::vector<std::string>& name_in,
              const std::vector<std::string>& name_out,
@@ -179,10 +194,14 @@ namespace casadi {
              const Dict& opts=Dict());
     ///@}
 
-    /** \brief  Destructor */
+    /** \brief  Destructor
+
+        \identifier{1v4} */
     ~Function();
 
-    /** \brief Expand a function to SX */
+    /** \brief Expand a function to SX
+
+        \identifier{1v5} */
     ///@{
     Function expand() const;
     Function expand(const std::string& name,
@@ -191,22 +210,32 @@ namespace casadi {
 
     /// \cond INTERNAL
 #ifndef SWIG
-    /** \brief  Create from node */
+    /** \brief  Create from node
+
+        \identifier{1v6} */
     static Function create(FunctionInternal* node);
 
-    /** \brief  Create from node and initialize */
+    /** \brief  Create from node and initialize
+
+        \identifier{1v7} */
     static Function create(FunctionInternal* node, const Dict& opts);
 #endif // SWIG
     /// \endcond
 
-    /** \brief Get the number of function inputs */
+    /** \brief Get the number of function inputs
+
+        \identifier{1v8} */
     casadi_int n_in() const;
 
-    /** \brief Get the number of function outputs */
+    /** \brief Get the number of function outputs
+
+        \identifier{1v9} */
     casadi_int n_out() const;
 
     ///@{
-    /** \brief Get input dimension */
+    /** \brief Get input dimension
+
+        \identifier{1va} */
     casadi_int size1_in(casadi_int ind) const;
     casadi_int size1_in(const std::string& iname) const {return size1_in(index_in(iname));}
     casadi_int size2_in(casadi_int ind) const;
@@ -218,7 +247,9 @@ namespace casadi {
     ///@}
 
     ///@{
-    /** \brief Get output dimension */
+    /** \brief Get output dimension
+
+        \identifier{1vb} */
     casadi_int size1_out(casadi_int ind) const;
     casadi_int size1_out(const std::string& oname) const {return size1_out(index_out(oname));}
     casadi_int size2_out(casadi_int ind) const;
@@ -233,27 +264,30 @@ namespace casadi {
     /** \brief  Get number of input nonzeros
      *
      * For a particular input or for all of the inputs
-     */
+
+        \identifier{1vc} */
     casadi_int nnz_in() const;
     casadi_int nnz_in(casadi_int ind) const;
-    casadi_int nnz_in(const std::string& iname) const {return numel_in(index_in(iname));}
+    casadi_int nnz_in(const std::string& iname) const {return nnz_in(index_in(iname));}
     ///@}
 
     ///@{
     /** \brief  Get number of output nonzeros
      *
      * For a particular output or for all of the outputs
-     */
+
+        \identifier{1vd} */
     casadi_int nnz_out() const;
     casadi_int nnz_out(casadi_int ind) const;
-    casadi_int nnz_out(const std::string& oname) const {return numel_out(index_out(oname));}
+    casadi_int nnz_out(const std::string& oname) const {return nnz_out(index_out(oname));}
     ///@}
 
     ///@{
     /** \brief  Get number of input elements
      *
      * For a particular input or for all of the inputs
-     */
+
+        \identifier{1ve} */
     casadi_int numel_in() const;
     casadi_int numel_in(casadi_int ind) const;
     casadi_int numel_in(const std::string& iname) const {return numel_in(index_in(iname));}
@@ -263,60 +297,93 @@ namespace casadi {
     /** \brief  Get number of output elements
      *
      * For a particular output or for all of the outputs
-     */
+
+        \identifier{1vf} */
     casadi_int numel_out() const;
     casadi_int numel_out(casadi_int ind) const;
     casadi_int numel_out(const std::string& oname) const {return numel_out(index_out(oname));}
     ///@}
 
-    /** \brief Get input scheme */
+    /** \brief Get input scheme
+
+        \identifier{1vg} */
     const std::vector<std::string>& name_in() const;
 
-    /** \brief Get output scheme */
+    /** \brief Get output scheme
+
+        \identifier{1vh} */
     const std::vector<std::string>& name_out() const;
 
-    /** \brief Get input scheme name by index */
+    /** \brief Get input scheme name by index
+
+        \identifier{1vi} */
     const std::string& name_in(casadi_int ind) const;
 
-    /** \brief Get output scheme name by index */
+    /** \brief Get output scheme name by index
+
+        \identifier{1vj} */
     const std::string& name_out(casadi_int ind) const;
 
     /** \brief Find the index for a string describing a particular entry of an input scheme
      *
      * example:  schemeEntry("x_opt")  -> returns  NLPSOL_X if FunctionInternal adheres to
      * SCHEME_NLPINput
-     */
+
+        \identifier{1vk} */
     casadi_int index_in(const std::string &name) const;
 
     /** \brief Find the index for a string describing a particular entry of an output scheme
      *
      * example:  schemeEntry("x_opt")  -> returns  NLPSOL_X if FunctionInternal adheres to
      * SCHEME_NLPINput
-     */
+
+        \identifier{1vl} */
     casadi_int index_out(const std::string &name) const;
 
-    /** \brief Get default input value */
+    /** \brief Get default input value
+
+        \identifier{1vm} */
     double default_in(casadi_int ind) const;
 
-    /** \brief Get largest input value */
+    /** \brief Get largest input value
+
+        \identifier{1vn} */
     double max_in(casadi_int ind) const;
 
-    /** \brief Get smallest input value */
+    /** \brief Get smallest input value
+
+        \identifier{1vo} */
     double min_in(casadi_int ind) const;
 
-    /** \brief Get sparsity of a given input */
+    /** \brief Get nominal input value
+
+        \identifier{1vp} */
+    std::vector<double> nominal_in(casadi_int ind) const;
+
+    /** \brief Get nominal output value
+
+        \identifier{1vq} */
+    std::vector<double> nominal_out(casadi_int ind) const;
+
+    /** \brief Get sparsity of a given input
+
+        \identifier{1vr} */
     /// @{
     const Sparsity& sparsity_in(casadi_int ind) const;
     const Sparsity& sparsity_in(const std::string& iname) const;
     /// @}
 
-    /** \brief Get sparsity of a given output */
+    /** \brief Get sparsity of a given output
+
+        \identifier{1vs} */
     /// @{
     const Sparsity& sparsity_out(casadi_int ind) const;
     const Sparsity& sparsity_out(const std::string& iname) const;
     /// @}
 
-    /** \brief Get differentiability of inputs/output */
+    /** \brief Get differentiability of inputs/output
+
+        \identifier{1vt} */
     /// @{
     bool is_diff_in(casadi_int ind) const;
     bool is_diff_out(casadi_int ind) const;
@@ -334,75 +401,116 @@ namespace casadi {
                      const AuxOut& aux=AuxOut(),
                      const Dict& opts=Dict()) const;
 
-    /** \brief Get oracle */
+    /** \brief Get oracle
+
+        \identifier{1vu} */
     Function oracle() const;
 
-    /** \brief Wrap in an Function instance consisting of only one MX call */
+    /** \brief Wrap in an Function instance consisting of only one MX call
+
+        \identifier{1vv} */
     Function wrap() const;
 
-    /** \brief Wrap in a Function with options */
+    /** \brief Wrap in a Function with options
+
+        \identifier{1vw} */
     Function wrap_as_needed(const Dict& opts) const;
 
     /** \brief Which variables enter with some order
     *
     * \param[in] order Only 1 (linear) and 2 (nonlinear) allowed
     * \param[in] tr   Flip the relationship. Return which expressions contain the variables
-    */
+
+        \identifier{1vx} */
     std::vector<bool> which_depends(const std::string& s_in,
                                     const std::vector<std::string>& s_out,
                                     casadi_int order=1, bool tr=false) const;
 
-    /** \brief Print dimensions of inputs and outputs */
+    /** \brief Print dimensions of inputs and outputs
+
+        \identifier{1vy} */
     void print_dimensions(std::ostream &stream=casadi::uout()) const;
 
-    /** \brief Print options to a stream */
+    /** \brief Print options to a stream
+
+        \identifier{1vz} */
     void print_options(std::ostream &stream=casadi::uout()) const;
 
-    /** \brief Print all information there is to know about a certain option */
+    /** \brief Print all information there is to know about a certain option
+
+        \identifier{1w0} */
     void print_option(const std::string &name, std::ostream &stream = casadi::uout()) const;
 
-    /** \brief Do the derivative functions need nondifferentiated outputs? */
+    /** \brief Does a particular option exist
+
+        \identifier{1w1} */
+    bool has_option(const std::string &option_name) const;
+
+    /** \brief Change option after object creation for debugging
+
+      * This is only possible for a selected number of options that do not change the numerical
+      * results of the computation, e.g. to enable a more verbose output or saving to file.
+
+        \identifier{1w2} */
+    void change_option(const std::string& option_name, const GenericType& option_value);
+
+    /** \brief Do the derivative functions need nondifferentiated outputs?
+
+        \identifier{1w3} */
     bool uses_output() const;
 
-    ///@{
-    /** \brief Generate a Jacobian function of output \a oind with respect to input \a iind
-     * \param iind The index of the input
-     * \param oind The index of the output
-     * Legacy function: To be deprecated in a future version of CasADi.
-     * Exists only for compatibility with Function::jacobian pre-CasADi 3.2
-     */
+#ifdef WITH_DEPRECATED_FEATURES
+    /** \brief [DEPRECATED] Replaced by Function::factory.
+
+        \identifier{1w4} */
     Function jacobian_old(casadi_int iind, casadi_int oind) const;
 
-    /** \brief Generate a Hessian function of output \a oind with respect to input \a iind
-     * \param iind The index of the input
-     * \param oind The index of the output
-     * Legacy function: To be deprecated in a future version of CasADi.
-     * Exists only for compatibility with Function::hessian pre-CasADi 3.2
-     */
+    /** \brief [DEPRECATED] Replaced by Function::factory.
+
+        \identifier{1w5} */
     Function hessian_old(casadi_int iind, casadi_int oind) const;
 
-    /** \brief Generate a Jacobian function of all the inputs elements with respect to all
-     * the output elements).
-     */
-    Function jacobian() const;
+    ///@{
+    /// [DEPRECATED] Get, if necessary generate, the sparsity of a Jacobian block
+    const Sparsity sparsity_jac(casadi_int iind, casadi_int oind,
+                                bool compact=false, bool symmetric=false) const;
+    const Sparsity sparsity_jac(const std::string &iind, casadi_int oind=0,
+                                bool compact=false, bool symmetric=false) const {
+      return sparsity_jac(index_in(iind), oind, compact, symmetric);
+    }
+    const Sparsity sparsity_jac(casadi_int iind, const std::string &oind,
+                                bool compact=false, bool symmetric=false) const {
+      return sparsity_jac(iind, index_out(oind), compact, symmetric);
+    }
+    const Sparsity sparsity_jac(const std::string &iind, const std::string &oind,
+                                bool compact=false, bool symmetric=false) const {
+      return sparsity_jac(index_in(iind), index_out(oind), compact, symmetric);
+    }
+    ///@}
+#endif // WITH_DEPRECATED_FEATURES
+
+  /** \brief Calculate all Jacobian blocks
+
+    * Generates a function that takes all non-differentiated inputs and outputs
+    * and calculates all Jacobian blocks.
+    * Inputs that are not needed by the routine are all-zero sparse matrices
+    * with the correct dimensions. Output blocks that are not calculated,
+    * e.g. if the corresponding input or output is marked non-differentiated
+    * are also all-zero sparse.
+    * The Jacobian blocks are sorted starting by all the blocks for the first
+    * output, then all the blocks for the second output and so on.
+    * E.g. f : (x, y) -> (r, s) results in the function
+    * jac_f : (x, y, out_r, out_s) -> (jac_r_x, jac_r_y, jac_s_x, jac_s_y)
+    *
+    * This function is cached.
 
-    /** \brief Calculate all Jacobian blocks
-      * Generates a function that takes all non-differentiated inputs and outputs
-      * and calculates all Jacobian blocks.
-      * Inputs that are not needed by the routine are all-zero sparse matrices
-      * with the correct dimensions. Output blocks that are not calculated,
-      * e.g. if the corresponding input or output is marked non-differentiated
-      * are also all-zero sparse.
-      * The Jacobian blocks are sorted starting by all the blocks for the first
-      * output, then all the blocks for the second output and so on.
-      * E.g. f:(x,y)->(r,s) results in the function
-      * jac_f:(x,y,r,s)->(dr_dx, dr_dy, ds_dx, ds_dy)
-      * This function is cached.
-      */
-    Function jac() const;
+      \identifier{1w6} */
+    Function jacobian() const;
 
     ///@{
-    /** \brief Evaluate the function symbolically or numerically  */
+    /** \brief Evaluate the function symbolically or numerically
+
+        \identifier{1w7} */
     void call(const std::vector<DM> &arg, std::vector<DM>& SWIG_OUTPUT(res),
               bool always_inline=false, bool never_inline=false) const;
     void call(const std::vector<SX> &arg, std::vector<SX>& SWIG_OUTPUT(res),
@@ -432,7 +540,9 @@ namespace casadi {
     ///@}
 
     ///@{
-    /** \brief Evaluate with temporary memory allocation */
+    /** \brief Evaluate with temporary memory allocation
+
+        \identifier{1w8} */
     void operator()(std::vector<const double*> arg, std::vector<double*> res) const;
     void operator()(std::vector<const bvec_t*> arg, std::vector<bvec_t*> res) const;
     void operator()(std::vector<const SXElem*> arg, std::vector<SXElem*> res) const;
@@ -440,7 +550,9 @@ namespace casadi {
     ///@}
 
     ///@{
-    /** \brief Supported arguments for numerical evaluation and converters */
+    /** \brief Supported arguments for numerical evaluation and converters
+
+        \identifier{1w9} */
     typedef const std::vector<std::vector<double>>& VecArg;
     std::vector<const double*> buf_in(VecArg arg) const;
     typedef std::vector<std::vector<double>>& VecRes;
@@ -457,7 +569,9 @@ namespace casadi {
     ///@}
 
     ///@{
-    /** \brief Numerical evaluation */
+    /** \brief Numerical evaluation
+
+        \identifier{1wa} */
     void operator()(VecArg arg, VecRes res) const { (*this)(buf_in(arg), buf_out(res)); }
     void operator()(VecArg arg, MapRes res) const { (*this)(buf_in(arg), buf_out(res)); }
     void operator()(VecArg arg, VPrRes res) const { (*this)(buf_in(arg), buf_out(res)); }
@@ -482,35 +596,49 @@ namespace casadi {
     }
     ///@}
 
-    /** \brief Evaluate memory-less, numerically */
+    /** \brief Evaluate memory-less, numerically
+
+        \identifier{1wb} */
     int operator()(const double** arg, double** res,
         casadi_int* iw, double* w, int mem) const;
 
-    /** \brief Evaluate numerically with checkout/release */
+    /** \brief Evaluate numerically with checkout/release
+
+        \identifier{1wc} */
     int operator()(const double** arg, double** res,
         casadi_int* iw, double* w) const;
 
     /** \brief Evaluate memory-less SXElem
+
         Same syntax as the double version, allowing use in templated code
-     */
+
+        \identifier{1wd} */
     int operator()(const SXElem** arg, SXElem** res,
         casadi_int* iw, SXElem* w, int mem=0) const;
 
-    /** \brief  Propagate sparsity forward */
+    /** \brief  Propagate sparsity forward
+
+        \identifier{1we} */
     int operator()(const bvec_t** arg, bvec_t** res,
         casadi_int* iw, bvec_t* w, int mem=0) const;
 
-    /** \brief  Propagate sparsity backward */
+    /** \brief  Propagate sparsity backward
+
+        \identifier{1wf} */
     int rev(bvec_t** arg, bvec_t** res, casadi_int* iw, bvec_t* w, int mem=0) const;
 
-    /** \brief Propagate sparsity backward with temporary memory allocation */
+    /** \brief Propagate sparsity backward with temporary memory allocation
+
+        \identifier{1wg} */
     int rev(std::vector<bvec_t*> arg, std::vector<bvec_t*> res) const;
 
 #endif // SWIG
 
     /** \brief  Evaluate symbolically in parallel and sum (matrix graph)
+
         \param parallelization Type of parallelization used: unroll|serial|openmp
-    */
+
+        \identifier{1wh} */
     std::vector<MX> mapsum(const std::vector<MX > &x,
                            const std::string& parallelization="serial") const;
 
@@ -554,7 +682,7 @@ namespace casadi {
 
         Set base to -1 to unroll all the way; no gains in memory efficiency here.
 
-    */
+        \identifier{1wi} */
     Function mapaccum(const std::string& name, casadi_int N, const Dict& opts = Dict()) const;
     Function mapaccum(const std::string& name, casadi_int N, casadi_int n_accum,
                       const Dict& opts = Dict()) const;
@@ -593,16 +721,19 @@ namespace casadi {
         \endverbatim
 
         \param parallelization Type of parallelization used: unroll|serial|openmp
-    */
+
+        \identifier{1wj} */
     Function map(casadi_int n, const std::string& parallelization="serial") const;
     Function map(casadi_int n, const std::string& parallelization,
       casadi_int max_num_threads) const;
 
     ///@{
     /** \brief Map with reduction
+
       A subset of the inputs are non-repeated and a subset of the outputs summed
       up.
-    */
+
+        \identifier{1wk} */
     Function map(const std::string& name, const std::string& parallelization, casadi_int n,
       const std::vector<casadi_int>& reduce_in,
       const std::vector<casadi_int>& reduce_out,
@@ -617,23 +748,36 @@ namespace casadi {
       const Dict& opts=Dict()) const;
     ///@}
 
-    /** \brief returns a new function with a selection of inputs/outputs of the original */
+    /** \brief returns a new function with a selection of inputs/outputs of the original
+
+        \identifier{1wl} */
     Function slice(const std::string& name, const std::vector<casadi_int>& order_in,
                    const std::vector<casadi_int>& order_out, const Dict& opts=Dict()) const;
 
-    /** \brief Constuct a switch function */
+    /** \brief Constuct a switch function
+
+        \identifier{1wm} */
     static Function conditional(const std::string& name, const std::vector<Function>& f,
                                 const Function& f_def, const Dict& opts=Dict());
 
+    /** \brief Conditional call to a function
+
+        \identifier{1wn} */
+    static Function conditional(const std::string& name,
+      const Function& f, const Dict& opts=Dict());
+
     /** \brief BSpline evaluator function
      *
      *  Requires a known coefficient tensor
-     */
+
+        \identifier{1wo} */
     static Function bspline(const std::string &name,
       const std::vector< std::vector<double> >& knots, const std::vector<double>& coeffs,
       const std::vector<casadi_int>& degree, casadi_int m=1, const Dict& opts=Dict());
 
-    /** \brief Constructor (if-else) */
+    /** \brief Constructor (if-else)
+
+        \identifier{1wp} */
     static Function if_else(const std::string& name, const Function& f_true,
                             const Function& f_false, const Dict& opts=Dict());
 
@@ -651,7 +795,8 @@ namespace casadi {
      *
      *        The functions returned are cached, meaning that if called multiple timed
      *        with the same value, then multiple references to the same function will be returned.
-     */
+
+        \identifier{1wq} */
     Function forward(casadi_int nfwd) const;
 
     /** \brief Get a function that calculates \a nadj adjoint derivatives
@@ -670,51 +815,52 @@ namespace casadi {
      *
      *        The functions returned are cached, meaning that if called multiple timed
      *        with the same value, then multiple references to the same function will be returned.
-     */
+
+        \identifier{1wr} */
     Function reverse(casadi_int nadj) const;
 
-    ///@{
-    /// Get, if necessary generate, the sparsity of a Jacobian block
-    const Sparsity sparsity_jac(casadi_int iind, casadi_int oind,
-                                bool compact=false, bool symmetric=false) const;
-    const Sparsity sparsity_jac(const std::string &iind, casadi_int oind=0,
-                                bool compact=false, bool symmetric=false) const {
-      return sparsity_jac(index_in(iind), oind, compact, symmetric);
-    }
-    const Sparsity sparsity_jac(casadi_int iind, const std::string &oind,
-                                bool compact=false, bool symmetric=false) const {
-      return sparsity_jac(iind, index_out(oind), compact, symmetric);
-    }
-    const Sparsity sparsity_jac(const std::string &iind, const std::string &oind,
-                                bool compact=false, bool symmetric=false) const {
-      return sparsity_jac(index_in(iind), index_out(oind), compact, symmetric);
-    }
-    ///@}
+    /** \brief Get, if necessary generate, the sparsity of all Jacobian blocks
 
-    /** \brief Export / Generate C code for the function */
+        \identifier{1ws} */
+    const std::vector<Sparsity>& jac_sparsity(bool compact = false) const;
+
+    /** \brief Get, if necessary generate, the sparsity of a single Jacobian block
+
+        \identifier{1wt} */
+    Sparsity jac_sparsity(casadi_int oind, casadi_int iind, bool compact = false) const;
+
+    /** \brief Export / Generate C code for the function
+
+        \identifier{1wu} */
     std::string generate(const std::string& fname, const Dict& opts=Dict()) const;
 
-    /** \brief Export / Generate C code for the function */
+    /** \brief Export / Generate C code for the function
+
+        \identifier{1wv} */
     std::string generate(const Dict& opts=Dict()) const;
 
-    /** \brief Export / Generate C code for the dependency function */
+    /** \brief Export / Generate C code for the dependency function
+
+        \identifier{1ww} */
     std::string generate_dependencies(const std::string& fname, const Dict& opts=Dict()) const;
 
     /** \brief Export an input file that can be passed to generate C code with a main
-     * 
-     * \seealso generate_out
-     * \seealso convert_in to convert between dict/map and vector
-     */
+     *
+     * \see generate_out
+     * \see convert_in to convert between dict/map and vector
+
+        \identifier{1wx} */
     /// @{
     void generate_in(const std::string& fname, const std::vector<DM>& arg);
     std::vector<DM> generate_in(const std::string& fname);
     /// @}
 
     /** \brief Export an output file that can be checked with generated C code output
-     * 
-     * \seealso generate_in
-     * \seealso convert_out to convert between dict/map and vector
-     */
+     *
+     * \see generate_in
+     * \see convert_out to convert between dict/map and vector
+
+        \identifier{1wy} */
     /// @{
     void generate_out(const std::string& fname, const std::vector<DM>& arg);
     std::vector<DM> generate_out(const std::string& fname);
@@ -723,21 +869,34 @@ namespace casadi {
     /** \brief Export function in specific language
      *
      * Only allowed for (a subset of) SX/MX Functions
-     */
+
+        \identifier{1wz} */
     ///@{
     void export_code(const std::string& lang,
       const std::string &fname, const Dict& options=Dict()) const;
 
 #ifndef SWIG
-    /** \brief Serialize */
+    /** \brief Serialize
+
+        \identifier{1x0} */
     void serialize(std::ostream &stream, const Dict& opts=Dict()) const;
 
-    /** \brief Serialize an object */
+    /** \brief Serialize an object
+
+        \identifier{1x1} */
     void serialize(SerializingStream &s) const;
 #endif
 
-    /** \brief Serialize */
+    /** \brief Serialize
+
+        \identifier{1x2} */
     std::string serialize(const Dict& opts=Dict()) const;
+
+    /** \brief Save Function to a file
+
+        \see load
+
+        \identifier{240} */
     void save(const std::string &fname, const Dict& opts=Dict()) const;
 
     std::string export_code(const std::string& lang, const Dict& options=Dict()) const;
@@ -759,7 +918,9 @@ namespace casadi {
       return ret;
     }
 
-    /** \brief  Const access functions of the node */
+    /** \brief  Const access functions of the node
+
+        \identifier{1x3} */
     FunctionInternal* operator->() const;
 
     /// Check if a particular cast is allowed
@@ -772,8 +933,10 @@ namespace casadi {
 
     ///@{
     /** \brief Get symbolic primitives equivalent to the input expressions
+
      * There is no guarantee that subsequent calls return unique answers
-     */
+
+        \identifier{1x4} */
     const SX sx_in(casadi_int iind) const;
     const SX sx_in(const std::string& iname) const {
       return sx_in(index_in(iname));
@@ -788,8 +951,10 @@ namespace casadi {
 
     ///@{
     /** \brief Get symbolic primitives equivalent to the output expressions
+
     * There is no guarantee that subsequent calls return unique answers
-    */
+
+        \identifier{1x5} */
     const SX sx_out(casadi_int oind) const;
     const SX sx_out(const std::string& oname) const {
       return sx_out(index_out(oname));
@@ -802,7 +967,9 @@ namespace casadi {
     const std::vector<MX> mx_out() const;
     ///@}
 
-    /** \brief Convert from/to flat vector of input/output nonzeros */
+    /** \brief Convert from/to flat vector of input/output nonzeros
+
+        \identifier{1x6} */
     /// @{
     std::vector<double> nz_from_in(const std::vector<DM>& arg) const;
     std::vector<double> nz_from_out(const std::vector<DM>& arg) const;
@@ -810,11 +977,12 @@ namespace casadi {
     std::vector<DM> nz_to_out(const std::vector<double>& arg) const;
     ///@}
 
-    /** \brief Convert from/to input/output lists/map 
+    /** \brief Convert from/to input/output lists/map
     *
     * Will raise an error when an unknown key is used or a list has incorrect size.
-    * Does not perform sparsity checking. 
-    */
+    * Does not perform sparsity checking.
+
+        \identifier{1x7} */
     /// @{
     DMDict convert_in(const std::vector<DM>& arg) const;
     std::vector<DM> convert_in(const DMDict& arg) const;
@@ -830,101 +998,153 @@ namespace casadi {
     std::vector<MX> convert_out(const MXDict& arg) const;
     /// @}
 
-    /** \brief Does the function have free variables */
+    /** \brief Does the function have free variables
+
+        \identifier{1x8} */
     bool has_free() const;
 
-    /** \brief Get free variables as a string */
+    /** \brief Get free variables as a string
+
+        \identifier{1x9} */
     std::vector<std::string> get_free() const;
 
-    /** \brief Get all the free variables of the function */
+    /** \brief Get all the free variables of the function
+
+        \identifier{1xa} */
     std::vector<SX> free_sx() const;
 
-    /** \brief Get all the free variables of the function */
+    /** \brief Get all the free variables of the function
+
+        \identifier{1xb} */
     std::vector<MX> free_mx() const;
 
-    /** \brief Extract the functions needed for the Lifted Newton method */
+    /** \brief Extract the functions needed for the Lifted Newton method
+
+        \identifier{1xc} */
     void generate_lifted(Function& SWIG_OUTPUT(vdef_fcn),
                          Function& SWIG_OUTPUT(vinit_fcn)) const;
 
-    /** \brief Number of nodes in the algorithm */
+    /** \brief Number of nodes in the algorithm
+
+        \identifier{1xd} */
     casadi_int n_nodes() const;
 
-    /** \brief Number of instruction in the algorithm (SXFunction/MXFunction) */
+    /** \brief Number of instruction in the algorithm (SXFunction/MXFunction)
+
+        \identifier{1xe} */
     casadi_int n_instructions() const;
 
-    /** \brief Identifier index of the instruction (SXFunction/MXFunction) */
+    /** \brief Identifier index of the instruction (SXFunction/MXFunction)
+
+        \identifier{1xf} */
     casadi_int instruction_id(casadi_int k) const;
 
     /** \brief Locations in the work vector for the inputs of the instruction
-     * (SXFunction/MXFunction) */
+
+     * (SXFunction/MXFunction)
+
+        \identifier{1xg} */
     std::vector<casadi_int> instruction_input(casadi_int k) const;
 
-    /** \brief Get the floating point output argument of an instruction (SXFunction) */
+    /** \brief Get the floating point output argument of an instruction (SXFunction)
+
+        \identifier{1xh} */
     double instruction_constant(casadi_int k) const;
 
     /** \brief Location in the work vector for the output of the instruction
-     * (SXFunction/MXFunction) */
+
+     * (SXFunction/MXFunction)
+
+        \identifier{1xi} */
     std::vector<casadi_int> instruction_output(casadi_int k) const;
 
-    /** \brief Get the MX node corresponding to an instruction (MXFunction) */
+    /** \brief Get the MX node corresponding to an instruction (MXFunction)
+
+        \identifier{1xj} */
     MX instruction_MX(casadi_int k) const;
 
     /** \brief Get the SX node corresponding to all instructions (SXFunction)
      *
      * Note: input and output instructions have no SX representation.
      * This method returns nan for those instructions.
-    */
+
+        \identifier{1xk} */
     SX instructions_sx() const;
 
     ///@{
-    /** \brief  Is the class able to propagate seeds through the algorithm? */
+    /** \brief  Is the class able to propagate seeds through the algorithm?
+
+        \identifier{1xl} */
     bool has_spfwd() const;
     bool has_sprev() const;
     ///@}
 
-    /** \brief Get required length of arg field */
+    /** \brief Get required length of arg field
+
+        \identifier{1xm} */
     size_t sz_arg() const;
 
-    /** \brief Get required length of res field */
+    /** \brief Get required length of res field
+
+        \identifier{1xn} */
     size_t sz_res() const;
 
-    /** \brief Get required length of iw field */
+    /** \brief Get required length of iw field
+
+        \identifier{1xo} */
     size_t sz_iw() const;
 
-    /** \brief Get required length of w field */
+    /** \brief Get required length of w field
+
+        \identifier{1xp} */
     size_t sz_w() const;
 
 #ifndef SWIG
-    /** \brief Get number of temporary variables needed */
+    /** \brief Get number of temporary variables needed
+
+        \identifier{1xq} */
     void sz_work(size_t& sz_arg, size_t& sz_res, size_t& sz_iw, size_t& sz_w) const;
 
-    /** \brief Set the (persistent) work vectors */
+    /** \brief Set the (persistent) work vectors
+
+        \identifier{1xr} */
     void set_work(const double**& arg, double**& res,
       casadi_int*& iw, double*& w, int mem=0) const;
 
-    /** \brief Set the (temporary) work vectors */
+    /** \brief Set the (temporary) work vectors
+
+        \identifier{1xs} */
     void set_temp(const double** arg, double** res,
         casadi_int* iw, double* w, int mem=0) const;
 
-    /** \brief Set the (persistent and temporary) work vectors */
+    /** \brief Set the (persistent and temporary) work vectors
+
+        \identifier{1xt} */
     void setup(const double** arg, double** res, casadi_int* iw, double* w, int mem=0) const;
 
-    /** \brief Call using a map */
+    /** \brief Call using a map
+
+        \identifier{1xu} */
     template<typename M>
     void call_gen(const std::map<std::string, M>& arg, std::map<std::string, M>& res,
                bool always_inline, bool never_inline) const;
 #endif // SWIG
     /// \endcond
 
-    /** \brief Name of the function */
-    std::string name() const;
+    /** \brief Name of the function
+
+        \identifier{1xv} */
+    const std::string& name() const;
 
     /** \brief Check if the function is of a particular type
+
         Optionally check if name matches one of the base classes (default true)
-     */
+
+        \identifier{1xw} */
     bool is_a(const std::string& type, bool recursive=true) const;
 
     /** \brief Check if a string is a valid function name
+
      * Valid function names consist of
      *
      * - At least one character
@@ -933,25 +1153,36 @@ namespace casadi {
      * - Underscore, but never as first character and never next to another underscore
      *
      * May not be one of the following keywords: "null", "jac", "hess"
-     */
+
+        \identifier{1xx} */
     static bool check_name(const std::string& name);
 
     /** \brief Turn a string into a valid function name as defined by "check_name"
+
      * Non-alphanumeric characters are converted into underscores and multiple
      * consecutive undercores are dropped
-     */
+
+        \identifier{1xy} */
     static std::string fix_name(const std::string& name);
 
-    /** \brief Build function from serialization */
+    /** \brief Build function from serialization
+
+        \identifier{1xz} */
     static Function deserialize(std::istream& stream);
 
-    /** \brief Build function from serialization */
+    /** \brief Build function from serialization
+
+        \identifier{1y0} */
     static Function deserialize(const std::string& s);
 
-    /** \brief Build function from serialization */
+    /** \brief Build function from serialization
+
+        \identifier{1y1} */
     static Function load(const std::string& filename);
 
-    /** \brief Build function from serialization */
+    /** \brief Build function from serialization
+
+        \identifier{1y2} */
     static Function deserialize(DeserializingStream& s);
 
     /// Assert that an input dimension is equal so some given value
@@ -971,22 +1202,50 @@ namespace casadi {
     void* memory(int ind) const;
 #endif // SWIG
 
-    // Get a list of all functions
+    /** \brief Get all functions in the cache
+
+        \identifier{26i} */
+    Dict cache() const;
+
+    /** \brief Get a list of all functions
+
+        \identifier{1y3} */
     std::vector<std::string> get_function() const;
 
-    // Get a dependency function
+    /** \brief Get a dependency function
+
+        \identifier{1y4} */
     Function get_function(const std::string &name) const;
 
-    // Check if a particular dependency exists
+    /** \brief Check if a particular dependency exists
+
+        \identifier{1y5} */
     bool has_function(const std::string& fname) const;
 
+    /** \brief Get all functions embedded in the expression graphs
+
+      * \param[in] max_depth  Maximum depth - a negative number indicates no maximum
+
+        \identifier{1y6} */
+    std::vector<Function> find_functions(casadi_int max_depth = -1) const;
+
+    /** \brief  Get a specific function embedded in the expression graphs
+
+      * \param[in] name  Name of function needed
+      * \param[in] max_depth  Maximum depth - a negative number indicates no maximum
+
+        \identifier{1y7} */
+    Function find_function(const std::string &name, casadi_int max_depth=-1) const;
+
     /** Obtain information about function */
     Dict info() const;
 
 #ifndef SWIG
     protected:
     ///@{
-    /** \brief Called by constructors */
+    /** \brief Called by constructors
+
+        \identifier{1y8} */
     void construct(const std::string& name,
                    const std::vector<SX>& ex_in, const std::vector<SX>& ex_out,
                    const std::vector<std::string>& name_in,
@@ -1027,7 +1286,8 @@ namespace casadi {
 
 
 /** \brief Class to achieve minimal overhead function evaluations
-*/
+
+    \identifier{1y9} */
 class CASADI_EXPORT FunctionBuffer {
   Function f_;
   std::vector<double> w_;
@@ -1039,7 +1299,9 @@ class CASADI_EXPORT FunctionBuffer {
   void *mem_internal_;
   int ret_;
 public:
-  /** \brief Main constructor */
+  /** \brief Main constructor
+
+      \identifier{1ya} */
   FunctionBuffer(const Function& f);
 #ifndef SWIG
   ~FunctionBuffer();
@@ -1052,7 +1314,8 @@ public:
       mem.set_arg(0, memoryview(a))
 
       Note that CasADi uses 'fortran' order: column-by-column
-  */
+
+      \identifier{1yb} */
   void set_arg(casadi_int i, const double* a, casadi_int size);
 
   /** \brief Set output buffer for ouput i
@@ -1060,7 +1323,8 @@ public:
       mem.set_res(0, memoryview(a))
 
       Note that CasADi uses 'fortran' order: column-by-column
-  */
+
+      \identifier{1yc} */
   void set_res(casadi_int i, double* a, casadi_int size);
   /// Get last return value
   int ret();