function.hpp

/*
 *    This file is part of CasADi.
 *
 *    CasADi -- A symbolic framework for dynamic optimization.
 *    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
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 3 of the License, or (at your option) any later version.
 *
 *    CasADi is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with CasADi; if not, write to the Free Software
 *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */
 
#ifndef CASADI_FUNCTION_HPP
#define CASADI_FUNCTION_HPP
 
#include "sx_elem.hpp"
#include "mx.hpp"
#include "printable.hpp"
#include <exception>
#include <stack>
 
namespace casadi {
 
#ifndef SWIG
  class FunctionInternal;
  class SerializingStream;
  class DeserializingStream;
#endif // SWIG
 
  class CASADI_EXPORT Function :
    public SharedObject,
    public SWIG_IF_ELSE(PrintableCommon, Printable<Function>) {
  public:
    static std::string type_name() {return "Function";}
 
    Function();
 
    Function(const std::string& fname);
 
 
    Function(const std::string& name,
             const std::vector<SX>& ex_in,
             const std::vector<SX>& ex_out,
             const Dict& opts=Dict());
    Function(const std::string& name,
             const std::vector<SX>& ex_in,
             const std::vector<SX>& ex_out,
             const std::vector<std::string>& name_in,
             const std::vector<std::string>& name_out,
             const Dict& opts=Dict());
    Function(const std::string& name, const std::map<std::string, SX>& dict,
             const std::vector<std::string>& name_in,
             const std::vector<std::string>& name_out,
             const Dict& opts=Dict());
 
 
    Function(const std::string& name,
             const std::vector<MX>& ex_in,
             const std::vector<MX>& ex_out,
             const Dict& opts=Dict());
    Function(const std::string& name,
             const std::vector<MX>& ex_in,
             const std::vector<MX>& ex_out,
             const std::vector<std::string>& name_in,
             const std::vector<std::string>& name_out,
             const Dict& opts=Dict());
    Function(const std::string& name, const std::map<std::string, MX>& dict,
             const std::vector<std::string>& name_in,
             const std::vector<std::string>& name_out,
             const Dict& opts=Dict());
 
 
#ifndef SWIG
    Function(const std::string& name, SXIList ex_in,
      const SXVector& ex_out, const Dict& opts=Dict());
    Function(const std::string& name, const SXVector& ex_in,
      SXIList ex_out, const Dict& opts=Dict());
    Function(const std::string& name, SXIList ex_in,
      SXIList ex_out, const Dict& opts=Dict());
    Function(const std::string& name, SXIList ex_in, const SXVector& ex_out,
             const StringVector& name_in, const StringVector& name_out,
             const Dict& opts=Dict());
    Function(const std::string& name, const SXVector& ex_in, SXIList ex_out,
             const StringVector& name_in, const StringVector& name_out,
             const Dict& opts=Dict());
    Function(const std::string& name, SXIList ex_in, SXIList ex_out,
             const StringVector& name_in, const StringVector& name_out,
             const Dict& opts=Dict());
    Function(const std::string& name, MXIList ex_in, const MXVector& ex_out,
             const Dict& opts=Dict());
    Function(const std::string& name, const MXVector& ex_in, MXIList ex_out,
             const Dict& opts=Dict());
    Function(const std::string& name, MXIList ex_in, MXIList ex_out,
             const Dict& opts=Dict());
    Function(const std::string& name, MXIList ex_in, const MXVector& ex_out,
             const StringVector& name_in, const StringVector& name_out,
             const Dict& opts=Dict());
    Function(const std::string& name, const MXVector& ex_in, MXIList ex_out,
             const StringVector& name_in, const StringVector& name_out,
             const Dict& opts=Dict());
    Function(const std::string& name, MXIList ex_in, MXIList ex_out,
             const StringVector& name_in, const StringVector& name_out,
             const Dict& opts=Dict());
#endif // SWIG
 
 
    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,
             const Dict& opts=Dict());
    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,
             const std::vector<Sparsity>& sparsity_in,
             const std::vector<Sparsity>& sparsity_out,
             const Dict& opts=Dict());
 
    ~Function();
 
    Function expand() const;
    Function expand(const std::string& name,
                    const Dict& opts=Dict()) const;
 
#ifndef SWIG
    static Function create(FunctionInternal* node);
 
    static Function create(FunctionInternal* node, const Dict& opts);
