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/TensorConcatenation.h

@@ -1,377 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 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_CONCATENATION_H
-#define EIGEN_CXX11_TENSOR_TENSOR_CONCATENATION_H
-
-namespace Eigen {
-
-/** \class TensorConcatenationOp
-  * \ingroup CXX11_Tensor_Module
-  *
-  * \brief Tensor concatenation class.
-  *
-  *
-  */
-namespace internal {
-template<typename Axis, typename LhsXprType, typename RhsXprType>
-struct traits<TensorConcatenationOp<Axis, LhsXprType, RhsXprType> >
-{
-  // Type promotion to handle the case where the types of the lhs and the rhs are different.
-  typedef typename promote_storage_type<typename LhsXprType::Scalar,
-                                        typename RhsXprType::Scalar>::ret Scalar;
-  typedef typename promote_storage_type<typename traits<LhsXprType>::StorageKind,
-                                        typename traits<RhsXprType>::StorageKind>::ret StorageKind;
-  typedef typename promote_index_type<typename traits<LhsXprType>::Index,
-                                      typename traits<RhsXprType>::Index>::type Index;
-  typedef typename LhsXprType::Nested LhsNested;
-  typedef typename RhsXprType::Nested RhsNested;
-  typedef typename remove_reference<LhsNested>::type _LhsNested;
-  typedef typename remove_reference<RhsNested>::type _RhsNested;
-  static const int NumDimensions = traits<LhsXprType>::NumDimensions;
-  static const int Layout = traits<LhsXprType>::Layout;
-  enum { Flags = 0 };
-  typedef typename conditional<Pointer_type_promotion<typename LhsXprType::Scalar, Scalar>::val,
-                               typename traits<LhsXprType>::PointerType, typename traits<RhsXprType>::PointerType>::type PointerType;
-};
-
-template<typename Axis, typename LhsXprType, typename RhsXprType>
-struct eval<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>, Eigen::Dense>
-{
-  typedef const TensorConcatenationOp<Axis, LhsXprType, RhsXprType>& type;
-};
-
-template<typename Axis, typename LhsXprType, typename RhsXprType>
-struct nested<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>, 1, typename eval<TensorConcatenationOp<Axis, LhsXprType, RhsXprType> >::type>
-{
-  typedef TensorConcatenationOp<Axis, LhsXprType, RhsXprType> type;
-};
-
-}  // end namespace internal
-
-
-template<typename Axis, typename LhsXprType, typename RhsXprType>
-class TensorConcatenationOp : public TensorBase<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>, WriteAccessors>
-{
-  public:
-    typedef TensorBase<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>, WriteAccessors> Base;
-    typedef typename internal::traits<TensorConcatenationOp>::Scalar Scalar;
-    typedef typename internal::traits<TensorConcatenationOp>::StorageKind StorageKind;
-    typedef typename internal::traits<TensorConcatenationOp>::Index Index;
-    typedef typename internal::nested<TensorConcatenationOp>::type Nested;
-    typedef typename internal::promote_storage_type<typename LhsXprType::CoeffReturnType,
-                                                    typename RhsXprType::CoeffReturnType>::ret CoeffReturnType;
-    typedef typename NumTraits<Scalar>::Real RealScalar;
-
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorConcatenationOp(const LhsXprType& lhs, const RhsXprType& rhs, Axis axis)
-        : m_lhs_xpr(lhs), m_rhs_xpr(rhs), m_axis(axis) {}
-
-    EIGEN_DEVICE_FUNC
-    const typename internal::remove_all<typename LhsXprType::Nested>::type&
-    lhsExpression() const { return m_lhs_xpr; }
-
-    EIGEN_DEVICE_FUNC
-    const typename internal::remove_all<typename RhsXprType::Nested>::type&
-    rhsExpression() const { return m_rhs_xpr; }
-
-    EIGEN_DEVICE_FUNC const Axis& axis() const { return m_axis; }
-
-    EIGEN_TENSOR_INHERIT_ASSIGNMENT_OPERATORS(TensorConcatenationOp)
-  protected:
-    typename LhsXprType::Nested m_lhs_xpr;
-    typename RhsXprType::Nested m_rhs_xpr;
-    const Axis m_axis;
-};
-
-
-// Eval as rvalue
-template<typename Axis, typename LeftArgType, typename RightArgType, typename Device>
-struct TensorEvaluator<const TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device>
-{
-  typedef TensorConcatenationOp<Axis, LeftArgType, RightArgType> XprType;
-  typedef typename XprType::Index Index;
-  static const int NumDims = internal::array_size<typename TensorEvaluator<LeftArgType, Device>::Dimensions>::value;
-  static const int RightNumDims = internal::array_size<typename TensorEvaluator<RightArgType, Device>::Dimensions>::value;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-  enum {
-    IsAligned         = false,
-    PacketAccess      = TensorEvaluator<LeftArgType, Device>::PacketAccess &&
-                        TensorEvaluator<RightArgType, Device>::PacketAccess,
-    BlockAccess       = false,
-    PreferBlockAccess = TensorEvaluator<LeftArgType, Device>::PreferBlockAccess ||
-                        TensorEvaluator<RightArgType, Device>::PreferBlockAccess,
-    Layout            = TensorEvaluator<LeftArgType, Device>::Layout,
-    RawAccess         = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-    : m_leftImpl(op.lhsExpression(), device), m_rightImpl(op.rhsExpression(), device), m_axis(op.axis())
-  {
-    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<LeftArgType, Device>::Layout) == static_cast<int>(TensorEvaluator<RightArgType, Device>::Layout) || NumDims == 1), YOU_MADE_A_PROGRAMMING_MISTAKE);
-    EIGEN_STATIC_ASSERT((NumDims == RightNumDims), YOU_MADE_A_PROGRAMMING_MISTAKE);
-    EIGEN_STATIC_ASSERT((NumDims > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-    eigen_assert(0 <= m_axis && m_axis < NumDims);
-    const Dimensions& lhs_dims = m_leftImpl.dimensions();
-    const Dimensions& rhs_dims = m_rightImpl.dimensions();
-    {
-      int i = 0;
-      for (; i < m_axis; ++i) {
-        eigen_assert(lhs_dims[i] > 0);
-        eigen_assert(lhs_dims[i] == rhs_dims[i]);
-        m_dimensions[i] = lhs_dims[i];
-      }
-      eigen_assert(lhs_dims[i] > 0);  // Now i == m_axis.
-      eigen_assert(rhs_dims[i] > 0);
-      m_dimensions[i] = lhs_dims[i] + rhs_dims[i];
-      for (++i; i < NumDims; ++i) {
-        eigen_assert(lhs_dims[i] > 0);
-        eigen_assert(lhs_dims[i] == rhs_dims[i]);
-        m_dimensions[i] = lhs_dims[i];
-      }
-    }
-
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_leftStrides[0] = 1;
-      m_rightStrides[0] = 1;
-      m_outputStrides[0] = 1;
-
-      for (int j = 1; j < NumDims; ++j) {
-        m_leftStrides[j] = m_leftStrides[j-1] * lhs_dims[j-1];
-        m_rightStrides[j] = m_rightStrides[j-1] * rhs_dims[j-1];
-        m_outputStrides[j] = m_outputStrides[j-1] * m_dimensions[j-1];
-      }
-    } else {
-      m_leftStrides[NumDims - 1] = 1;
-      m_rightStrides[NumDims - 1] = 1;
-      m_outputStrides[NumDims - 1] = 1;
-
-      for (int j = NumDims - 2; j >= 0; --j) {
-        m_leftStrides[j] = m_leftStrides[j+1] * lhs_dims[j+1];
-        m_rightStrides[j] = m_rightStrides[j+1] * rhs_dims[j+1];
-        m_outputStrides[j] = m_outputStrides[j+1] * m_dimensions[j+1];
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  // TODO(phli): Add short-circuit memcpy evaluation if underlying data are linear?
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType)
-  {
-    m_leftImpl.evalSubExprsIfNeeded(NULL);
-    m_rightImpl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-
-  EIGEN_STRONG_INLINE void cleanup()
-  {
-    m_leftImpl.cleanup();
-    m_rightImpl.cleanup();
-  }
-
-  // TODO(phli): attempt to speed this up. The integer divisions and modulo are slow.
-  // See CL/76180724 comments for more ideas.
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
-  {
-    // Collect dimension-wise indices (subs).
-    array<Index, NumDims> subs;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int i = NumDims - 1; i > 0; --i) {
-        subs[i] = index / m_outputStrides[i];
-        index -= subs[i] * m_outputStrides[i];
-      }
-      subs[0] = index;
-    } else {
-      for (int i = 0; i < NumDims - 1; ++i) {
-        subs[i] = index / m_outputStrides[i];
-        index -= subs[i] * m_outputStrides[i];
-      }
-      subs[NumDims - 1] = index;
-    }
-
-    const Dimensions& left_dims = m_leftImpl.dimensions();
-    if (subs[m_axis] < left_dims[m_axis]) {
-      Index left_index;
-      if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-        left_index = subs[0];
-        EIGEN_UNROLL_LOOP
-        for (int i = 1; i < NumDims; ++i) {
-          left_index += (subs[i] % left_dims[i]) * m_leftStrides[i];
-        }
-      } else {
-        left_index = subs[NumDims - 1];
-        EIGEN_UNROLL_LOOP
-        for (int i = NumDims - 2; i >= 0; --i) {
-          left_index += (subs[i] % left_dims[i]) * m_leftStrides[i];
-        }
-      }
-      return m_leftImpl.coeff(left_index);
-    } else {
-      subs[m_axis] -= left_dims[m_axis];
-      const Dimensions& right_dims = m_rightImpl.dimensions();
-      Index right_index;
-      if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-        right_index = subs[0];
-        EIGEN_UNROLL_LOOP
-        for (int i = 1; i < NumDims; ++i) {
-          right_index += (subs[i] % right_dims[i]) * m_rightStrides[i];
-        }
-      } else {
-        right_index = subs[NumDims - 1];
-        EIGEN_UNROLL_LOOP
-        for (int i = NumDims - 2; i >= 0; --i) {
-          right_index += (subs[i] % right_dims[i]) * m_rightStrides[i];
-        }
-      }
-      return m_rightImpl.coeff(right_index);
-    }
-  }
-
-  // TODO(phli): Add a real vectorization.
-  template<int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const
-  {
-    const int packetSize = PacketType<CoeffReturnType, Device>::size;
-    EIGEN_STATIC_ASSERT((packetSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
-    eigen_assert(index + packetSize - 1 < dimensions().TotalSize());
-
-    EIGEN_ALIGN_MAX CoeffReturnType values[packetSize];
-    EIGEN_UNROLL_LOOP
-    for (int i = 0; i < packetSize; ++i) {
-      values[i] = coeff(index+i);
-    }
-    PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-    return rslt;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost
-  costPerCoeff(bool vectorized) const {
-    const double compute_cost = NumDims * (2 * TensorOpCost::AddCost<Index>() +
-                                           2 * TensorOpCost::MulCost<Index>() +
-                                           TensorOpCost::DivCost<Index>() +
-                                           TensorOpCost::ModCost<Index>());
-    const double lhs_size = m_leftImpl.dimensions().TotalSize();
-    const double rhs_size = m_rightImpl.dimensions().TotalSize();
-    return (lhs_size / (lhs_size + rhs_size)) *
-               m_leftImpl.costPerCoeff(vectorized) +
-           (rhs_size / (lhs_size + rhs_size)) *
-               m_rightImpl.costPerCoeff(vectorized) +
-           TensorOpCost(0, 0, compute_cost);
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return NULL; }
-
-  #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_leftImpl.bind(cgh);
-    m_rightImpl.bind(cgh);
-  }
-  #endif
-
-  protected:
-    Dimensions m_dimensions;
-    array<Index, NumDims> m_outputStrides;
-    array<Index, NumDims> m_leftStrides;
-    array<Index, NumDims> m_rightStrides;
-    TensorEvaluator<LeftArgType, Device> m_leftImpl;
-    TensorEvaluator<RightArgType, Device> m_rightImpl;
-    const Axis m_axis;
-};
-
-// Eval as lvalue
-template<typename Axis, typename LeftArgType, typename RightArgType, typename Device>
-  struct TensorEvaluator<TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device>
-  : public TensorEvaluator<const TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device>
-{
-  typedef TensorEvaluator<const TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device> Base;
-  typedef TensorConcatenationOp<Axis, LeftArgType, RightArgType> XprType;
-  typedef typename Base::Dimensions Dimensions;
-  enum {
-    IsAligned         = false,
-    PacketAccess      = TensorEvaluator<LeftArgType, Device>::PacketAccess &&
-                        TensorEvaluator<RightArgType, Device>::PacketAccess,
-    BlockAccess       = false,
-    PreferBlockAccess = TensorEvaluator<LeftArgType, Device>::PreferBlockAccess ||
-                        TensorEvaluator<RightArgType, Device>::PreferBlockAccess,
-    Layout            = TensorEvaluator<LeftArgType, Device>::Layout,
-    RawAccess         = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(XprType& op, const Device& device)
-    : Base(op, device)
-  {
-    EIGEN_STATIC_ASSERT((static_cast<int>(Layout) == static_cast<int>(ColMajor)), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  }
-
-  typedef typename XprType::Index Index;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index)
-  {
-    // Collect dimension-wise indices (subs).
-    array<Index, Base::NumDims> subs;
-    for (int i = Base::NumDims - 1; i > 0; --i) {
-      subs[i] = index / this->m_outputStrides[i];
-      index -= subs[i] * this->m_outputStrides[i];
-    }
-    subs[0] = index;
-
-    const Dimensions& left_dims = this->m_leftImpl.dimensions();
-    if (subs[this->m_axis] < left_dims[this->m_axis]) {
-      Index left_index = subs[0];
-      for (int i = 1; i < Base::NumDims; ++i) {
-        left_index += (subs[i] % left_dims[i]) * this->m_leftStrides[i];
-      }
-      return this->m_leftImpl.coeffRef(left_index);
-    } else {
-      subs[this->m_axis] -= left_dims[this->m_axis];
-      const Dimensions& right_dims = this->m_rightImpl.dimensions();
-      Index right_index = subs[0];
-      for (int i = 1; i < Base::NumDims; ++i) {
-        right_index += (subs[i] % right_dims[i]) * this->m_rightStrides[i];
-      }
-      return this->m_rightImpl.coeffRef(right_index);
-    }
-  }
-
-  template <int StoreMode> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  void writePacket(Index index, const PacketReturnType& x)
-  {
-    const int packetSize = PacketType<CoeffReturnType, Device>::size;
-    EIGEN_STATIC_ASSERT((packetSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
-    eigen_assert(index + packetSize - 1 < this->dimensions().TotalSize());
-
-    EIGEN_ALIGN_MAX CoeffReturnType values[packetSize];
-    internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
-    for (int i = 0; i < packetSize; ++i) {
-      coeffRef(index+i) = values[i];
-    }
-  }
-};
-
-} // end namespace Eigen
-
-#endif // EIGEN_CXX11_TENSOR_TENSOR_CONCATENATION_H