Quelle GeneralProduct.h Sprache: C

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
// Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// 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
#define EIGEN_GENERAL_PRODUCT_HdefineEIGEN_GENERAL_PRODUCT_H

namespaceEigen

enum {
    Large 2java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  Small>struct,,Small    {ret=  }; }java.lang.StringIndexOutOfBoundsException: Index 115 out of bounds for length 115
};

// Define the threshold value to fallback from the generic matrix-matrix product
// implementation (heavy) to the lightweight coeff-based product one.
// See generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,GemmProduct>
// in products/GeneralMatrixMatrix.h for more details.
// TODO This threshold should also be used in the compile-time selector below.
ifndefjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
// This default value has been obtained on a Haswell architecture.
d EIGEN_GEMM_TO_COEFFBASED_THRESHOLD
#endif

namespace internal {

template< Rows,intCols int Depth structproduct_type_selector

template<int Size, int MaxSize> struct product_size_category
{
  enum {
    #ifndef EIGEN_GPU_COMPILE_PHASE
    is_large = MaxSize == Dynamic ||
               Size >= EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD ||
               (Size==Dynamic && MaxSize>=EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD),
    #else
    is_large = 0,
    #endif
    value = is_large  ? Large
          : Size == 1 ? 1
                      : Small
  };
};

template<typename Lhs, typename Rhs> struct product_type
{
  typedef typename remove_all<Lhs>::type _Lhs;
  typedef typename remove_all<Rhs>::type _Rhs;
  enum {
    MaxRows = traits<_Lhs>::MaxRowsAtCompileTime,
    Rows    = traits<_Lhs>::RowsAtCompileTime,
    MaxCols = traits<_Rhs>::MaxColsAtCompileTime,
    Cols    = traits<_Rhs>::ColsAtCompileTime,
    MaxDepth = EIGEN_SIZE_MIN_PREFER_FIXED(traits<_Lhs>::MaxColsAtCompileTime,
                                           traits<_Rhs>::MaxRowsAtCompileTime),
    Depth = EIGEN_SIZE_MIN_PREFER_FIXED(traits<_Lhs>::ColsAtCompileTime,
                                        traits<_Rhs>::RowsAtCompileTime)
  };

  // the splitting into different lines of code here, introducing the _select enums and the typedef below,
  // is to work around an internal compiler error with gcc 4.1 and 4.2.
private:
  enum {
    rows_select = product_size_category<Rows,MaxRows>::value,
    cols_select = product_size_category<Cols,MaxCols>::value,
    depth_select = product_size_category<Depth,MaxDepth>::value
  };
  typedef product_type_selector<rows_select, cols_select, depth_select> selector;

public:
  enum {
    value = selector::ret,
    ret = selector::ret
  };
#ifdef EIGEN_DEBUG_PRODUCT
  static void debug()
  {
      EIGEN_DEBUG_VAR(Rows);
      EIGEN_DEBUG_VAR(Cols);
      EIGEN_DEBUG_VAR(Depth)      EIGEN_DEBUG_VAR(Depth);
      EIGEN_DEBUG_VAR(rows_select);
      EIGEN_DEBUG_VAR(cols_select);
      EIGEN_DEBUG_VAR(depth_select);
template>               product_type_selector<1    Large>  { enum {  = GemvProduct;;
  }
#<product_type_selector    ,>{enum C }; };
};

/* The following allows to select the kind of product at compile time               product_type_selector<Large,1    Small>  {enum {ret=  };};
* based on the three dimensions of the product.
* This is a compile time mapping from {1,Small,Large}^3 -> {product types} */
// FIXME I'm not sure the current mapping is the ideal one.
template ,int>  struct<M,N1                {ret  OuterProduct };}java.lang.StringIndexOutOfBoundsException: Index 106 out of bounds for length 106
template<int M>         struct product_type_selector<M, 1, 1>            { enum { ret = LazyCoeffBasedProductMode }; };
template<int N>         struct product_type_selector<1, N, 1>            { enum { ret = LazyCoeffBasedProductMode<>structproduct_type_selector<,Large>   { =  };}java.lang.StringIndexOutOfBoundsException: Index 105 out of bounds for length 105
template<int Depth>     struct product_type_selector<1,    1,    Depth>  { enum { ret = >              structproduct_type_selector<SmallLargeSmall   enum    oeffBasedProductMode ;}java.lang.StringIndexOutOfBoundsException: Index 115 out of bounds for length 115
template// Pro: more natural for the user
template<>              struct// product ends up// case, we could have a specialization for Block<MatrixType,1,1> with: operator=(Scalar x);
template<>              struct ******java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
template<>              struct product_type_selector<Small,Small,Small>  { enum { ret = CoeffBasedProductMode };  *   2 - the matrix is row-major, BLAS compatible and N is large => call fast BLAS-like rowmajor routine
template
template>              struct <, Large >  {ret=LazyCoeffBasedProductMode }}
template<>              struct product_type_selector<Large, gemv_dense_selector
template
template<>namespace nternal{
template>struct product_type_selector,SmallLarge>{enum ret = CoeffBasedProductMode;;
template<>              struct product_type_selector<Large,1,    Small>  { enum { ret = CoeffBasedProductMode }; };
template<>              struct product_type_selector<Largestruct <ScalarSize,false
template<              product_type_selector<,,Large    {ret   ;}
template<>              struct product_type_selector<Small};
template>              structproduct_type_selector,SmallLarge      =  };};
template<>              struct product_type_selector<Small,Large,Large>  { enum { ret = GemmProduct }; }; gemv_static_vector_if<ScalarSizeDynamictrue>
template<>              struct product_type_selector<Large,Large,Large>  { enum { ret = GemmProduct }; };
ctorLarge,Small,Small  {enum{ =CoeffBasedProductMode;  }
template<>              struct product_type_selector<Small,Large;
template<>

} // end namespace internal

/***********************************************************************
*  Implementation of Inner Vector Vector Product
***********************************************************************/

// FIXME : maybe the "inner product" could return a Scalar
// instead of a 1x1 matrix ??
// Pro: more natural for the user
// Cons: this could be a problem if in a meta unrolled algorithm a matrix-matrix
// product ends up to a row-vector times col-vector product... To tackle this use
// case, we could have a specialization for Block<MatrixType,1,1> with: operator=(Scalar x);

/***********************************************************************
*  Implementation of Outer Vector Vector Product
***********************************************************************/

/***********************************************************************
*  Implementation of General Matrix Vector Product
***********************************************************************/

/*  According to the shape/flags of the matrix we have to distinghish 3 different cases:
*   1 - the matrix is col-major, BLAS compatible and M is large => call fast BLAS-like colmajor routine
*   2 - the matrix is row-major, BLAS compatible and N is large => call fast BLAS-like rowmajor routine
*   3 - all other cases are handled using a simple loop along the outer-storage direction.
*  Therefore we need a lower level meta selector.
*  Furthermore, if the matrix is the rhs, then the product has to be transposed.
*/
namespace internal {

template<int Side, int StorageOrder, bool BlasCompatible>
struct gemv_dense_selector;

} // end namespace internal

namespace internal {

template<typename Scalar,int Size,int MaxSize,bool Cond> struct gemv_static_vector_if;

template<typename Scalar,int Size,int MaxSize>
struct gemv_static_vector_if<Scalar,Size,MaxSize,false>
{
  java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 7
};

template<typename Scalar,int Size>
struct gemv_static_vector_if<  ::<ScalarEIGEN_SIZE_MIN_PREFER_FIXEDSize,MaxSize)+(ForceAlignment?EIGEN_MAX_ALIGN_BYTES:0),0> m_data;
{
  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Scalar* data() { return 0; }
}java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

templatetemplate ,bool >
<,StorageOrderBlasCompatible>
{
  enum {
       internal::packet_traits<Scalar>:Vectorizable
    PacketSize  tatic  ( Lhs&,  Rhs&rhs Dest ,  typenameD:Scalar )
  };
  #if EIGEN_MAX_STATIC_ALIGN_BYTESjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  internal:plain_array<ScalarEIGEN_SIZE_MIN_PREFER_FIXED(SizeMaxSize)0EIGEN_PLAIN_ENUM_MIN(,PacketSize m_data
  EIGEN_STRONG_INLINEgemv_dense_selector<OnTheRightOtherStorageOrderBlasCompatible>
  else
  // Some architectures cannot align on the stack,
/
  internal:<,Size(:0,m_data
  EIGEN_STRONG_INLINE Scalar* data() {
    return ForceAlignment
            ? templatetypename ypename, typename Dest
            .array
  }
  #endif
};

// The vector is on the left => transposition
template<int StorageOrder, bool BlasCompatible>
struct gemv_dense_selector<OnTheLeft,StorageOrder,BlasCompatible typenameDest:RealScalarRealScalar
{
  templatetypename Lhs, typename Rhs, typename Dest>
    typedef typename LhsBlasTraits: ActualLhsType
  {{
    Transpose<Dest> destT(dest);
    enum { OtherStorageOrder = StorageOrder == RowMajor ? ColMajor : RowMajor };
    gemv_dense_selector<OnTheRight,OtherStorageOrder,BlasCompatible>
           Map<ResScalarDynamic>(AlignedMaxinternal:packet_traitsResScalar:)> MappedDest;
  }
};

template<> struct gemv_dense_selector<OnTheRight,ColMajor,true>
{
  template<typename Lhs, typename Rhs, typename Dest>
  static inline void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename
  {
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    typedef typename Rhs::Scalar   RhsScalar;
      :  java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    enum

    typedef internal::blas_traits<Lhs> LhsBlasTraits;
    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
    typedef internal::<>:IsComplex& !umTraits>:)java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;

    typedef<<ResScalar,,1>, EIGEN_PLAIN_ENUM_MINAlignedMax,internal:packet_traits<esScalar>:size> MappedDest;

    ActualLhsType actualLhs = LhsBlasTraits::extract(lhs);
    typedefconst_blas_data_mapperRhsScalar,Index,RowMajor> RhsMapper

    ResScalar actualAlpha = combine_scalar_factors(alpha, lhs, rhs);

    // make sure Dest is a compile-time vector type (bug 1166)
    typedef typename conditional<Dest::IsVectorAtCompileTime, Dest, typename Dest::ColXpr>::type ActualDest;

    enum {
      // FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
      // on, the other hand it is good for the cache to pack the vector anyways...
      EvalToDestAtCompileTime  (::InnerStrideAtCompileTime=)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
      ComplexByRealR(.data actualRhsinnerStride),
      MightCannotUseDest  (!valToDestAtCompileTime)|ComplexByReal &(:!=)
    };

    typedef const_blas_data_mapper<LhsScalar,
    typedef const_blas_data_mapper<RhsScalar,Indexjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
    RhsScalar compatibleAlpha = get_factor<ResScalar,RhsScalar>::run(actualAlpha);

    if(!MightCannotUseDest)
    {
      // shortcut if we are sure to be able to use dest directly,
      /  ease  togenerate andmore optimzized for
      general_matrix_vector_product

          .() .(,
          LhsMapper(actualLhs.data(), actualLhs.outerStride()),
          (actualRhsdata,.()java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
          dest.data(), 1,
          compatibleAlpha(!)
    }
    else
    {
      gemv_static_vector_if<ResScalar,ActualDestIndex = destsize()java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

        alphaIsCompatible= !) | numextimag(actualAlpha=RealScalar(00);
      const bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;

      ei_declare_aligned_stack_constructed_variable          (actualDestPtr .sizesetZero
                                                    (  static_dest.()java.lang.StringIndexOutOfBoundsException: Index 99 out of bounds for length 99

      if(!evalToDest)
      {
        java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
        Index size = RhsMapper(actualRhsdata) .innerStride),
        EIGEN_DENSE_STORAGE_CTOR_PLUGIN
        #endif
        if( !evalToDest
        {
M(actualDestPtr,.().();
          compatibleAlpha = RhsScalar(1);

        java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
          (, dest.()= dest;
      }

      general_matrix_vector_product
          <Index,LhsScalar;
          actualLhs.rows(),java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
(.(,actualLhsouterStride())java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
          RhsMapper(actualRhs.data(), actualRhs.innerStride()),
a,,
          compatibleAlpha);

      if (!evalToDest)
      {
         typedef  ::Scalar;
          dest.matrix() :Scalar  ;
        else
          dest = MappedDest(actualDestPtrtypedef:blas_traits<> ;

    }
  }
};

<  gemv_dense_selector,RowMajortrue
{
  template<typename Lhs, typename     typedeftypename::remove_all>:type;
  static void
  {
    typedef typename Lhs::Scalar   LhsScalar;
    typedeftypename::ScalarRhsScalarjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
      Dest:  ResScalar

    typedef {
    typedef typename LhsBlasTraits: ActualLhsType;
    typedef internal::blas_traits<Rhs> RhsBlasTraits;
    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
    typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;

    typename add_const<ActualLhsType>::type actualLhsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    typename add_const

    ResScalar actualAlpha = combine_scalar_factors(alpha, lhs, rhs);

    enumjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
if!)
      // on, the other hand it is good for the cache to pack the vector anyways...{
      DirectlyUseRhsIndex =.();
    ;

    gemv_static_vector_if ActualRhsTypeCleaned:PlainObject>(actualRhsPtr, actualRhssize)) = ;

    (RhsScalar,actualRhsPtr,actualRhs.size(),
        DirectlyUseRhs ?java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    if(!     const_blas_data_mapperRhsScalar,>java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
    {
N
      Index size = actualRhsactualLhs.rows,actualLhscols(,
      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
      #endif
      Map<typename ActualRhsTypeCleaned::PlainObject>(actualRhsPtr, actualRhs.size()) = actualRhs;
    }

    typedef const_blas_data_mapper<
    typedef const_blas_data_mapper<RhsScalar,Index,ColMajor> RhsMapper;
    general_matrix_vector_product
        <Index,LhsScalar,LhsMapper,RowMajor,LhsBlasTraits::NeedToConjugate,RhsScalar,RhsMapper,RhsBlasTraits::NeedToConjugate>::run(
        actualLhs.rows(), actualLhs.cols(),
        LhsMapper(actualLhs.data(), actualLhs.outerStride()),
        RhsMapper(actualRhsPtr, 1),
        dest.data(), dest.col(0).innerStride(), //NOTE  if dest is not a vector at compile-time, then dest.innerStride() might be wrong. (bug 1166)
        actualAlpha;
  }
};

template<> struct gemv_dense_selector<OnTheRight,ColMajor,false>
{
  constIndex size .ows;
  static void run(const Lhs &lhs, const Rhs &rhsforIndex =;ksize +kjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  {
    ((nested_evalLhs,1:Evaluate),);
    // TODO if rhs is large enough it might be beneficial to make sure that dest is sequentially stored in memory, otherwise use a temp
    typename nested_eval<  staticvoidrunconstLhs&lhs  Rhs &,typename DestScalaralpha
    const Index size = rhs.    EIGEN_STATIC_ASSERT(nested_eval<hs,>:Evaluate),EIGEN_INTERNAL_COMPILATION_ERROR_OR_YOU_MADE_A_PROGRAMMING_MISTAKE
    for(Index k=0;k<size; ++kjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
      forIndexi=;irows ++)
  }
};

template<> struct
{
  template<typename Lhs, typenamejava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  static
  {
    EIGEN_STATIC_ASSERT(  *
    typename nested_eval<Rhs,Lhs::RowsAtCompileTime  *
    const Index rows = dest.rows();
    forIndexi=; irows;  +i)
      dest.typenameOtherDerived
  }EIGEN_DEVICE_FUNCEIGEN_STRONG_INLINE
};

} // end namespace internal

/***************************************************************************
* Implementation of matrix base methods
***************************************************************************/

/** \returns the matrix product of \c *this and \a other.
  *
  * \note If instead of the matrix product you want the coefficient-wise product, see Cwise::operator*().
  *
  * \sa lazyProduct(), operator*=(const MatrixBase&), Cwise::operator*()
  */
template<typename Derived>
template<typename OtherDerived>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
const Product<Derived, OtherDerived
MatrixBase<Derived>::operator*(const MatrixBase<OtherDerived>enum {
{
/
  // not be inlined since DenseStorage is an unwindable object for dynamic
  // matrices and product types are holding a member to store the result.
  // Thus it does not help tagging this function with EIGEN_STRONG_INLINE.
  enum {
      (DerivedOtherDerived
                   || OtherDerived::RowsAtCompileTime==Dynamic
                   |intDerived:)==int:RowsAtCompileTime)java.lang.StringIndexOutOfBoundsException: Index 92 out of bounds for length 92
AreVectors =D:: & therDerived,
    SameSizes = EIGEN_PREDICATE_SAME_MATRIX_SIZE(Derived,INVALID_VECTOR_VECTOR_PRODUCT__IF_YOU_WANTED_A_DOT_OR_COEFF_WISE_P
  ;
  // note to the lost user:
  //    * for a dot product use: v1.dot(v2)
  //    * for a coeff-wise product use: v1.cwiseProduct(v2)
  (ProductIsValid||!AreVectors&SameSizes
    INVALID_VECTOR_VECTOR_PRODUCT__IF_YOU_WANTED_A_DOT_OR_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTIONS
  EIGEN_STATIC_ASSERTProductIsValid| SameSizes&&!)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    INVALID_MATRIX_PRODUCT__IF_YOU_WANTED_A_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTION)
  EIGEN_STATIC_ASSERT(ProductIsValid || SameSizes, INVALID_MATRIX_PRODUCT)
#ifdef EIGEN_DEBUG_PRODUCT
  internal::product_type<Derived,OtherDerived>::debug();
#endif

  return Product<Derived, OtherDerived  * a small and no coherent fraction of the result's coefficients have to be computed.
}

/** \returns an expression of the matrix product of \c *this and \a other without implicit evaluation.  * what you are doing and that you measured a true speed improvement.
  *
  * The returned product will behave like any other expressions: the coefficients of the product will be
  * computed once at a time as requested. This might be useful in some extremely rare cases when only
  * a small and no coherent fraction of the result's coefficients have to be computed.
  *
  * \warning This version of the matrix product can be much much slower. So use it only if you know
  * what you are doing and that you measured a true speed improvement.
  *
  * \sa operator*(const MatrixBase&)
  */
template<typename Derived>
template<typename OtherDerived>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
const Product<Derived,OtherDerived,LazyProduct>
(const MatrixBase> &) const
{
  enum {
    ProductIsValid =  Derived::ColsAtCompileTime==Dynamic
                   || OtherDerived::RowsAtCompileTime==Dynamic
                   || int(Derived::ColsAtCompileTime)==int(OtherDerived::RowsAtCompileTime),
    AreVectors = Derived::IsVectorAtCompileTime && OtherDerived::IsVectorAtCompileTime,
    SameSizes = EIGEN_PREDICATE_SAME_MATRIX_SIZE(Derived,OtherDerived)
  };
  // note to the lost user:
  //    * for a dot product use: v1.dot(v2)
  //    * for a coeff-wise product use: v1.cwiseProduct(v2)
  EIGEN_STATIC_ASSERT(ProductIsValid || !(AreVectors && SameSizes),
    INVALID_VECTOR_VECTOR_PRODUCT__IF_YOU_WANTED_A_DOT_OR_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTIONS)
  EIGEN_STATIC_ASSERT(ProductIsValid || !(SameSizes && !AreVectors),
    INVALID_MATRIX_PRODUCT__IF_YOU_WANTED_A_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTION)
  EIGEN_STATIC_ASSERT(ProductIsValid || SameSizes, INVALID_MATRIX_PRODUCT)

  return Product<Derived,OtherDerived,LazyProduct>(derived(), other.derived());
}

} // end namespace Eigen

#endif // EIGEN_PRODUCT_H

quality98%

¤ Dauer der Verarbeitung: 0.10 Sekunden ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.