#endif // SWIG
 
    casadi_int n_in() const;
 
    casadi_int n_out() const;
 
 
    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;
    casadi_int size2_in(const std::string& iname) const {return size2_in(index_in(iname));}
    std::pair<casadi_int, casadi_int> size_in(casadi_int ind) const;
    std::pair<casadi_int, casadi_int> size_in(const std::string& iname) const {
      return size_in(index_in(iname));
    }
 
 
    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;
    casadi_int size2_out(const std::string& oname) const {return size2_out(index_out(oname));}
    std::pair<casadi_int, casadi_int> size_out(casadi_int ind) const;
    std::pair<casadi_int, casadi_int> size_out(const std::string& oname) const {
      return size_out(index_out(oname));
    }
 
 
    casadi_int nnz_in() const;
    casadi_int nnz_in(casadi_int ind) const;
    casadi_int nnz_in(const std::string& iname) const {return nnz_in(index_in(iname));}
 
 
    casadi_int nnz_out() const;
    casadi_int nnz_out(casadi_int ind) const;
    casadi_int nnz_out(const std::string& oname) const {return nnz_out(index_out(oname));}
 
 
    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));}
 
 
    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));}
 
    const std::vector<std::string>& name_in() const;
 
    const std::vector<std::string>& name_out() const;
 
    const std::string& name_in(casadi_int ind) const;
 
    const std::string& name_out(casadi_int ind) const;
 
    casadi_int index_in(const std::string &name) const;
 
    casadi_int index_out(const std::string &name) const;
 
    bool has_in(const std::string &name) const;
    bool has_out(const std::string &name) const;
 
    double default_in(casadi_int ind) const;
 
    double max_in(casadi_int ind) const;
 
    double min_in(casadi_int ind) const;
 
    std::vector<double> nominal_in(casadi_int ind) const;
 
    std::vector<double> nominal_out(casadi_int ind) const;
 
    const Sparsity& sparsity_in(casadi_int ind) const;
    const Sparsity& sparsity_in(const std::string& iname) const;
 
    const Sparsity& sparsity_out(casadi_int ind) const;
    const Sparsity& sparsity_out(const std::string& iname) const;
 
    bool is_diff_in(casadi_int ind) const;
    bool is_diff_out(casadi_int ind) const;
    std::vector<bool> is_diff_in() const;
    std::vector<bool> is_diff_out() const;
 
    // A linear combination of inputs
    typedef std::map<std::string, std::vector<std::string> > AuxOut;
 
    // Factory
    Function factory(const std::string& name,
                     const std::vector<std::string>& s_in,
                     const std::vector<std::string>& s_out,
                     const AuxOut& aux=AuxOut(),
                     const Dict& opts=Dict()) const;
 
    Function oracle() const;
 
    Function wrap() const;
 
    Function wrap_as_needed(const Dict& opts) const;
 
    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;
 
    void print_dimensions(std::ostream &stream=casadi::uout()) const;
 
    void print_options(std::ostream &stream=casadi::uout()) const;
 
    void print_option(const std::string &name, std::ostream &stream = casadi::uout()) const;
 
    bool has_option(const std::string &option_name) const;
 
    void change_option(const std::string& option_name, const GenericType& option_value);
 
    bool uses_output() const;
 
#ifdef WITH_DEPRECATED_FEATURES
    Function jacobian_old(casadi_int iind, casadi_int oind) const;
 
    Function hessian_old(casadi_int iind, casadi_int oind) const;
 
    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
 
    Function jacobian() const;
 
 
    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),
              bool always_inline=false, bool never_inline=false) const;
    void call(const std::vector<MX> &arg, std::vector<MX>& SWIG_OUTPUT(res),
              bool always_inline=false, bool never_inline=false) const;
    void call(const DMDict& arg, DMDict& SWIG_OUTPUT(res),
              bool always_inline=false, bool never_inline=false) const;
    void call(const SXDict& arg, SXDict& SWIG_OUTPUT(res),
              bool always_inline=false, bool never_inline=false) const;
    void call(const MXDict& arg, MXDict& SWIG_OUTPUT(res),
              bool always_inline=false, bool never_inline=false) const;
 
