mx_node.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_NODE_HPP
#define CASADI_MX_NODE_HPP
 
#include "mx.hpp"
#include "shared_object.hpp"
#include "sx_elem.hpp"
#include "calculus.hpp"
#include "code_generator.hpp"
#include "linsol.hpp"
#include <vector>
#include <stack>
#include <array>
 
namespace casadi {
 
  class SerializingStream;
  class DeserializingStream;
 
  class CASADI_EXPORT MXNode : public SharedObjectInternal {
    friend class MX;
 
  public:
    MXNode();
 
    ~MXNode() override=0;
 
    virtual bool __nonzero__() const;
 
    virtual bool is_zero() const { return false;}
 
    virtual bool is_one() const { return false;}
 
    virtual bool is_minus_one() const { return false;}
 
    virtual bool is_half() const { return false;}
 
    virtual bool is_inf() const { return false;}
 
    virtual bool is_minus_inf() const { return false;}
 
    virtual bool is_integer() const { return false;}
 
    virtual bool is_nonnegative() const { return false;}
 
    virtual bool is_value(double val) const { return false;}
 
    virtual bool is_eye() const { return false;}
 
    virtual bool is_unary() const { return false;}
 
    virtual bool is_binary() const { return false;}
 
    void can_inline(std::map<const MXNode*, casadi_int>& nodeind) const;
 
    std::string print_compact(std::map<const MXNode*, casadi_int>& nodeind,
                             std::vector<std::string>& intermed) const;
 
    virtual std::string disp(const std::vector<std::string>& arg) const = 0;
 
    virtual void add_dependency(CodeGenerator& g) const {}
 
    virtual bool has_refcount() const { return false;}
 
    virtual void codegen_incref(CodeGenerator& g, std::set<void*>& added) const {}
 
    virtual void codegen_decref(CodeGenerator& g, std::set<void*>& added) const {}
 
    virtual void generate(CodeGenerator& g,
                          const std::vector<casadi_int>& arg,
                          const std::vector<casadi_int>& res,
                          const std::vector<bool>& arg_is_ref,
                          std::vector<bool>& res_is_ref) const;
 
    void generate_copy(CodeGenerator& g,
                          const std::vector<casadi_int>& arg,
                          const std::vector<casadi_int>& res,
                          const std::vector<bool>& arg_is_ref,
                          std::vector<bool>& res_is_ref,
                          casadi_int i) const;
 
    virtual int eval(const double** arg, double** res, casadi_int* iw, double* w) const;
 
    virtual int eval_sx(const SXElem** arg, SXElem** res, casadi_int* iw, SXElem* w) const;
 
    virtual void eval_mx(const std::vector<MX>& arg, std::vector<MX>& res,
        const std::vector<bool>& unique={}) const;
 
    virtual void eval_linear(const std::vector<std::array<MX, 3> >& arg,
                        std::vector<std::array<MX, 3> >& res) const;
 
    void eval_linear_unary(const std::vector<std::array<MX, 3> >& arg,
                        std::vector<std::array<MX, 3> >& res) const;
 
    void eval_linear_rearrange(const std::vector<std::array<MX, 3> >& arg,
        std::vector<std::array<MX, 3> >& res) const;
 
    virtual void ad_forward(const std::vector<std::vector<MX> >& fseed,
                         std::vector<std::vector<MX> >& fsens) const;
 
    virtual void ad_reverse(const std::vector<std::vector<MX> >& aseed,
                         std::vector<std::vector<MX> >& asens) const;
 
    virtual int sp_forward(const bvec_t** arg, bvec_t** res, casadi_int* iw, bvec_t* w) const;
 
    virtual int eval_activity(const bvec_t** arg, bvec_t** res, casadi_int* iw, bvec_t* w) const {
      for (casadi_int k=0; k<nout(); ++k) {
        bvec_t* v = res[k];
        if (!v) continue;
        for (casadi_int i=0; i<sparsity(k).nnz(); ++i) v[i] = ~static_cast<bvec_t>(0);
      }
      return 0;
    }
 
    virtual int sp_reverse(bvec_t** arg, bvec_t** res, casadi_int* iw, bvec_t* w) const;
 
    virtual const std::string& name() const;
 
    std::string class_name() const override;
 
    void disp(std::ostream& stream, bool more) const override;
 
    virtual bool is_valid_input() const { return false;}
 
    virtual casadi_int n_primitives() const;
 
    virtual void primitives(std::vector<MX>::iterator& it) const;
 
 
    virtual void split_primitives(const MX& x, std::vector<MX>::iterator& it) const;
    virtual void split_primitives(const SX& x, std::vector<SX>::iterator& it) const;
    virtual void split_primitives(const DM& x, std::vector<DM>::iterator& it) const;
 
