sequenzo 0.1.18__cp310-cp310-win_amd64.whl → 0.1.20__cp310-cp310-win_amd64.whl

sequenzo/dissimilarity_measures/src/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorConversion.h

@@ -1,456 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@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_CXX11_TENSOR_TENSOR_CONVERSION_H
-#define EIGEN_CXX11_TENSOR_TENSOR_CONVERSION_H
-
-namespace Eigen {
-
-/** \class TensorConversionOp
-  * \ingroup CXX11_Tensor_Module
-  *
-  * \brief Tensor conversion class. This class makes it possible to vectorize
-  * type casting operations when the number of scalars per packet in the source
-  * and the destination type differ
-  */
-namespace internal {
-template<typename TargetType, typename XprType>
-struct traits<TensorConversionOp<TargetType, XprType> >
-{
-  // Type promotion to handle the case where the types of the lhs and the rhs are different.
-  typedef TargetType Scalar;
-  typedef typename traits<XprType>::StorageKind StorageKind;
-  typedef typename traits<XprType>::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef typename remove_reference<Nested>::type _Nested;
-  static const int NumDimensions = traits<XprType>::NumDimensions;
-  static const int Layout = traits<XprType>::Layout;
-  enum { Flags = 0 };
-  typedef typename TypeConversion<Scalar, typename traits<XprType>::PointerType>::type PointerType;
-};
-
-template<typename TargetType, typename XprType>
-struct eval<TensorConversionOp<TargetType, XprType>, Eigen::Dense>
-{
-  typedef const TensorConversionOp<TargetType, XprType>& type;
-};
-
-template<typename TargetType, typename XprType>
-struct nested<TensorConversionOp<TargetType, XprType>, 1, typename eval<TensorConversionOp<TargetType, XprType> >::type>
-{
-  typedef TensorConversionOp<TargetType, XprType> type;
-};
-
-}  // end namespace internal
-
-
-template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket, int SrcCoeffRatio, int TgtCoeffRatio>
-struct PacketConverter;
-
-template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket>
-struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 1, 1> {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  PacketConverter(const TensorEvaluator& impl)
-      : m_impl(impl) {}
-
-  template<int LoadMode, typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
-    return internal::pcast<SrcPacket, TgtPacket>(m_impl.template packet<LoadMode>(index));
-  }
-
- private:
-  const TensorEvaluator& m_impl;
-};
-
-
-template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket>
-struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 2, 1> {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  PacketConverter(const TensorEvaluator& impl)
-      : m_impl(impl) {}
-
-  template<int LoadMode, typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
-    const int SrcPacketSize = internal::unpacket_traits<SrcPacket>::size;
-
-    SrcPacket src1 = m_impl.template packet<LoadMode>(index);
-    SrcPacket src2 = m_impl.template packet<LoadMode>(index + SrcPacketSize);
-    TgtPacket result = internal::pcast<SrcPacket, TgtPacket>(src1, src2);
-    return result;
-  }
-
- private:
-  const TensorEvaluator& m_impl;
-};
-
-template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket>
-struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 4, 1> {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  PacketConverter(const TensorEvaluator& impl)
-      : m_impl(impl) {}
-
-  template<int LoadMode, typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
-    const int SrcPacketSize = internal::unpacket_traits<SrcPacket>::size;
-
-    SrcPacket src1 = m_impl.template packet<LoadMode>(index);
-    SrcPacket src2 = m_impl.template packet<LoadMode>(index + SrcPacketSize);
-    SrcPacket src3 = m_impl.template packet<LoadMode>(index + 2 * SrcPacketSize);
-    SrcPacket src4 = m_impl.template packet<LoadMode>(index + 3 * SrcPacketSize);
-    TgtPacket result = internal::pcast<SrcPacket, TgtPacket>(src1, src2, src3, src4);
-    return result;
-  }
-
- private:
-  const TensorEvaluator& m_impl;
-};
-
-template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket>
-struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 8, 1> {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  PacketConverter(const TensorEvaluator& impl)
-      : m_impl(impl) {}
-
-  template<int LoadMode, typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
-    const int SrcPacketSize = internal::unpacket_traits<SrcPacket>::size;
-
-    SrcPacket src1 = m_impl.template packet<LoadMode>(index);
-    SrcPacket src2 = m_impl.template packet<LoadMode>(index + 1 * SrcPacketSize);
-    SrcPacket src3 = m_impl.template packet<LoadMode>(index + 2 * SrcPacketSize);
-    SrcPacket src4 = m_impl.template packet<LoadMode>(index + 3 * SrcPacketSize);
-    SrcPacket src5 = m_impl.template packet<LoadMode>(index + 4 * SrcPacketSize);
-    SrcPacket src6 = m_impl.template packet<LoadMode>(index + 5 * SrcPacketSize);
-    SrcPacket src7 = m_impl.template packet<LoadMode>(index + 6 * SrcPacketSize);
-    SrcPacket src8 = m_impl.template packet<LoadMode>(index + 7 * SrcPacketSize);
-    TgtPacket result = internal::pcast<SrcPacket, TgtPacket>(src1, src2, src3, src4, src5, src6, src7, src8);
-    return result;
-  }
-
- private:
-  const TensorEvaluator& m_impl;
-};
-
-template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket, int TgtCoeffRatio>
-struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 1, TgtCoeffRatio> {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  PacketConverter(const TensorEvaluator& impl)
-      : m_impl(impl), m_maxIndex(impl.dimensions().TotalSize()) {}
-
-  template<int LoadMode, typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
-    const int SrcPacketSize = internal::unpacket_traits<SrcPacket>::size;
-    // Only call m_impl.packet() when we have direct access to the underlying data. This
-    // ensures that we don't compute the subexpression twice. We may however load some
-    // coefficients twice, but in practice this doesn't negatively impact performance.
-    if (m_impl.data() && (index + SrcPacketSize < m_maxIndex)) {
-      // Force unaligned memory loads since we can't ensure alignment anymore
-      return internal::pcast<SrcPacket, TgtPacket>(m_impl.template packet<Unaligned>(index));
-    } else {
-      const int TgtPacketSize = internal::unpacket_traits<TgtPacket>::size;
-      typedef typename internal::unpacket_traits<SrcPacket>::type SrcType;
-      typedef typename internal::unpacket_traits<TgtPacket>::type TgtType;
-      internal::scalar_cast_op<SrcType, TgtType> converter;
-      EIGEN_ALIGN_MAX typename internal::unpacket_traits<TgtPacket>::type values[TgtPacketSize];
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < TgtPacketSize; ++i) {
-        values[i] = converter(m_impl.coeff(index+i));
-      }
-      TgtPacket rslt = internal::pload<TgtPacket>(values);
-      return rslt;
-    }
-  }
-
- private:
-  const TensorEvaluator& m_impl;
-  const typename TensorEvaluator::Index m_maxIndex;
-};
-
-template<typename TargetType, typename XprType>
-class TensorConversionOp : public TensorBase<TensorConversionOp<TargetType, XprType>, ReadOnlyAccessors>
-{
-  public:
-    typedef typename internal::traits<TensorConversionOp>::Scalar Scalar;
-    typedef typename internal::traits<TensorConversionOp>::StorageKind StorageKind;
-    typedef typename internal::traits<TensorConversionOp>::Index Index;
-    typedef typename internal::nested<TensorConversionOp>::type Nested;
-    typedef Scalar CoeffReturnType;
-    typedef typename NumTraits<Scalar>::Real RealScalar;
-
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorConversionOp(const XprType& xpr)
-        : m_xpr(xpr) {}
-
-    EIGEN_DEVICE_FUNC
-    const typename internal::remove_all<typename XprType::Nested>::type&
-    expression() const { return m_xpr; }
-
-  protected:
-    typename XprType::Nested m_xpr;
-};
-
-template <bool SameType, typename Eval, typename EvalPointerType> struct ConversionSubExprEval {
-  static EIGEN_STRONG_INLINE bool run(Eval& impl, EvalPointerType) {
-    impl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-};
-
-template <typename Eval, typename EvalPointerType> struct ConversionSubExprEval<true, Eval, EvalPointerType> {
-  static EIGEN_STRONG_INLINE bool run(Eval& impl, EvalPointerType data) {
-    return impl.evalSubExprsIfNeeded(data);
-  }
-};
-
-#ifdef EIGEN_USE_THREADS
-template <bool SameType, typename Eval, typename EvalPointerType,
-          typename EvalSubExprsCallback>
-struct ConversionSubExprEvalAsync {
-  static EIGEN_STRONG_INLINE void run(Eval& impl, EvalPointerType, EvalSubExprsCallback done) {
-    impl.evalSubExprsIfNeededAsync(nullptr, std::move(done));
-  }
-};
-
-template <typename Eval, typename EvalPointerType,
-          typename EvalSubExprsCallback>
-struct ConversionSubExprEvalAsync<true, Eval, EvalPointerType,
-                                  EvalSubExprsCallback> {
-  static EIGEN_STRONG_INLINE void run(Eval& impl, EvalPointerType data, EvalSubExprsCallback done) {
-    impl.evalSubExprsIfNeededAsync(data, std::move(done));
-  }
-};
-#endif
-
-namespace internal {
-
-template <typename SrcType, typename TargetType, bool IsSameT>
-struct CoeffConv {
-  template <typename ArgType, typename Device>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TargetType run(const TensorEvaluator<ArgType, Device>& impl, Index index) {
-    internal::scalar_cast_op<SrcType, TargetType> converter;
-    return converter(impl.coeff(index));
-  }
-};
-
-template <typename SrcType, typename TargetType>
-struct CoeffConv<SrcType, TargetType, true> {
-  template <typename ArgType, typename Device>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TargetType run(const TensorEvaluator<ArgType, Device>& impl, Index index) {
-    return impl.coeff(index);
-  }
-};
-
-template <typename SrcPacket, typename TargetPacket, int LoadMode, bool ActuallyVectorize, bool IsSameT>
-struct PacketConv {
-  typedef typename internal::unpacket_traits<SrcPacket>::type SrcType;
-  typedef typename internal::unpacket_traits<TargetPacket>::type TargetType;
-
-  static const int PacketSize = internal::unpacket_traits<TargetPacket>::size;
-
-  template <typename ArgType, typename Device>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TargetPacket run(const TensorEvaluator<ArgType, Device>& impl, Index index) {
-    internal::scalar_cast_op<SrcType, TargetType> converter;
-    EIGEN_ALIGN_MAX typename internal::remove_const<TargetType>::type values[PacketSize];
-    EIGEN_UNROLL_LOOP
-    for (int i = 0; i < PacketSize; ++i) {
-      values[i] = converter(impl.coeff(index+i));
-    }
-    TargetPacket rslt = internal::pload<TargetPacket>(values);
-    return rslt;
-  }
-};
-
-template <typename SrcPacket, typename TargetPacket, int LoadMode, bool IsSameT>
-struct PacketConv<SrcPacket, TargetPacket, LoadMode, true, IsSameT> {
-  typedef typename internal::unpacket_traits<SrcPacket>::type SrcType;
-  typedef typename internal::unpacket_traits<TargetPacket>::type TargetType;
-
-  template <typename ArgType, typename Device>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TargetPacket run(const TensorEvaluator<ArgType, Device>& impl, Index index) {
-    const int SrcCoeffRatio = internal::type_casting_traits<SrcType, TargetType>::SrcCoeffRatio;
-    const int TgtCoeffRatio = internal::type_casting_traits<SrcType, TargetType>::TgtCoeffRatio;
-    PacketConverter<TensorEvaluator<ArgType, Device>, SrcPacket, TargetPacket,
-                    SrcCoeffRatio, TgtCoeffRatio> converter(impl);
-    return converter.template packet<LoadMode>(index);
-  }
-};
-
-template <typename SrcPacket, typename TargetPacket, int LoadMode>
-struct PacketConv<SrcPacket, TargetPacket, LoadMode, /*ActuallyVectorize=*/false, /*IsSameT=*/true> {
-  typedef typename internal::unpacket_traits<TargetPacket>::type TargetType;
-  static const int PacketSize = internal::unpacket_traits<TargetPacket>::size;
-
-  template <typename ArgType, typename Device>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TargetPacket run(const TensorEvaluator<ArgType, Device>& impl, Index index) {
-    EIGEN_ALIGN_MAX typename internal::remove_const<TargetType>::type values[PacketSize];
-    for (int i = 0; i < PacketSize; ++i) values[i] = impl.coeff(index+i);
-    return internal::pload<TargetPacket>(values);
-  }
-};
-
-template <typename SrcPacket, typename TargetPacket, int LoadMode>
-struct PacketConv<SrcPacket, TargetPacket, LoadMode, /*ActuallyVectorize=*/true, /*IsSameT=*/true> {
-  template <typename ArgType, typename Device>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TargetPacket run(const TensorEvaluator<ArgType, Device>& impl, Index index) {
-    return impl.template packet<LoadMode>(index);
-  }
-};
-
-}  // namespace internal
-
-// Eval as rvalue
-template<typename TargetType, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorConversionOp<TargetType, ArgType>, Device>
-{
-  typedef TensorConversionOp<TargetType, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  typedef typename TensorEvaluator<ArgType, Device>::Dimensions Dimensions;
-  typedef TargetType Scalar;
-  typedef TargetType CoeffReturnType;
-  typedef typename internal::remove_all<typename internal::traits<ArgType>::Scalar>::type SrcType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  typedef typename PacketType<SrcType, Device>::type PacketSourceType;
-  static const int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  static const bool IsSameType = internal::is_same<TargetType, SrcType>::value;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  enum {
-    IsAligned         = false,
-    PacketAccess      =
-    #ifndef EIGEN_USE_SYCL
-                        true,
-    #else
-                        TensorEvaluator<ArgType, Device>::PacketAccess &
-                        internal::type_casting_traits<SrcType, TargetType>::VectorizedCast,
-    #endif
-    BlockAccess       = TensorEvaluator<ArgType, Device>::BlockAccess,
-    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
-    Layout            = TensorEvaluator<ArgType, Device>::Layout,
-    RawAccess         = false
-  };
-
-  static const int NumDims = internal::array_size<Dimensions>::value;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  typedef typename TensorEvaluator<const ArgType, Device>::TensorBlock
-      ArgTensorBlock;
-
-  struct TensorConversionOpBlockFactory {
-    template <typename ArgXprType>
-    struct XprType {
-      typedef TensorConversionOp<TargetType, const ArgXprType> type;
-    };
-
-    template <typename ArgXprType>
-    typename XprType<ArgXprType>::type expr(const ArgXprType& expr) const {
-      return typename XprType<ArgXprType>::type(expr);
-    }
-  };
-
-  typedef internal::TensorUnaryExprBlock<TensorConversionOpBlockFactory,
-                                         ArgTensorBlock>
-      TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-    : m_impl(op.expression(), device)
-  {
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_impl.dimensions(); }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data)
-  {
-    return ConversionSubExprEval<IsSameType, TensorEvaluator<ArgType, Device>, EvaluatorPointerType>::run(m_impl, data);
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(
-      EvaluatorPointerType data, EvalSubExprsCallback done) {
-    ConversionSubExprEvalAsync<IsSameType, TensorEvaluator<ArgType, Device>,
-                               EvaluatorPointerType,
-        EvalSubExprsCallback>::run(m_impl, data, std::move(done));
-  }
-#endif
-
-  EIGEN_STRONG_INLINE void cleanup()
-  {
-    m_impl.cleanup();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
-  {
-    return internal::CoeffConv<SrcType, TargetType, IsSameType>::run(m_impl,index);
-  }
-
-  template<int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType
-  packet(Index index) const {
-    // If we are not going to do the cast, we just need to check that base
-    // TensorEvaluator has packet access. Otherwise we also need to make sure,
-    // that we have an implementation of vectorized cast.
-    const bool Vectorizable =
-        IsSameType
-        ? TensorEvaluator<ArgType, Device>::PacketAccess
-        : int(TensorEvaluator<ArgType, Device>::PacketAccess) &
-          int(internal::type_casting_traits<SrcType, TargetType>::VectorizedCast);
-
-    return internal::PacketConv<PacketSourceType, PacketReturnType, LoadMode,
-                                Vectorizable, IsSameType>::run(m_impl, index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost
-  costPerCoeff(bool vectorized) const {
-    const double cast_cost = TensorOpCost::CastCost<SrcType, TargetType>();
-    if (vectorized) {
-      const double SrcCoeffRatio =
-          internal::type_casting_traits<SrcType, TargetType>::SrcCoeffRatio;
-      const double TgtCoeffRatio =
-          internal::type_casting_traits<SrcType, TargetType>::TgtCoeffRatio;
-      return m_impl.costPerCoeff(vectorized) * (SrcCoeffRatio / PacketSize) +
-          TensorOpCost(0, 0, TgtCoeffRatio * (cast_cost / PacketSize));
-    } else {
-      return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, cast_cost);
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    return m_impl.getResourceRequirements();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock
-  block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-          bool /*root_of_expr_ast*/ = false) const {
-    return TensorBlock(m_impl.block(desc, scratch),
-                         TensorConversionOpBlockFactory());
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return NULL; }
-
-  /// required by sycl in order to extract the sycl accessor
-  const TensorEvaluator<ArgType, Device>& impl() const { return m_impl; }
-#ifdef EIGEN_USE_SYCL
-  // binding placeholder accessors to a command group handler for SYCL
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void bind(cl::sycl::handler &cgh) const {
-    m_impl.bind(cgh);
-  }
-#endif
-
- protected:
-  TensorEvaluator<ArgType, Device> m_impl;
-};
-
-} // end namespace Eigen
-
-#endif // EIGEN_CXX11_TENSOR_TENSOR_CONVERSION_H