#ifndef SWIG
    bool operator==(const Function& f) const;
 
    std::vector<DM> operator()(const std::vector<DM>& arg) const;
    std::vector<SX> operator()(const std::vector<SX>& arg) const;
    std::vector<MX> operator()(const std::vector<MX>& arg) const;
    const DMDict operator()(const DMDict& arg) const;
    const SXDict operator()(const SXDict& arg) const;
    const MXDict operator()(const MXDict& arg) const;
 
 
    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;
    template<typename D> void call_gen(std::vector<const D*> arg, std::vector<D*> res) const;
 
 
    typedef const std::vector<std::vector<double>>& VecArg;
    std::vector<const double*> buf_in(VecArg arg) const;
    typedef std::vector<std::vector<double>>& VecRes;
    std::vector<double*> buf_out(VecRes res) const;
    typedef std::vector<std::vector<double>*> VPrRes;
    std::vector<double*> buf_out(VPrRes res) const;
 
    typedef const std::map<std::string, std::vector<double>>& MapArg;
    std::vector<const double*> buf_in(MapArg arg) const;
    typedef std::map<std::string, std::vector<double>>& MapRes;
    std::vector<double*> buf_out(MapRes res) const;
    typedef std::map<std::string, std::vector<double>*> MPrRes;
    std::vector<double*> buf_out(MPrRes res) const;
 
 
    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)); }
    void operator()(VecArg arg, MPrRes res) const { (*this)(buf_in(arg), buf_out(res)); }
 
    void operator()(MapArg arg, VecRes res) const { (*this)(buf_in(arg), buf_out(res)); }
    void operator()(MapArg arg, MapRes res) const { (*this)(buf_in(arg), buf_out(res)); }
    void operator()(MapArg arg, VPrRes res) const { (*this)(buf_in(arg), buf_out(res)); }
    void operator()(MapArg arg, MPrRes res) const { (*this)(buf_in(arg), buf_out(res)); }
 
    std::vector<DM> operator()(const DM& arg0) const {
      return operator()(std::vector<DM>{arg0});
    }
    std::vector<SX> operator()(const SX& arg0) const {
      return operator()(std::vector<SX>{arg0});
    }
    std::vector<MX> operator()(const MX& arg0) const {
      return operator()(std::vector<MX>{arg0});
    }
 
    int operator()(const double** arg, double** res,
        casadi_int* iw, double* w, int mem) const;
 
    int operator()(const double** arg, double** res,
        casadi_int* iw, double* w) const;
 
    int operator()(const SXElem** arg, SXElem** res,
        casadi_int* iw, SXElem* w, int mem=0) const;
 
    int operator()(const bvec_t** arg, bvec_t** res,
        casadi_int* iw, bvec_t* w, int mem=0) const;
 
    int rev(bvec_t** arg, bvec_t** res, casadi_int* iw, bvec_t* w, int mem=0) const;
 
    int rev(std::vector<bvec_t*> arg, std::vector<bvec_t*> res) const;
 
#endif // SWIG
 
    std::vector<MX> mapsum(const std::vector<MX > &x,
                           const std::string& parallelization="serial") const;
 
 
    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;
    Function mapaccum(const std::string& name, casadi_int n,
                      const std::vector<casadi_int>& accum_in,
                      const std::vector<casadi_int>& accum_out,
                      const Dict& opts=Dict()) const;
    Function mapaccum(const std::string& name, casadi_int n,
                      const std::vector<std::string>& accum_in,
                      const std::vector<std::string>& accum_out,
                      const Dict& opts=Dict()) const;
    Function mapaccum(casadi_int N, const Dict& opts = Dict()) const;
    Function fold(casadi_int N, const Dict& opts = Dict()) const;
 
    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;
 
 
    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,
      const Dict& opts=Dict()) const;
    Function map(const std::string& name, const std::string& parallelization, casadi_int n,
      const std::vector<std::string>& reduce_in,
      const std::vector<std::string>& reduce_out,
      const Dict& opts=Dict()) const;
    Function map(casadi_int n,
      const std::vector<bool>& reduce_in,
      const std::vector<bool>& reduce_out=std::vector<bool>(),
      const Dict& opts=Dict()) const;
 
    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;
 
    static Function conditional(const std::string& name, const std::vector<Function>& f,
                                const Function& f_def, const Dict& opts=Dict());
 
    static Function conditional(const std::string& name,
      const Function& f, const Dict& opts=Dict());
 
    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());
 
    static Function if_else(const std::string& name, const Function& f_true,
                            const Function& f_false, const Dict& opts=Dict());
 
    Function forward(casadi_int nfwd) const;
 
    Function reverse(casadi_int nadj) const;
 
    const std::vector<Sparsity>& jac_sparsity(bool compact = false) const;
 
    Sparsity jac_sparsity(casadi_int oind, casadi_int iind, bool compact = false) const;
 
    std::string generate(const std::string& fname, const Dict& opts=Dict()) const;
 
    std::string generate(const Dict& opts=Dict()) const;
 
    std::string generate_dependencies(const std::string& fname, const Dict& opts=Dict()) const;
 
    void generate_in(const std::string& fname, const std::vector<DM>& arg);
    std::vector<DM> generate_in(const std::string& fname);
 
    void generate_out(const std::string& fname, const std::vector<DM>& arg);
    std::vector<DM> generate_out(const std::string& fname);
 
    void export_code(const std::string& lang,
      const std::string &fname, const Dict& options=Dict()) const;
 
