text: // This file is part of Eigen, a lightweight C++ template library
  // for linear algebra.
  //
  // Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
  // Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
  //
  // This Source Code Form is subject to the terms of the Mozilla
  // Public License v. 2.0. If a copy of the MPL was not distributed
  // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
  
  #ifndef EIGEN_CWISE_BINARY_OP_H
  #define EIGEN_CWISE_BINARY_OP_H
  
  namespace Eigen {
  
  /** \class CwiseBinaryOp
    * \ingroup Core_Module
    *
    * \brief Generic expression where a coefficient-wise binary operator is applied to two expressions
    *
    * \param BinaryOp template functor implementing the operator
    * \param Lhs the type of the left-hand side
    * \param Rhs the type of the right-hand side
    *
    * This class represents an expression  where a coefficient-wise binary operator is applied to two expressions.
    * It is the return type of binary operators, by which we mean only those binary operators where
    * both the left-hand side and the right-hand side are Eigen expressions.
    * For example, the return type of matrix1+matrix2 is a CwiseBinaryOp.
    *
    * Most of the time, this is the only way that it is used, so you typically don't have to name
    * CwiseBinaryOp types explicitly.
    *
    * \sa MatrixBase::binaryExpr(const MatrixBase<OtherDerived> &,const CustomBinaryOp &) const, class CwiseUnaryOp, class CwiseNullaryOp
    */
  
  namespace internal {
  template<typename BinaryOp, typename Lhs, typename Rhs>
  struct traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
  {
    // we must not inherit from traits<Lhs> since it has
    // the potential to cause problems with MSVC
    typedef typename remove_all<Lhs>::type Ancestor;
    typedef typename traits<Ancestor>::XprKind XprKind;
    enum {
      RowsAtCompileTime = traits<Ancestor>::RowsAtCompileTime,
      ColsAtCompileTime = traits<Ancestor>::ColsAtCompileTime,
      MaxRowsAtCompileTime = traits<Ancestor>::MaxRowsAtCompileTime,
      MaxColsAtCompileTime = traits<Ancestor>::MaxColsAtCompileTime
    };
  
    // even though we require Lhs and Rhs to have the same scalar type (see CwiseBinaryOp constructor),
    // we still want to handle the case when the result type is different.
    typedef typename result_of<
                       BinaryOp(
                         typename Lhs::Scalar,
                         typename Rhs::Scalar
                       )
                     >::type Scalar;
    typedef typename promote_storage_type<typename traits<Lhs>::StorageKind,
                                             typename traits<Rhs>::StorageKind>::ret StorageKind;
    typedef typename promote_index_type<typename traits<Lhs>::Index,
                                           typename traits<Rhs>::Index>::type Index;
    typedef typename Lhs::Nested LhsNested;
    typedef typename Rhs::Nested RhsNested;
    typedef typename remove_reference<LhsNested>::type _LhsNested;
    typedef typename remove_reference<RhsNested>::type _RhsNested;
    enum {
      LhsCoeffReadCost = _LhsNested::CoeffReadCost,
      RhsCoeffReadCost = _RhsNested::CoeffReadCost,
      LhsFlags = _LhsNested::Flags,
      RhsFlags = _RhsNested::Flags,
      SameType = is_same<typename _LhsNested::Scalar,typename _RhsNested::Scalar>::value,
      StorageOrdersAgree = (int(Lhs::Flags)&RowMajorBit)==(int(Rhs::Flags)&RowMajorBit),
      Flags0 = (int(LhsFlags) | int(RhsFlags)) & (
          HereditaryBits
        | (int(LhsFlags) & int(RhsFlags) &
             ( AlignedBit
             | (StorageOrdersAgree ? LinearAccessBit : 0)
             | (functor_traits<BinaryOp>::PacketAccess && StorageOrdersAgree && SameType ? PacketAccessBit : 0)
             )
          )
       ),
      Flags = (Flags0 & ~RowMajorBit) | (LhsFlags & RowMajorBit),
      CoeffReadCost = LhsCoeffReadCost + RhsCoeffReadCost + functor_traits<BinaryOp>::Cost
    };
  };
  } // end namespace internal
  
  // we require Lhs and Rhs to have the same scalar type. Currently there is no example of a binary functor
  // that would take two operands of different types. If there were such an example, then this check should be
  // moved to the BinaryOp functors, on a per-case basis. This would however require a change in the BinaryOp functors, as
  // currently they take only one typename Scalar template parameter.
  // It is tempting to always allow mixing different types but remember that this is often impossible in the vectorized paths.
  // So allowing mixing different types gives very unexpected errors when enabling vectorization, when the user tries to
  // add together a float matrix and a double matrix.
  #define EIGEN_CHECK_BINARY_COMPATIBILIY(BINOP,LHS,RHS) \
    EIGEN_STATIC_ASSERT((internal::functor_is_product_like<BINOP>::ret \
                          ? int(internal::scalar_product_traits<LHS, RHS>::Defined) \
                          : int(internal::is_same<LHS, RHS>::value)), \
      YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
  
  template<typename BinaryOp, typename Lhs, typename Rhs, typename StorageKind>
  class CwiseBinaryOpImpl;
  
  template<typename BinaryOp, typename Lhs, typename Rhs>
  class CwiseBinaryOp : internal::no_assignment_operator,
    public CwiseBinaryOpImpl<
            BinaryOp, Lhs, Rhs,
            typename internal::promote_storage_type<typename internal::traits<Lhs>::StorageKind,
                                             typename internal::traits<Rhs>::StorageKind>::ret>
  {
    public:
  
      typedef typename CwiseBinaryOpImpl<
          BinaryOp, Lhs, Rhs,
          typename internal::promote_storage_type<typename internal::traits<Lhs>::StorageKind,
                                           typename internal::traits<Rhs>::StorageKind>::ret>::Base Base;
      EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseBinaryOp)
  
      typedef typename internal::nested<Lhs>::type LhsNested;
      typedef typename internal::nested<Rhs>::type RhsNested;
      typedef typename internal::remove_reference<LhsNested>::type _LhsNested;
      typedef typename internal::remove_reference<RhsNested>::type _RhsNested;
  
      EIGEN_STRONG_INLINE CwiseBinaryOp(const Lhs& aLhs, const Rhs& aRhs, const BinaryOp& func = BinaryOp())
        : m_lhs(aLhs), m_rhs(aRhs), m_functor(func)
      {
        EIGEN_CHECK_BINARY_COMPATIBILIY(BinaryOp,typename Lhs::Scalar,typename Rhs::Scalar);
        // require the sizes to match
        EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Lhs, Rhs)
        eigen_assert(aLhs.rows() == aRhs.rows() && aLhs.cols() == aRhs.cols());
      }
  
      EIGEN_STRONG_INLINE Index rows() const {
        // return the fixed size type if available to enable compile time optimizations
        if (internal::traits<typename internal::remove_all<LhsNested>::type>::RowsAtCompileTime==Dynamic)
          return m_rhs.rows();
        else
          return m_lhs.rows();
      }
      EIGEN_STRONG_INLINE Index cols() const {
        // return the fixed size type if available to enable compile time optimizations
        if (internal::traits<typename internal::remove_all<LhsNested>::type>::ColsAtCompileTime==Dynamic)
          return m_rhs.cols();
        else
          return m_lhs.cols();
      }
  
      /** \returns the left hand side nested expression */
      const _LhsNested& lhs() const { return m_lhs; }
      /** \returns the right hand side nested expression */
      const _RhsNested& rhs() const { return m_rhs; }
      /** \returns the functor representing the binary operation */
      const BinaryOp& functor() const { return m_functor; }
  
    protected:
      LhsNested m_lhs;
      RhsNested m_rhs;
      const BinaryOp m_functor;
  };
  
  template<typename BinaryOp, typename Lhs, typename Rhs>
  class CwiseBinaryOpImpl<BinaryOp, Lhs, Rhs, Dense>
    : public internal::dense_xpr_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >::type
  {
      typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> Derived;
    public:
  
      typedef typename internal::dense_xpr_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >::type Base;
      EIGEN_DENSE_PUBLIC_INTERFACE( Derived )
  
      EIGEN_STRONG_INLINE const Scalar coeff(Index rowId, Index colId) const
      {
        return derived().functor()(derived().lhs().coeff(rowId, colId),
                                   derived().rhs().coeff(rowId, colId));
      }
  
      template<int LoadMode>
      EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const
      {
        return derived().functor().packetOp(derived().lhs().template packet<LoadMode>(rowId, colId),
                                            derived().rhs().template packet<LoadMode>(rowId, colId));
      }
  
      EIGEN_STRONG_INLINE const Scalar coeff(Index index) const
      {
        return derived().functor()(derived().lhs().coeff(index),
                                   derived().rhs().coeff(index));
      }
  
      template<int LoadMode>
      EIGEN_STRONG_INLINE PacketScalar packet(Index index) const
      {
        return derived().functor().packetOp(derived().lhs().template packet<LoadMode>(index),
                                            derived().rhs().template packet<LoadMode>(index));
      }
  };
  
  /** replaces \c *this by \c *this - \a other.
    *
    * \returns a reference to \c *this
    */
  template<typename Derived>
  template<typename OtherDerived>
  EIGEN_STRONG_INLINE Derived &
  MatrixBase<Derived>::operator-=(const MatrixBase<OtherDerived> &other)
  {
    SelfCwiseBinaryOp<internal::scalar_difference_op<Scalar>, Derived, OtherDerived> tmp(derived());
    tmp = other.derived();
    return derived();
  }
  
  /** replaces \c *this by \c *this + \a other.
    *
    * \returns a reference to \c *this
    */
  template<typename Derived>
  template<typename OtherDerived>
  EIGEN_STRONG_INLINE Derived &
  MatrixBase<Derived>::operator+=(const MatrixBase<OtherDerived>& other)
  {
    SelfCwiseBinaryOp<internal::scalar_sum_op<Scalar>, Derived, OtherDerived> tmp(derived());
    tmp = other.derived();
    return derived();
  }
  
  } // end namespace Eigen
  
  #endif // EIGEN_CWISE_BINARY_OP_H
  