    template<typename T>
    T join_primitives_gen(typename std::vector<T>::const_iterator& it) const;
 
 
    virtual MX join_primitives(std::vector<MX>::const_iterator& it) const;
    virtual SX join_primitives(std::vector<SX>::const_iterator& it) const;
    virtual DM join_primitives(std::vector<DM>::const_iterator& it) const;
 
    virtual bool has_duplicates() const;
 
    virtual void reset_input() const;
 
    virtual bool is_output() const {return false;}
 
    virtual bool has_output() const {return false;}
 
    virtual casadi_int which_output() const;
 
    virtual const Function& which_function() const;
 
    virtual casadi_int op() const = 0;
 
    virtual Dict info() const;
 
    void serialize(SerializingStream& s) const;
 
    virtual void serialize_body(SerializingStream& s) const;
 
    virtual void serialize_type(SerializingStream& s) const;
 
    static MXNode* deserialize(DeserializingStream& s);
 
    static bool is_equal(const MXNode* x, const MXNode* y, casadi_int depth);
    virtual bool is_equal(const MXNode* node, casadi_int depth) const { return false;}
 
    inline static bool maxDepth() { return MX::get_max_depth();}
 
    bool sameOpAndDeps(const MXNode* node, casadi_int depth) const;
 
    const MX& dep(casadi_int ind=0) const { return dep_.at(ind);}
 
    casadi_int n_dep() const;
 
    virtual casadi_int nout() const { return 1;}
 
    virtual MX get_output(casadi_int oind) const;
 
    const Sparsity& sparsity() const { return sparsity_;}
 
    virtual const Sparsity& sparsity(casadi_int oind) const;
 
    template<class T>
    bool matches_sparsity(const std::vector<T>& arg) const {
        for (casadi_int i=0;i<dep_.size();++i) {
            if (dep_[i].sparsity()!=arg[i].sparsity()) {
                return false;
            }
        }
        return true;
    }
 
    casadi_int numel() const { return sparsity().numel(); }
    casadi_int nnz(casadi_int i=0) const { return sparsity(i).nnz(); }
    casadi_int size1() const { return sparsity().size1(); }
    casadi_int size2() const { return sparsity().size2(); }
    std::pair<casadi_int, casadi_int> size() const { return sparsity().size();}
 
    // Get IO index
    virtual casadi_int ind() const;
 
    // Get IO segment
    virtual casadi_int segment() const;
 
    // Get IO offset
    virtual casadi_int offset() const;
 
    void set_sparsity(const Sparsity& sparsity);
 
    virtual size_t sz_arg() const { return n_dep();}
 
    virtual size_t sz_res() const { return nout();}
 
    virtual size_t sz_iw() const { return 0;}
 
    virtual size_t sz_w() const { return 0;}
 
    virtual size_t codegen_sz_w() const { return sz_w();}
 
    void set_dep(const MX& dep);
 
    void set_dep(const MX& dep1, const MX& dep2);
 
    void set_dep(const MX& dep1, const MX& dep2, const MX& dep3);
 
    void set_dep(const std::vector<MX>& dep);
 
    void check_dep() const;
 
    inline static MX to_matrix(const MX& x, const Sparsity& sp) {
      if (x.size()==sp.size()) {
        return x;
      } else {
        return MX(sp, x);
      }
    }
 
    virtual double to_double() const;
 
    virtual casadi_int to_int() const;
 
    virtual DM get_DM() const;
 
    virtual casadi_int n_inplace() const { return 0;}
 
    virtual Matrix<casadi_int> mapping() const;
 
    virtual MX get_horzcat(const std::vector<MX>& x) const;
 
    virtual std::vector<MX> get_horzsplit(const std::vector<casadi_int>& output_offset) const;
 
    virtual MX get_repmat(casadi_int m, casadi_int n) const;
 
    virtual MX get_repsum(casadi_int m, casadi_int n) const;
 
    virtual MX get_kron(const MX& b) const;
 
    virtual MX get_kron_contract(const MX& x, bool inner) const;
 
    virtual MX get_vertcat(const std::vector<MX>& x) const;
 
    virtual std::vector<MX> get_vertsplit(const std::vector<casadi_int>& output_offset) const;
 
    virtual MX get_diagcat(const std::vector<MX>& x) const;
 
    virtual std::vector<MX> get_diagsplit(const std::vector<casadi_int>& offset1,
                                         const std::vector<casadi_int>& offset2) const;
 
    virtual MX get_transpose() const;
 
    virtual MX get_reshape(const Sparsity& sp) const;
 
    virtual MX get_sparsity_cast(const Sparsity& sp) const;
 
    virtual MX get_mac(const MX& y, const MX& z,
                       const std::string& blas = "reference") const;
 