#ifndef SWIG
    void serialize(std::ostream &stream, const Dict& opts=Dict()) const;
 
    void serialize(SerializingStream &s) const;
#endif
 
    std::string serialize(const Dict& opts=Dict()) const;
 
    void save(const std::string &fname, const Dict& opts=Dict()) const;
 
    std::string export_code(const std::string& lang, const Dict& options=Dict()) const;
#ifndef SWIG
    void export_code(const std::string& lang,
      std::ostream &stream, const Dict& options=Dict()) const;
#endif // SWIG
#ifndef SWIG
    FunctionInternal* get() const;
 
    template<typename T>
    T* get() const {
      T* ret = dynamic_cast<T*>(get());
      casadi_assert_dev(ret!=nullptr);
      return ret;
    }
 
    FunctionInternal* operator->() const;
 
    static bool test_cast(const SharedObjectInternal* ptr);
#endif // SWIG
 
    Dict stats(int mem=0) const;
 
 
    const SX sx_in(casadi_int iind) const;
    const SX sx_in(const std::string& iname) const {
      return sx_in(index_in(iname));
    }
    const std::vector<SX> sx_in() const;
    const MX mx_in(casadi_int ind) const;
    const MX mx_in(const std::string & iname) const {
      return mx_in(index_in(iname));
    }
    const std::vector<MX> mx_in() const;
 
 
    const SX sx_out(casadi_int oind) const;
    const SX sx_out(const std::string& oname) const {
      return sx_out(index_out(oname));
    }
    const std::vector<SX> sx_out() const;
    const MX mx_out(casadi_int ind) const;
    const MX mx_out(const std::string& oname) const {
      return mx_out(index_out(oname));
    }
    const std::vector<MX> mx_out() const;
 
    std::vector<double> nz_from_in(const std::vector<DM>& arg) const;
    std::vector<double> nz_from_out(const std::vector<DM>& arg) const;
    std::vector<DM> nz_to_in(const std::vector<double>& arg) const;
    std::vector<DM> nz_to_out(const std::vector<double>& arg) const;
 
    DMDict convert_in(const std::vector<DM>& arg) const;
    std::vector<DM> convert_in(const DMDict& arg) const;
    DMDict convert_out(const std::vector<DM>& arg) const;
    std::vector<DM> convert_out(const DMDict& arg) const;
    SXDict convert_in(const std::vector<SX>& arg) const;
    std::vector<SX> convert_in(const SXDict& arg) const;
    SXDict convert_out(const std::vector<SX>& arg) const;
    std::vector<SX> convert_out(const SXDict& arg) const;
    MXDict convert_in(const std::vector<MX>& arg) const;
    std::vector<MX> convert_in(const MXDict& arg) const;
    MXDict convert_out(const std::vector<MX>& arg) const;
    std::vector<MX> convert_out(const MXDict& arg) const;
 
    bool has_free() const;
 
    std::vector<std::string> get_free() const;
 
    std::vector<SX> free_sx() const;
 
    std::vector<MX> free_mx() const;
 
    void generate_lifted(Function& SWIG_OUTPUT(vdef_fcn),
                         Function& SWIG_OUTPUT(vinit_fcn)) const;
 
    casadi_int n_nodes() const;
 
    casadi_int n_instructions() const;
 
    casadi_int instruction_id(casadi_int k) const;
 
    std::vector<casadi_int> instruction_input(casadi_int k) const;
 
    double instruction_constant(casadi_int k) const;
 
    std::vector<casadi_int> instruction_output(casadi_int k) const;
 
    MX instruction_MX(casadi_int k) const;
 
    SX instructions_sx() const;
 
 
    bool has_spfwd() const;
    bool has_sprev() const;
 
    size_t sz_arg() const;
 
    size_t sz_res() const;
 
    size_t sz_iw() const;
 
    size_t sz_w() const;
 
