text: /*
   *    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) 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_DOT_HPP
  #define CASADI_DOT_HPP
  
  #include "mx_node.hpp"
  #include <map>
  #include <stack>
  
  /// \cond INTERNAL
  
  namespace casadi {
    /** \brief Matrix dot
        \author Joel Andersson
        \date 2013
    */
    class CASADI_EXPORT Dot : public MXNode {
    public:
  
      /// Constructor
      Dot(const MX& x, const MX& y);
  
      /// Destructor
      ~Dot() override {}
  
      /// Evaluate the function (template)
      template<typename T>
      int eval_gen(const T** arg, T** res, casadi_int* iw, T* w) const;
  
      /// Evaluate the function numerically
      int eval(const double** arg, double** res, casadi_int* iw, double* w) const override;
  
      /// Evaluate the function symbolically (SX)
      int eval_sx(const SXElem** arg, SXElem** res, casadi_int* iw, SXElem* w) const override;
  
      /** \brief  Propagate sparsity forward */
      int sp_forward(const bvec_t** arg, bvec_t** res, casadi_int* iw, bvec_t* w) const override;
  
      /** \brief  Propagate sparsity backwards */
      int sp_reverse(bvec_t** arg, bvec_t** res, casadi_int* iw, bvec_t* w) const override;
  
      /** \brief  Evaluate symbolically (MX) */
      void eval_mx(const std::vector<MX>& arg, std::vector<MX>& res) const override;
  
      /** \brief Calculate forward mode directional derivatives */
      void ad_forward(const std::vector<std::vector<MX> >& fseed,
                           std::vector<std::vector<MX> >& fsens) const override;
  
      /** \brief Calculate reverse mode directional derivatives */
      void ad_reverse(const std::vector<std::vector<MX> >& aseed,
                           std::vector<std::vector<MX> >& asens) const override;
  
      /** \brief Generate code for the operation */
      void generate(CodeGenerator& g,
                    const std::vector<casadi_int>& arg,
                    const std::vector<casadi_int>& res) const override;
  
      /** \brief  Print expression */
      std::string disp(const std::vector<std::string>& arg) const override;
  
      /** \brief Get the operation */
      casadi_int op() const override { return OP_DOT;}
  
      /** \brief Deserialize without type information */
      static MXNode* deserialize(DeserializingStream& s) { return new Dot(s); }
  
    protected:
      /** \brief Deserializing constructor */
      explicit Dot(DeserializingStream& s) : MXNode(s) {}
  
    };
  
  
  } // namespace casadi
  /// \endcond
  
  #endif // CASADI_DOT_HPP
  