text: // This file is part of Eigen, a lightweight C++ template library
  // for linear algebra.
  //
  // Copyright (C) 2008-2010 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_UNARY_OP_H
  #define EIGEN_CWISE_UNARY_OP_H
  
  namespace Eigen {
  
  /** \class CwiseUnaryOp
    * \ingroup Core_Module
    *
    * \brief Generic expression where a coefficient-wise unary operator is applied to an expression
    *
    * \param UnaryOp template functor implementing the operator
    * \param XprType the type of the expression to which we are applying the unary operator
    *
    * This class represents an expression where a unary operator is applied to an expression.
    * It is the return type of all operations taking exactly 1 input expression, regardless of the
    * presence of other inputs such as scalars. For example, the operator* in the expression 3*matrix
    * is considered unary, because only the right-hand side is an expression, and its
    * return type is a specialization of CwiseUnaryOp.
    *
    * Most of the time, this is the only way that it is used, so you typically don't have to name
    * CwiseUnaryOp types explicitly.
    *
    * \sa MatrixBase::unaryExpr(const CustomUnaryOp &) const, class CwiseBinaryOp, class CwiseNullaryOp
    */
  
  namespace internal {
  template<typename UnaryOp, typename XprType>
  struct traits<CwiseUnaryOp < UnaryOp, XprType> >
  : traits<XprType> {
  typedef typename result_of<
      UnaryOp(typename XprType::Scalar)
  >::type Scalar;
  typedef typename XprType::Nested XprTypeNested;
  typedef typename remove_reference<XprTypeNested>::type _XprTypeNested;
  enum {
    Flags = _XprTypeNested::Flags & (
        HereditaryBits | LinearAccessBit | AlignedBit
            | (functor_traits<UnaryOp>::PacketAccess ? PacketAccessBit : 0)),
    CoeffReadCost = EIGEN_ADD_COST(_XprTypeNested::CoeffReadCost, functor_traits<UnaryOp>::Cost)
  };
  };
  }
  
  template<typename UnaryOp, typename XprType, typename StorageKind>
  class CwiseUnaryOpImpl;
  
  template<typename UnaryOp, typename XprType>
  class CwiseUnaryOp : internal::no_assignment_operator,
                       public CwiseUnaryOpImpl<UnaryOp, XprType, typename internal::traits<XprType>::StorageKind> {
   public:
  
    typedef typename CwiseUnaryOpImpl<UnaryOp, XprType, typename internal::traits<XprType>::StorageKind>::Base Base;
    EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryOp)
  
    inline CwiseUnaryOp(const XprType &xpr, const UnaryOp &func = UnaryOp())
        : m_xpr(xpr), m_functor(func) {}
  
    EIGEN_STRONG_INLINE Index rows() const { return m_xpr.rows(); }
    EIGEN_STRONG_INLINE Index cols() const { return m_xpr.cols(); }
  
    /** \returns the functor representing the unary operation */
    const UnaryOp &functor() const { return m_functor; }
  
    /** \returns the nested expression */
    const typename internal::remove_all<typename XprType::Nested>::type &
    nestedExpression() const { return m_xpr; }
  
    /** \returns the nested expression */
    typename internal::remove_all<typename XprType::Nested>::type &
    nestedExpression() { return m_xpr.const_cast_derived(); }
  
   protected:
    typename XprType::Nested m_xpr;
    const UnaryOp m_functor;
  };
  
  // This is the generic implementation for dense storage.
  // It can be used for any expression types implementing the dense concept.
  template<typename UnaryOp, typename XprType>
  class CwiseUnaryOpImpl<UnaryOp, XprType, Dense>
      : public internal::dense_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type {
   public:
  
    typedef CwiseUnaryOp<UnaryOp, XprType> Derived;
    typedef typename internal::dense_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type Base;
    EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
  
    EIGEN_STRONG_INLINE const Scalar coeff(Index rowId, Index colId) const {
      return derived().functor()(derived().nestedExpression().coeff(rowId, colId));
    }
  
    template<int LoadMode>
    EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const {
      return derived().functor().packetOp(derived().nestedExpression().template packet<LoadMode>(rowId, colId));
    }
  
    EIGEN_STRONG_INLINE const Scalar coeff(Index index) const {
      return derived().functor()(derived().nestedExpression().coeff(index));
    }
  
    template<int LoadMode>
    EIGEN_STRONG_INLINE PacketScalar packet(Index index) const {
      return derived().functor().packetOp(derived().nestedExpression().template packet<LoadMode>(index));
    }
  };
  
  } // end namespace Eigen
  
  #endif // EIGEN_CWISE_UNARY_OP_H
  