#ifndef SWIG
    void sz_work(size_t& sz_arg, size_t& sz_res, size_t& sz_iw, size_t& sz_w) const;
 
    void set_work(const double**& arg, double**& res,
      casadi_int*& iw, double*& w, int mem=0) const;
 
    void set_temp(const double** arg, double** res,
        casadi_int* iw, double* w, int mem=0) const;
 
    void setup(const double** arg, double** res, casadi_int* iw, double* w, int mem=0) const;
 
    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;
 
    void merge(const std::vector<MX>& arg,
        std::vector<MX>& subs_from, std::vector<MX>& subs_to) const;
#endif // SWIG
 
    const std::string& name() const;
 
    bool is_a(const std::string& type, bool recursive=true) const;
 
    static bool check_name(const std::string& name);
 
    static std::string fix_name(const std::string& name);
 
    static Function deserialize(std::istream& stream);
 
    static Function deserialize(const std::string& s);
 
    static Function load(const std::string& filename);
 
    static Function deserialize(DeserializingStream& s);
 
    void assert_size_in(casadi_int i, casadi_int nrow, casadi_int ncol) const;
 
    void assert_size_out(casadi_int i, casadi_int nrow, casadi_int ncol) const;
 
    void assert_sparsity_out(casadi_int i, const Sparsity& sp,
        casadi_int n = 1, bool allow_all_zero_sparse = true) const;
 
    casadi_int checkout() const;
 
    void release(int mem) const;
 
#ifndef SWIG
    void* memory(int ind) const;
 
    static std::vector<SX> order(const std::vector<SX>& expr);
    static std::vector<MX> order(const std::vector<MX>& expr);
#endif // SWIG
 
    Dict cache() const;
 
    std::vector<std::string> get_function() const;
 
    Function get_function(const std::string &name) const;
 
    bool has_function(const std::string& fname) const;
 
    std::vector<Function> find_functions(casadi_int max_depth = -1) const;
 
    Function find_function(const std::string &name, casadi_int max_depth=-1) const;
 
    Dict info() const;
 
#ifndef SWIG
    protected:
 
    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,
                   const std::vector<std::string>& name_out,
                   const Dict& opts);
    void construct(const std::string& name,
                   const std::vector<MX>& ex_in, const std::vector<MX>& ex_out,
                   const std::vector<std::string>& name_in,
                   const std::vector<std::string>& name_out,
                   const Dict& opts);
    template<typename M>
      void construct(const std::string& name, const std::map<std::string, M>& dict,
                     const std::vector<std::string>& name_in,
                     const std::vector<std::string>& name_out,
                     const Dict& opts);
 
    static bool proceed_to(std::istream& file, const std::string& str);
 
    Function mapaccum(const std::string& name, const std::vector<Function>& chain,
                      casadi_int n_accum=1, const Dict& opts = Dict()) const;
 
#ifdef WITH_EXTRA_CHECKS
    public:
    // How many times have we passed through
    // operator()(const double** arg, double** res, casadi_int* iw, double* w, int mem)?
    static thread_local casadi_int call_depth_;
#endif
 
 
#endif // SWIG
 
 
 
  };
 
 
class CASADI_EXPORT FunctionBuffer {
  Function f_;
  std::vector<double> w_;
  std::vector<casadi_int> iw_;
  std::vector<const double*> arg_;
  std::vector<double*> res_;
  FunctionInternal* f_node_;
  casadi_int mem_;
  void *mem_internal_;
  int ret_;
public:
  FunctionBuffer(const Function& f);
#ifndef SWIG
  ~FunctionBuffer();
  FunctionBuffer(const FunctionBuffer& f);
  FunctionBuffer& operator=(const FunctionBuffer& f);
#endif // SWIG
 
  void set_arg(casadi_int i, const double* a, casadi_int size);
 
  void set_res(casadi_int i, double* a, casadi_int size);
  int ret();
  void _eval();
  void* _self() { return this; }
  Dict stats() const;
};
 
void CASADI_EXPORT _function_buffer_eval(void* raw);
 
 
} // namespace casadi
 
#include "casadi_interrupt.hpp"
#include "runtime/shared.hpp"
 
#endif // CASADI_FUNCTION_HPP