mx.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_MX_HPP
#define CASADI_MX_HPP
#include "shared_object.hpp"
#include "matrix_fwd.hpp"
#include "sx_fwd.hpp"
#include "dm.hpp"
#include "generic_matrix.hpp"
#include "generic_expression.hpp"
#include "generic_type.hpp"
#include "printable.hpp"
#include <vector>
#ifdef CASADI_WITH_THREAD
#ifdef CASADI_WITH_THREAD_MINGW
#include <mingw.mutex.h>
#else // CASADI_WITH_THREAD_MINGW
#include <mutex>
#endif // CASADI_WITH_THREAD_MINGW
#endif //CASADI_WITH_THREAD
 
namespace casadi {
 
  class MXNode;
  class Function;
  class SerializingStream;
  class DeserializingStream;
 
#ifndef SWIG
  struct ConvexifyData {
    std::vector<casadi_int> scc_offset, scc_mapping;
    Sparsity scc_sp;
    Sparsity Hrsp;
    Sparsity Hsp;
    casadi_convexify_config<double> config;
    casadi_int sz_iw;
    casadi_int sz_w;
    casadi_int *iw;
    double* w;
  };
#endif
 
  class CASADI_EXPORT MX :
    public SWIG_IF_ELSE(GenericExpressionCommon, GenericExpression<MX>),
    public SWIG_IF_ELSE(PrintableCommon, Printable<MX>),
    public GenericMatrix<MX>,
    public SharedObject {
  public:
    static std::string type_name() {return "MX";}
 
    MX();
 
    MX(casadi_int nrow, casadi_int ncol);
 
#ifndef SWIG
    explicit MX(const std::pair<casadi_int, casadi_int>& rc);
#endif // SWIG
 
    explicit MX(const Sparsity& sp);
 
    MX(const Sparsity& sp, const MX& val);
 
    MX(const Sparsity& sp, const std::string& fname);
 
 
    MX(const Matrix<double>& val, const std::string& name);
 
    MX(double x);
 
#ifndef SWIG
    MX(const std::vector<double> &x);
#endif
 
    MX(const Matrix<double> &x);
 
 
    ~MX();
 
#ifndef SWIG
 
    static MX create(MXNode* node);
 
    static std::vector<MX> createMultipleOutput(MXNode* node);
 
    const Sparsity& sparsity() const;
 
    typedef MX ScalarType;
 
    typedef GenericMatrix<MX> B;
 
    using B::horzsplit;
    using B::diagsplit;
    using B::vertsplit;
    using B::mtimes;
    using B::repmat;
#endif // SWIG
 
    bool __nonzero__() const;
 
    Sparsity get_sparsity() const { return sparsity();}
 
    std::vector<MX> get_nonzeros() const;
 
    void erase(const std::vector<casadi_int>& rr, const std::vector<casadi_int>& cc,
                bool ind1=false);
 
    void erase(const std::vector<casadi_int>& rr, bool ind1=false);
 
    void enlarge(casadi_int nrow, casadi_int ncol,
                  const std::vector<casadi_int>& rr, const std::vector<casadi_int>& cc,
                  bool ind1=false);
 
    MX operator-() const;
 
    MX operator+() const { return *this; }
 
    MX inv() const;
 
#ifndef SWIG
 
    MXNode* operator->();
 
    const MXNode* operator->() const;
#endif // SWIG
 
    MX dep(casadi_int ch=0) const;
 
    casadi_int n_out() const;
 
    MX get_output(casadi_int oind) const;
 
    casadi_int n_dep() const;
 
    std::string name() const;
 
    explicit operator double() const;
 
    explicit operator Matrix<double>() const;
 
    bool is_symbolic() const;
 
    bool is_constant() const;
 
    bool is_integer() const;
 
    bool is_doubled() const;
 
    bool is_call() const;
 
    Function which_function() const;
 
    bool is_output() const;
 
    bool has_output() const;
 
    casadi_int which_output() const;
 
    bool is_op(casadi_int op) const;
 
    bool is_multiplication() const;
 
    bool is_commutative() const;
 
    bool is_norm() const;
 
    bool is_valid_input() const;
 
    casadi_int n_primitives() const;
 
    std::vector<MX> primitives() const;
 
 
    std::vector<MX> split_primitives(const MX& x) const;
    std::vector<SX> split_primitives(const SX& x) const;
    std::vector<DM> split_primitives(const DM& x) const;
 
 
    MX join_primitives(const std::vector<MX>& v) const;
    SX join_primitives(const std::vector<SX>& v) const;
    DM join_primitives(const std::vector<DM>& v) const;
 
 
    bool has_duplicates() const;
 
    void reset_input() const;
 
    bool is_eye() const;
 
    bool is_zero() const;
 
    bool is_one() const;
 
    bool is_minus_one() const;
 
    bool is_half() const;
 
    bool is_value(double val) const;
 
    bool is_inf() const;
 
    bool is_minus_inf() const;
 
    bool is_transpose() const;
 
    bool is_regular() const;
 
    bool is_binary() const;
 
    bool is_nonnegative() const;
 
    bool is_unary() const;
 
    casadi_int op() const;
 
    Dict info() const;
 
    void serialize(SerializingStream& s) const;
 
    static MX deserialize(DeserializingStream& s);
 
    casadi_int get_temp() const;
 
    void set_temp(casadi_int t) const;
 
 
    static MX binary(casadi_int op, const MX &x, const MX &y,
        bool unique_x=false, bool unique_y=false);
    static MX unary(casadi_int op, const MX &x, bool unique=false);
 
 
    static MX inf(const Sparsity& sp);
    static MX inf(casadi_int nrow=1, casadi_int ncol=1);
    static MX inf(const std::pair<casadi_int, casadi_int>& rc);
 
 
    static MX nan(const Sparsity& sp);
    static MX nan(casadi_int nrow=1, casadi_int ncol=1);
    static MX nan(const std::pair<casadi_int, casadi_int>& rc);
 
    static MX eye(casadi_int n);
 
#ifndef SWIG
    MXNode* get() const;
#endif // SWIG
 
 
    MX nzref(const Sparsity& sp, const std::vector<casadi_int>& nz) const;
 
 
    void get(MX& SWIG_OUTPUT(m), bool ind1, const Slice& rr) const;
    void get(MX& SWIG_OUTPUT(m), bool ind1, const Matrix<casadi_int>& rr) const;
    void get(MX& SWIG_OUTPUT(m), bool ind1, const Sparsity& sp) const;
    void get(MX& SWIG_OUTPUT(m), bool ind1, const MX& rr) const;
    void get(MX& SWIG_OUTPUT(m), bool ind1, const casadi_int rr) const {
      get(m, ind1, Matrix<casadi_int>(rr));
    }
 
 
    void get(MX& SWIG_OUTPUT(m), bool ind1, const Slice& rr, const Slice& cc) const;
    void get(MX& SWIG_OUTPUT(m), bool ind1, const Slice& rr, const Matrix<casadi_int>& cc) const;
    void get(MX& SWIG_OUTPUT(m), bool ind1, const Slice& rr, casadi_int cc) const {
      get(m, ind1, rr, Matrix<casadi_int>(cc));
    }
    void get(MX& SWIG_OUTPUT(m), bool ind1, const Matrix<casadi_int>& rr, const Slice& cc) const;
    void get(MX& SWIG_OUTPUT(m), bool ind1, casadi_int rr, const Slice& cc) const {
      get(m, ind1, Matrix<casadi_int>(rr), cc);
    }
    void get(MX& SWIG_OUTPUT(m), bool ind1, const Matrix<casadi_int>& rr,
                                            const Matrix<casadi_int>& cc) const;
    void get(MX& SWIG_OUTPUT(m), bool ind1, casadi_int rr,
                                            casadi_int cc) const {
      get(m, ind1, Matrix<casadi_int>(rr), Matrix<casadi_int>(cc));
    }
    void get(MX& SWIG_OUTPUT(m), bool ind1, const MX& rr, const Slice& cc) const;
    void get(MX& SWIG_OUTPUT(m), bool ind1, const Slice& rr, const MX& cc) const;
    void get(MX& SWIG_OUTPUT(m), bool ind1, const MX& rr, const MX& cc) const;
 
 
    void set(const MX& m, bool ind1, const Slice& rr);
    void set(const MX& m, bool ind1, const Matrix<casadi_int>& rr);
    void set(const MX& m, bool ind1, const Sparsity& sp);
 
 
    void set(const MX& m, bool ind1, const Slice& rr, const Slice& cc);
    void set(const MX& m, bool ind1, const Slice& rr, const Matrix<casadi_int>& cc);
    void set(const MX& m, bool ind1, const Matrix<casadi_int>& rr, const Slice& cc);
    void set(const MX& m, bool ind1, const Matrix<casadi_int>& rr, const Matrix<casadi_int>& cc);
 
 
    void get_nz(MX& SWIG_OUTPUT(m), bool ind1, const Slice& kk) const;
    void get_nz(MX& SWIG_OUTPUT(m), bool ind1, const Matrix<casadi_int>& kk) const;
    void get_nz(MX& SWIG_OUTPUT(m), bool ind1, const MX& kk) const;
    void get_nz(MX& SWIG_OUTPUT(m), bool ind1, casadi_int kk) const {
      get_nz(m, ind1, Matrix<casadi_int>(kk));
    }
    void get_nz(MX& SWIG_OUTPUT(m), bool ind1, const MX& inner, const Slice& outer) const;
    void get_nz(MX& SWIG_OUTPUT(m), bool ind1, const Slice& inner, const MX& outer) const;
    void get_nz(MX& SWIG_OUTPUT(m), bool ind1, const MX& inner, const MX& outer) const;
 
 
    void set_nz(const MX& m, bool ind1, const Slice& kk);
    void set_nz(const MX& m, bool ind1, const Matrix<casadi_int>& kk);
    void set_nz(const MX& m, bool ind1, const MX& kk);
    void set_nz(const MX& m, bool ind1, casadi_int kk) { set_nz(m, ind1, Matrix<casadi_int>(kk)); }
 
 
    static MX einstein(const MX& A, const MX& B, const MX& C,
      const std::vector<casadi_int>& dim_a, const std::vector<casadi_int>& dim_b,
      const std::vector<casadi_int>& dim_c,
      const std::vector<casadi_int>& a, const std::vector<casadi_int>& b,
      const std::vector<casadi_int>& c);
 
    static MX einstein(const MX& A, const MX& B,
      const std::vector<casadi_int>& dim_a, const std::vector<casadi_int>& dim_b,
      const std::vector<casadi_int>& dim_c,
      const std::vector<casadi_int>& a, const std::vector<casadi_int>& b,
      const std::vector<casadi_int>& c);
 
#ifndef SWIG
    static bool is_equal(const MX& x, const MX& y, casadi_int depth=0);
    static MX mmin(const MX &x);
    static MX mmax(const MX &x);
 
    static MX horzcat(const std::vector<MX>& x);
    static MX diagcat(const std::vector<MX>& x);
    static MX vertcat(const std::vector<MX>& x);
    static std::vector<MX> horzsplit(const MX& x, const std::vector<casadi_int>& offset);
    static std::vector<MX> diagsplit(const MX& x, const std::vector<casadi_int>& offset1,
                                     const std::vector<casadi_int>& offset2);
    static std::vector<MX> vertsplit(const MX& x, const std::vector<casadi_int>& offset);
    static MX blockcat(const std::vector< std::vector<MX > > &v);
    static MX mtimes(const MX& x, const MX& y,
                     const std::string& blas = "reference");
    static MX mac(const MX& x, const MX& y, const MX& z,
                  const std::string& blas = "reference");
    static MX reshape(const MX& x, casadi_int nrow, casadi_int ncol);
    static MX reshape(const MX& x, const Sparsity& sp);
    static MX sparsity_cast(const MX& x, const Sparsity& sp);
    static MX kron(const MX& x, const MX& b);
    static MX kron_contract(const MX& m, const MX& x, bool inner);
    static MX repmat(const MX& x, casadi_int n, casadi_int m=1);
 
    static MX linspace(const MX& a, const MX& b, casadi_int nsteps);
    static MX jacobian(const MX& f, const MX& x, const Dict& opts = Dict());
    static MX hessian(const MX& f, const MX& x, const Dict& opts = Dict());
    static MX hessian(const MX& f, const MX& x, MX& g, const Dict& opts = Dict());
    static std::vector<std::vector<MX> >
    forward(const std::vector<MX> &ex,
            const std::vector<MX> &arg,
            const std::vector<std::vector<MX> > &v,
            const Dict& opts = Dict());
    static std::vector<std::vector<MX> >
    reverse(const std::vector<MX> &ex,
            const std::vector<MX> &arg,
            const std::vector<std::vector<MX> > &v,
            const Dict& opts = Dict());
    static std::vector<bool> which_depends(const MX &expr, const MX &var,
        casadi_int order=1, bool tr=false);
    static Sparsity jacobian_sparsity(const MX& f, const MX& x);
    static MX substitute(const MX& ex, const MX& v, const MX& vdef);
    static std::vector<MX> substitute(const std::vector<MX> &ex,
                                         const std::vector<MX> &v,
                                         const std::vector<MX> &vdef);
    static void substitute_inplace(const std::vector<MX>& v,
                                  std::vector<MX>& vdef,
                                  std::vector<MX>& ex, bool reverse);
    static MX solve(const MX& a, const MX& b);
    static MX solve(const MX& a, const MX& b, const std::string& lsolver,
                    const Dict& dict = Dict());
    static MX inv_minor(const MX& A);
    static MX inv_node(const MX& A);
    static MX inv(const MX& A, const std::string& lsolver="qr", const Dict& dict = Dict());
    static MX pinv(const MX& A, const std::string& lsolver="qr",
               const Dict& dict = Dict());
    static MX expm_const(const MX& A, const MX& t);
    static MX expm(const MX& A);
    static casadi_int n_nodes(const MX& x);
    static std::string print_operator(const MX& x, const std::vector<std::string>& args);
    static void extract(std::vector<MX>& ex, std::vector<MX>& v,
      std::vector<MX>& vdef, const Dict& opts = Dict());
    static void shared(std::vector<MX>& ex, std::vector<MX>& v,
      std::vector<MX>& vdef, const std::string& v_prefix, const std::string& v_suffix);
    static MX if_else(const MX& cond, const MX& if_true,
                      const MX& if_false, bool short_circuit=false);
    static MX conditional(const MX& ind, const std::vector<MX> &x, const MX& x_default,
                          bool short_circuit=false);
    static bool depends_on(const MX& x, const MX& arg);
    static bool contains_all(const std::vector<MX>& v, const std::vector<MX> &n);
    static bool contains_any(const std::vector<MX>& v, const std::vector<MX> &n);
    static MX simplify(const MX& x);
    static MX transform(const MX& x, const Dict& opts = Dict());
    static MX transform(const MX& x,
        const std::vector<std::vector<GenericType> >& passes, const Dict& opts = Dict());
    static std::vector<MX> transform(const std::vector<MX>& x, const Dict& opts = Dict());
    static std::vector<MX> transform(const std::vector<MX>& x,
        const std::vector<std::vector<GenericType> >& passes, const Dict& opts = Dict());
    static MX dot(const MX& x, const MX& y);
    static MX mrdivide(const MX& a, const MX& b);
    static MX mldivide(const MX& a, const MX& b);
    static MX norm_2(const MX& x);
    static MX norm_fro(const MX& x);
    static MX norm_1(const MX& x);
    static MX norm_inf(const MX& x);
    static MX unite(const MX& A, const MX& B);
    static MX trace(const MX& x);
    static MX diag(const MX& x);
    static MX sum2(const MX& x);
    static MX sum1(const MX& x);
    static MX polyval(const MX& p, const MX& x);
    static MX det(const MX& x);
    static MX det(const MX& x, const std::string& lsolver, const Dict& opts=Dict());
    static std::vector<MX> symvar(const MX& x);
    static MX nullspace(const MX& A);
    static MX repsum(const MX& x, casadi_int n, casadi_int m=1);
    static MX densify(const MX& x, const MX& val=0);
    static MX _bilin(const MX& A, const MX& x, const MX& y);
    static MX _rank1(const MX& A, const MX& alpha, const MX& x, const MX& y);
    static MX project(const MX& x, const Sparsity& sp, bool intersect=false);
    static MX cumsum(const MX &x, casadi_int axis=-1);
    static MX _logsumexp(const MX& x);
    static std::vector<MX> cse(const std::vector<MX>& e);
    static void extract_parametric(const MX &expr, const MX& par,
            MX& expr_ret, std::vector<MX>& symbols, std::vector<MX>& parametric, const Dict& opts);
    static void separate_linear(const MX &expr,
      const MX &sym_lin, const MX &sym_const,
      MX& expr_const, MX& expr_lin, MX& expr_nonlin);
 
    static MX find(const MX& x);
    static MX low(const MX& v, const MX& p, const Dict& options = Dict());
    static MX graph_substitute(const MX& x, const std::vector<MX> &v,
                               const std::vector<MX> &vdef);
    static MX graph_substitute(const MX& x, const std::vector<MX> &v,
                               const std::vector<MX> &vdef, bool& updated);
    static std::vector<MX> graph_substitute(const std::vector<MX> &ex,
                                            const std::vector<MX> &v,
                                            const std::vector<MX> &vdef);
    static std::vector<MX> graph_substitute(const std::vector<MX> &ex,
                                            const std::vector<MX> &v,
                                            const std::vector<MX> &vdef,
                                            bool& updated);
    static MX matrix_expand(const MX& e, const std::vector<MX> &boundary,
                            const Dict& options);
    static std::vector<MX> matrix_expand(const std::vector<MX>& e,
                                         const std::vector<MX>& boundary,
                                         const Dict& options);
    static MX lift(const MX& x, const MX& x_guess);
    static DM evalf(const MX& m);
    static MX bspline(const MX& x,
            const DM& coeffs,
            const std::vector< std::vector<double> >& knots,
            const std::vector<casadi_int>& degree,
            casadi_int m,
            const Dict& opts = Dict());
    static MX bspline(const MX& x, const MX& coeffs,
            const std::vector< std::vector<double> >& knots,
            const std::vector<casadi_int>& degree,
            casadi_int m,
            const Dict& opts = Dict());
    static MX bspline(const MX& x, const MX& coeffs,
            const std::vector<MX>& knots,
            const std::vector<casadi_int>& degree,
            casadi_int m,
            const Dict& opts = Dict());
    static MX convexify(const MX& H, const Dict& opts = Dict());
    static MX stop_diff(const MX& expr, casadi_int order);
    static MX stop_diff(const MX& expr, const MX& var, casadi_int order);
    static std::vector<MX> difference(const std::vector<MX>& a, const std::vector<MX>& b);
 
#endif // SWIG
 
    // Simplification with reference counting awareness
    static bool simplify_ref_count(std::vector<MX>& arg,
                                   std::vector<MX>& res,
                                   const Dict& opts = Dict());
 
    // Simplification with constant folding
    static bool simplify_const_folding(std::vector<MX>& arg,
                                   std::vector<MX>& res,
                                   const Dict& opts = Dict());
 
    // Simplification by combining like terms in linear combinations
    static bool simplify_combine_terms(std::vector<MX>& arg,
                                   std::vector<MX>& res,
                                   const Dict& opts = Dict());
 
    static DM bspline_dual(const std::vector<double>& x,
            const std::vector< std::vector<double> >& knots,
            const std::vector<casadi_int>& degree,
            const Dict& opts = Dict());
 
    static MX interpn_linear(const std::vector<MX>& x, const MX& v, const std::vector<MX>& xq,
      const Dict& opts=Dict());
 
    MX printme(const MX& b) const;
 
#if !defined(SWIG) || defined(DOXYGEN)
    inline friend MX find(const MX& x) {
      return MX::find(x);
    }
 
    inline friend MX low(const MX& v, const MX& p, const Dict& options=Dict()) {
      return MX::low(v, p, options);
    }
 
    inline friend MX graph_substitute(const MX& ex, const std::vector<MX> &v,
                                      const std::vector<MX> &vdef) {
      return MX::graph_substitute(ex, v, vdef);
    }
 
    inline friend MX graph_substitute(const MX& ex, const std::vector<MX> &v,
                                      const std::vector<MX> &vdef, bool& updated) {
      return MX::graph_substitute(ex, v, vdef, updated);
    }
 
    inline friend std::vector<MX>
      graph_substitute(const std::vector<MX> &ex,
                       const std::vector<MX> &v,
                       const std::vector<MX> &vdef) {
      return MX::graph_substitute(ex, v, vdef);
    }
 
    inline friend std::vector<MX>
      graph_substitute(const std::vector<MX> &ex,
                       const std::vector<MX> &v,
                       const std::vector<MX> &vdef,
                       bool& updated) {
      return MX::graph_substitute(ex, v, vdef, updated);
    }
 
    inline friend MX
      matrix_expand(const MX& e, const std::vector<MX> &boundary = std::vector<MX>(),
        const Dict& options = Dict()) {
      return MX::matrix_expand(e, boundary, options);
    }
 
    inline friend std::vector<MX>
      matrix_expand(const std::vector<MX>& e,
                    const std::vector<MX> &boundary = std::vector<MX>(),
                    const Dict& options = Dict()) {
      return MX::matrix_expand(e, boundary, options);
    }
 
 
    inline friend MX bspline(const MX& x,
            const DM& coeffs,
            const std::vector< std::vector<double> >& knots,
            const std::vector<casadi_int>& degree,
            casadi_int m,
            const Dict& opts = Dict()) {
      return MX::bspline(x, coeffs, knots, degree, m, opts);
    }
 
    inline friend MX bspline(const MX& x, const MX& coeffs,
            const std::vector< std::vector<double> >& knots,
            const std::vector<casadi_int>& degree,
            casadi_int m,
            const Dict& opts = Dict()) {
      return MX::bspline(x, coeffs, knots, degree, m, opts);
    }
 
    inline friend MX bspline(const MX& x, const MX& coeffs,
            const std::vector<MX>& knots,
            const std::vector<casadi_int>& degree,
            casadi_int m,
            const Dict& opts = Dict()) {
      return MX::bspline(x, coeffs, knots, degree, m, opts);
    }
 
    inline friend DM bspline_dual(const std::vector<double>& x,
            const std::vector< std::vector<double> >& knots,
            const std::vector<casadi_int>& degree,
            const Dict& opts = Dict()) {
      return MX::bspline_dual(x, knots, degree, opts);
    }
 
    inline friend MX convexify(const MX& H,
            const Dict& opts = Dict()) {
      return MX::convexify(H, opts);
    }
 
    inline friend MX lift(const MX& x, const MX& x_guess) {
      return MX::lift(x, x_guess);
    }
 
    inline friend MX inv_node(const MX& x) {
      return MX::inv_node(x);
    }
 
    inline friend DM evalf(const MX& expr) {
      return MX::evalf(expr);
    }
 
    inline friend MX stop_diff(const MX& expr, casadi_int order) {
      return MX::stop_diff(expr, order);
    }
 
    inline friend MX no_grad(const MX& expr) {
      return MX::stop_diff(expr, 1);
    }
 
    inline friend MX no_hess(const MX& expr) {
      return MX::stop_diff(expr, 2);
    }
 
 
    inline friend MX stop_diff(const MX& expr, const MX& var, casadi_int order) {
      return MX::stop_diff(expr, var, order);
    }
 
    inline friend std::vector<MX> difference(const std::vector<MX>& a, const std::vector<MX>& b) {
      return MX::difference(a, b);
    }
 
#endif // SWIG
 
    MX attachAssert(const MX& y, const std::string& fail_message="") const;
 
    MX monitor(const std::string& comment) const;
 
    MX dump(const std::string& base_filename, const Dict& opts=Dict()) const;
 
    void reset_dump_count();
 
    MX T() const;
 
    Matrix<casadi_int> mapping() const;
 
    static void set_max_depth(casadi_int eq_depth=1);
 
    static casadi_int get_max_depth();
 
    static bool test_cast(const SharedObjectInternal* ptr);
 
    static std::vector<MX> get_input(const Function& f);
 
    static std::vector<MX> get_free(const Function& f);
 
    typedef std::map<std::string, MX> MXDict;
 
    void eval_mx(const std::vector<MX>& arg, std::vector<MX>& SWIG_OUTPUT(res),
        const std::vector<bool>& unique=std::vector<bool>()) const;
 
#ifndef SWIG
 
    void ad_forward(const std::vector<std::vector<MX> >& fseed,
                    std::vector<std::vector<MX> >& fsens) const;
    void ad_reverse(const std::vector<std::vector<MX> >& aseed,
                    std::vector<std::vector<MX> >& asens) const;
 
    MX(const Sparsity& sp, double val, bool dummy);
 
    // Create matrix symbolic primitive
    static MX _sym(const std::string& name, const Sparsity& sp);
 
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    static std::mutex& get_mutex_temp() { return mutex_temp; }
    static std::mutex mutex_temp;
#endif //CASADI_WITH_THREADSAFE_SYMBOLICS
  private:
 
    MX(MXNode* node, bool dummy1, bool dummy2, bool dummy3, bool dummy4);
 
    // Depth when checking equalities
    static casadi_int eq_depth_;
 
#endif // SWIG
  };
 
 
  typedef std::vector<MX> MXVector;
  typedef std::initializer_list<MX> MXIList;
  typedef std::vector<MXVector> MXVectorVector;
  typedef std::map<std::string, MX> MXDict;
 
  inline MX kron_contract(const MX& m, const MX& x, bool inner) {
    return MX::kron_contract(m, x, inner);
  }
 
#ifndef SWIG
  CASADI_EXPORT std::string export_graph(const MX& expression, const Dict& opts=Dict());
  CASADI_EXPORT std::string export_graph(const std::vector<MX>& expressions,
    const Dict& opts=Dict());
  CASADI_EXPORT void export_graph(const MX& expression, const std::string& fname,
    const Dict& opts=Dict());
  CASADI_EXPORT void export_graph(const std::vector<MX>& expressions, const std::string& fname,
    const Dict& opts=Dict());
#endif // SWIG
 
} // namespace casadi
 
#endif // CASADI_MX_HPP