    virtual MX get_einstein(const MX& A, const MX& B,
      const std::vector<casadi_int>& dim_c, const std::vector<casadi_int>& dim_a,
      const std::vector<casadi_int>& dim_b,
      const std::vector<casadi_int>& c, const std::vector<casadi_int>& a,
      const std::vector<casadi_int>& b) const;
 
    virtual MX get_bilin(const MX& x, const MX& y) const;
 
    virtual MX get_rank1(const MX& alpha, const MX& x, const MX& y) const;
 
    virtual MX get_logsumexp() const;
 
    virtual MX get_solve(const MX& r, bool tr, const Linsol& linear_solver) const;
 
    virtual MX get_solve_triu(const MX& r, bool tr) const;
 
    virtual MX get_solve_tril(const MX& r, bool tr) const;
 
    virtual MX get_solve_triu_unity(const MX& r, bool tr) const;
 
    virtual MX get_solve_tril_unity(const MX& r, bool tr) const;
 
    virtual MX get_nzref(const Sparsity& sp, const std::vector<casadi_int>& nz,
        bool unique=false) const;
 
    virtual MX get_nz_ref(const MX& nz) const;
 
    virtual MX get_nz_ref(const MX& inner, const Slice& outer) const;
 
    virtual MX get_nz_ref(const Slice& inner, const MX& outer) const;
 
    virtual MX get_nz_ref(const MX& inner, const MX& outer) const;
 
    virtual MX get_nzassign(const MX& y, const std::vector<casadi_int>& nz) const;
 
    virtual MX get_nzadd(const MX& y, const std::vector<casadi_int>& nz) const;
 
    virtual MX get_nzassign(const MX& y, const MX& nz) const;
 
    virtual MX get_nzassign(const MX& y, const MX& inner, const Slice& outer) const;
 
    virtual MX get_nzassign(const MX& y, const Slice& inner, const MX& outer) const;
 
    virtual MX get_nzassign(const MX& y, const MX& inner, const MX& outer) const;
 
    virtual MX get_nzadd(const MX& y, const MX& nz) const;
 
    virtual MX get_nzadd(const MX& y, const MX& inner, const Slice& outer) const;
 
    virtual MX get_nzadd(const MX& y, const Slice& inner, const MX& outer) const;
 
    virtual MX get_nzadd(const MX& y, const MX& inner, const MX& outer) const;
 
    virtual MX get_subref(const Slice& i, const Slice& j) const;
 
    virtual MX get_subassign(const MX& y, const Slice& i, const Slice& j) const;
 
    virtual MX get_project(const Sparsity& sp, bool unique=false) const;
 
    virtual MX get_unary(casadi_int op, bool unique=false) const;
 
    MX get_binary(casadi_int op, const MX& y, bool unique_x=false, bool unique_y=false) const;
 
    virtual MX _get_binary(casadi_int op, const MX& y, bool scX, bool scY,
        bool unique_x=false, bool unique_y=false) const;
 
    virtual MX get_det(const Linsol& linear_solver) const;
 
    virtual MX get_inv() const;
 
    virtual MX get_dot(const MX& y) const;
 
    virtual MX get_norm_fro() const;
 
    virtual MX get_norm_2() const;
 
    virtual MX get_norm_inf() const;
 
    virtual MX get_norm_1() const;
 
    virtual MX get_mmin() const;
 
    virtual MX get_mmax() const;
 
    MX get_assert(const MX& y, const std::string& fail_message) const;
 
    MX get_monitor(const std::string& comment) const;
 
    MX get_dump(const std::string& base_filename, const Dict& opts) const;
 
    MX get_find() const;
 
    MX get_low(const MX& v, const Dict& options) const;
 
    MX get_bspline(const std::vector<double>& knots,
            const std::vector<casadi_int>& offset,
            const std::vector<double>& coeffs,
            const std::vector<casadi_int>& degree,
            casadi_int m,
            const std::vector<casadi_int>& lookup_mode) const;
    MX get_bspline(const MX& coeffs, const std::vector<double>& knots,
            const std::vector<casadi_int>& offset,
            const std::vector<casadi_int>& degree,
            casadi_int m,
            const std::vector<casadi_int>& lookup_mode) const;
 
    MX get_convexify(const Dict& opts) const;
 
    mutable casadi_int temp;
 
    std::vector<MX> dep_;
 
    Sparsity sparsity_;
 
    static void copy_fwd(const bvec_t* arg, bvec_t* res, casadi_int len);
 
    static void copy_rev(bvec_t* arg, bvec_t* res, casadi_int len);
 
    static std::map<casadi_int, MXNode* (*)(DeserializingStream&)> deserialize_map;
 
  protected:
    explicit MXNode(DeserializingStream& s);
  };
 
} // namespace casadi
 
#endif // CASADI_MX_NODE_HPP