sequenzo 0.1.18__cp39-cp39-macosx_10_9_universal2.whl → 0.1.19__cp39-cp39-macosx_10_9_universal2.whl

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

@@ -1,247 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Ke Yang <yangke@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_INFLATION_H
-#define EIGEN_CXX11_TENSOR_TENSOR_INFLATION_H
-
-namespace Eigen {
-
-/** \class TensorInflation
-  * \ingroup CXX11_Tensor_Module
-  *
-  * \brief Tensor inflation class.
-  *
-  *
-  */
-namespace internal {
-template<typename Strides, typename XprType>
-struct traits<TensorInflationOp<Strides, XprType> > : public traits<XprType>
-{
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef typename remove_reference<Nested>::type _Nested;
-  static const int NumDimensions = XprTraits::NumDimensions;
-  static const int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-};
-
-template<typename Strides, typename XprType>
-struct eval<TensorInflationOp<Strides, XprType>, Eigen::Dense>
-{
-  typedef const TensorInflationOp<Strides, XprType>& type;
-};
-
-template<typename Strides, typename XprType>
-struct nested<TensorInflationOp<Strides, XprType>, 1, typename eval<TensorInflationOp<Strides, XprType> >::type>
-{
-  typedef TensorInflationOp<Strides, XprType> type;
-};
-
-}  // end namespace internal
-
-template<typename Strides, typename XprType>
-class TensorInflationOp : public TensorBase<TensorInflationOp<Strides, XprType>, ReadOnlyAccessors>
-{
-  public:
-  typedef typename Eigen::internal::traits<TensorInflationOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorInflationOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorInflationOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorInflationOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorInflationOp(const XprType& expr, const Strides& strides)
-      : m_xpr(expr), m_strides(strides) {}
-
-    EIGEN_DEVICE_FUNC
-    const Strides& strides() const { return m_strides; }
-
-    EIGEN_DEVICE_FUNC
-    const typename internal::remove_all<typename XprType::Nested>::type&
-    expression() const { return m_xpr; }
-
-  protected:
-    typename XprType::Nested m_xpr;
-    const Strides m_strides;
-};
-
-// Eval as rvalue
-template<typename Strides, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorInflationOp<Strides, ArgType>, Device>
-{
-  typedef TensorInflationOp<Strides, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  static const int NumDims = internal::array_size<typename TensorEvaluator<ArgType, 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;
-  static const int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  enum {
-    IsAligned = /*TensorEvaluator<ArgType, Device>::IsAligned*/ false,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = false,
-    PreferBlockAccess = false,
-    Layout = TensorEvaluator<ArgType, Device>::Layout,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_impl(op.expression(), device), m_strides(op.strides())
-  {
-    m_dimensions = m_impl.dimensions();
-    // Expand each dimension to the inflated dimension.
-    for (int i = 0; i < NumDims; ++i) {
-      m_dimensions[i] = (m_dimensions[i] - 1) * op.strides()[i] + 1;
-    }
-
-    // Remember the strides for fast division.
-    for (int i = 0; i < NumDims; ++i) {
-      m_fastStrides[i] = internal::TensorIntDivisor<Index>(m_strides[i]);
-    }
-
-    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_outputStrides[0] = 1;
-      m_inputStrides[0] = 1;
-      for (int i = 1; i < NumDims; ++i) {
-        m_outputStrides[i] = m_outputStrides[i-1] * m_dimensions[i-1];
-        m_inputStrides[i] = m_inputStrides[i-1] * input_dims[i-1];
-      }
-    } else {  // RowMajor
-      m_outputStrides[NumDims-1] = 1;
-      m_inputStrides[NumDims-1] = 1;
-      for (int i = NumDims - 2; i >= 0; --i) {
-        m_outputStrides[i] = m_outputStrides[i+1] * m_dimensions[i+1];
-        m_inputStrides[i] = m_inputStrides[i+1] * input_dims[i+1];
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-  EIGEN_STRONG_INLINE void cleanup() {
-    m_impl.cleanup();
-  }
-
-  // Computes the input index given the output index. Returns true if the output
-  // index doesn't fall into a hole.
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool getInputIndex(Index index, Index* inputIndex) const
-  {
-    eigen_assert(index < dimensions().TotalSize());
-    *inputIndex = 0;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      EIGEN_UNROLL_LOOP
-      for (int i = NumDims - 1; i > 0; --i) {
-        const Index idx = index / m_outputStrides[i];
-        if (idx != idx / m_fastStrides[i] * m_strides[i]) {
-          return false;
-        }
-        *inputIndex += idx / m_strides[i] * m_inputStrides[i];
-        index -= idx * m_outputStrides[i];
-      }
-      if (index != index / m_fastStrides[0] * m_strides[0]) {
-        return false;
-      }
-      *inputIndex += index / m_strides[0];
-      return true;
-    } else {
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < NumDims - 1; ++i) {
-        const Index idx = index / m_outputStrides[i];
-        if (idx != idx / m_fastStrides[i] * m_strides[i]) {
-          return false;
-        }
-        *inputIndex += idx / m_strides[i] * m_inputStrides[i];
-        index -= idx * m_outputStrides[i];
-      }
-      if (index != index / m_fastStrides[NumDims-1] * m_strides[NumDims-1]) {
-        return false;
-      }
-      *inputIndex += index / m_strides[NumDims - 1];
-    }
-    return true;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
-  {
-    Index inputIndex = 0;
-    if (getInputIndex(index, &inputIndex)) {
-     return m_impl.coeff(inputIndex);
-    } else {
-     return Scalar(0);
-    }
-  }
-
-  // TODO(yangke): optimize this function so that we can detect and produce
-  // all-zero packets
-  template<int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const
-  {
-    EIGEN_STATIC_ASSERT((PacketSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
-    eigen_assert(index+PacketSize-1 < dimensions().TotalSize());
-
-    EIGEN_ALIGN_MAX typename internal::remove_const<CoeffReturnType>::type 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 * (3 * TensorOpCost::DivCost<Index>() +
-                                           3 * TensorOpCost::MulCost<Index>() +
-                                           2 * TensorOpCost::AddCost<Index>());
-    const double input_size = m_impl.dimensions().TotalSize();
-    const double output_size = m_dimensions.TotalSize();
-    if (output_size == 0)
-      return TensorOpCost();
-    return m_impl.costPerCoeff(vectorized) +
-           TensorOpCost(sizeof(CoeffReturnType) * input_size / output_size, 0,
-                        compute_cost, vectorized, PacketSize);
-  }
-
-  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_impl.bind(cgh);
-  }
-#endif
-
- protected:
-  Dimensions m_dimensions;
-  array<Index, NumDims> m_outputStrides;
-  array<Index, NumDims> m_inputStrides;
-  TensorEvaluator<ArgType, Device> m_impl;
-  const Strides m_strides;
-  array<internal::TensorIntDivisor<Index>, NumDims> m_fastStrides;
-};
-
-} // end namespace Eigen
-
-#endif // EIGEN_CXX11_TENSOR_TENSOR_INFLATION_H

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

@@ -1,82 +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_INITIALIZER_H
-#define EIGEN_CXX11_TENSOR_TENSOR_INITIALIZER_H
-
-#if EIGEN_HAS_VARIADIC_TEMPLATES
-
-#include <initializer_list>
-
-namespace Eigen {
-
-/** \class TensorInitializer
-  * \ingroup CXX11_Tensor_Module
-  *
-  * \brief Helper template to initialize Tensors from std::initializer_lists.
-  */
-namespace internal {
-
-template <typename Derived, int N>
-struct Initializer {
-  typedef std::initializer_list<
-    typename Initializer<Derived, N - 1>::InitList> InitList;
-
-  static void run(TensorEvaluator<Derived, DefaultDevice>& tensor,
-                  Eigen::array<typename traits<Derived>::Index, traits<Derived>::NumDimensions>* indices,
-                  const InitList& vals) {
-    int i = 0;
-    for (const auto& v : vals) {
-      (*indices)[traits<Derived>::NumDimensions - N] = i++;
-      Initializer<Derived, N - 1>::run(tensor, indices, v);
-    }
-  }
-};
-
-template <typename Derived>
-struct Initializer<Derived, 1> {
-  typedef std::initializer_list<typename traits<Derived>::Scalar> InitList;
-
-  static void run(TensorEvaluator<Derived, DefaultDevice>& tensor,
-                  Eigen::array<typename traits<Derived>::Index, traits<Derived>::NumDimensions>* indices,
-                  const InitList& vals) {
-    int i = 0;
-    // There is likely a faster way to do that than iterating.
-    for (const auto& v : vals) {
-      (*indices)[traits<Derived>::NumDimensions - 1] = i++;
-      tensor.coeffRef(*indices) = v;
-    }
-  }
-};
-
-template <typename Derived>
-struct Initializer<Derived, 0> {
-  typedef typename traits<Derived>::Scalar InitList;
-
-  static void run(TensorEvaluator<Derived, DefaultDevice>& tensor,
-                  Eigen::array<typename traits<Derived>::Index, traits<Derived>::NumDimensions>*,
-                  const InitList& v) {
-    tensor.coeffRef(0) = v;
-  }
-};
-
-
-template <typename Derived, int N>
-void initialize_tensor(TensorEvaluator<Derived, DefaultDevice>& tensor,
-                       const typename Initializer<Derived, traits<Derived>::NumDimensions>::InitList& vals) {
-  Eigen::array<typename traits<Derived>::Index, traits<Derived>::NumDimensions> indices;
-  Initializer<Derived, traits<Derived>::NumDimensions>::run(tensor, &indices, vals);
-}
-
-}  // namespace internal
-}  // namespace Eigen
-
-#endif  // EIGEN_HAS_VARIADIC_TEMPLATES
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_INITIALIZER_H

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

@@ -1,263 +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_INTDIV_H
-#define EIGEN_CXX11_TENSOR_TENSOR_INTDIV_H
-
-
-namespace Eigen {
-
-/** \internal
-  *
-  * \class TensorIntDiv
-  * \ingroup CXX11_Tensor_Module
-  *
-  * \brief Fast integer division by a constant.
-  *
-  * See the paper from Granlund and Montgomery for explanation.
-  *   (at https://doi.org/10.1145/773473.178249)
-  *
-  * \sa Tensor
-  */
-
-namespace internal {
-
-namespace {
-
-  // Note: result is undefined if val == 0
-  template <typename T>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
-  typename internal::enable_if<sizeof(T)==4,int>::type count_leading_zeros(const T val)
-  {
-#ifdef EIGEN_GPU_COMPILE_PHASE
-    return __clz(val);
-#elif defined(SYCL_DEVICE_ONLY)
-    return cl::sycl::clz(val);
-#elif EIGEN_COMP_MSVC
-    unsigned long index;
-    _BitScanReverse(&index, val);
-    return 31 - index;
-#else
-    EIGEN_STATIC_ASSERT(sizeof(unsigned long long) == 8, YOU_MADE_A_PROGRAMMING_MISTAKE);
-    return __builtin_clz(static_cast<uint32_t>(val));
-#endif
-  }
-
-  template <typename T>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
-  typename internal::enable_if<sizeof(T)==8,int>::type count_leading_zeros(const T val)
-  {
-#ifdef EIGEN_GPU_COMPILE_PHASE
-    return __clzll(val);
-#elif defined(SYCL_DEVICE_ONLY)
-    return static_cast<int>(cl::sycl::clz(val));
-#elif EIGEN_COMP_MSVC && EIGEN_ARCH_x86_64
-    unsigned long index;
-    _BitScanReverse64(&index, val);
-    return 63 - index;
-#elif EIGEN_COMP_MSVC
-    // MSVC's _BitScanReverse64 is not available for 32bits builds.
-    unsigned int lo = (unsigned int)(val&0xffffffff);
-    unsigned int hi = (unsigned int)((val>>32)&0xffffffff);
-    int n;
-    if(hi==0)
-      n = 32 + count_leading_zeros<unsigned int>(lo);
-    else
-      n = count_leading_zeros<unsigned int>(hi);
-    return n;
-#else
-    EIGEN_STATIC_ASSERT(sizeof(unsigned long long) == 8, YOU_MADE_A_PROGRAMMING_MISTAKE);
-    return __builtin_clzll(static_cast<uint64_t>(val));
-#endif
-  }
-
-  template <typename T>
-  struct UnsignedTraits {
-    typedef typename conditional<sizeof(T) == 8, uint64_t, uint32_t>::type type;
-  };
-
-  template <typename T>
-  struct DividerTraits {
-    typedef typename UnsignedTraits<T>::type type;
-    static const int N = sizeof(T) * 8;
-  };
-
-  template <typename T>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE uint32_t muluh(const uint32_t a, const T b) {
-#if defined(EIGEN_GPU_COMPILE_PHASE)
-    return __umulhi(a, b);
-#elif defined(SYCL_DEVICE_ONLY)
-    return cl::sycl::mul_hi(a, static_cast<uint32_t>(b));
-#else
-    return (static_cast<uint64_t>(a) * b) >> 32;
-#endif
-  }
-
-  template <typename T>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE uint64_t muluh(const uint64_t a, const T b) {
-#if defined(EIGEN_GPU_COMPILE_PHASE)
-    return __umul64hi(a, b);
-#elif defined(SYCL_DEVICE_ONLY)
-    return cl::sycl::mul_hi(a, static_cast<uint64_t>(b));
-#elif EIGEN_HAS_BUILTIN_INT128
-    __uint128_t v = static_cast<__uint128_t>(a) * static_cast<__uint128_t>(b);
-    return static_cast<uint64_t>(v >> 64);
-#else
-    return (TensorUInt128<static_val<0>, uint64_t>(a) * TensorUInt128<static_val<0>, uint64_t>(b)).upper();
-#endif
-  }
-
-  template <int N, typename T>
-  struct DividerHelper {
-    static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE uint32_t computeMultiplier(const int log_div, const T divider) {
-      EIGEN_STATIC_ASSERT(N == 32, YOU_MADE_A_PROGRAMMING_MISTAKE);
-      return static_cast<uint32_t>((static_cast<uint64_t>(1) << (N+log_div)) / divider - (static_cast<uint64_t>(1) << N) + 1);
-    }
-  };
-
-  template <typename T>
-  struct DividerHelper<64, T> {
-    static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE uint64_t computeMultiplier(const int log_div, const T divider) {
-#if EIGEN_HAS_BUILTIN_INT128 && !defined(EIGEN_GPU_COMPILE_PHASE) && !defined(SYCL_DEVICE_ONLY)
-      return static_cast<uint64_t>((static_cast<__uint128_t>(1) << (64+log_div)) / static_cast<__uint128_t>(divider) - (static_cast<__uint128_t>(1) << 64) + 1);
-#else
-      const uint64_t shift = 1ULL << log_div;
-      TensorUInt128<uint64_t, uint64_t> result = TensorUInt128<uint64_t, static_val<0> >(shift, 0) / TensorUInt128<static_val<0>, uint64_t>(divider)
-                                               - TensorUInt128<static_val<1>, static_val<0> >(1, 0)
-                                               + TensorUInt128<static_val<0>, static_val<1> >(1);
-      return static_cast<uint64_t>(result);
-#endif
-    }
-  };
-}
-
-
-template <typename T, bool div_gt_one = false>
-struct TensorIntDivisor {
- public:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorIntDivisor() {
-    multiplier = 0;
-    shift1 = 0;
-    shift2 = 0;
-  }
-
-  // Must have 0 < divider < 2^31. This is relaxed to
-  // 0 < divider < 2^63 when using 64-bit indices on platforms that support
-  // the __uint128_t type.
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorIntDivisor(const T divider) {
-    const int N = DividerTraits<T>::N;
-    eigen_assert(static_cast<typename UnsignedTraits<T>::type>(divider) < NumTraits<UnsignedType>::highest()/2);
-    eigen_assert(divider > 0);
-
-    // fast ln2
-    const int leading_zeros = count_leading_zeros(static_cast<UnsignedType>(divider));
-    int log_div = N - leading_zeros;
-    // if divider is a power of two then log_div is 1 more than it should be.
-    if ((static_cast<typename UnsignedTraits<T>::type>(1) << (log_div-1)) == static_cast<typename UnsignedTraits<T>::type>(divider))
-      log_div--;
-
-    multiplier = DividerHelper<N, T>::computeMultiplier(log_div, divider);
-    shift1 = log_div > 1 ? 1 : log_div;
-    shift2 = log_div > 1 ? log_div-1 : 0;
-  }
-
-  // Must have 0 <= numerator. On platforms that don't support the __uint128_t
-  // type numerator should also be less than 2^32-1.
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T divide(const T numerator) const {
-    eigen_assert(static_cast<typename UnsignedTraits<T>::type>(numerator) < NumTraits<UnsignedType>::highest()/2);
-    //eigen_assert(numerator >= 0); // this is implicitly asserted by the line above
-
-    UnsignedType t1 = muluh(multiplier, numerator);
-    UnsignedType t = (static_cast<UnsignedType>(numerator) - t1) >> shift1;
-    return (t1 + t) >> shift2;
-  }
-
- private:
-  typedef typename DividerTraits<T>::type UnsignedType;
-  UnsignedType multiplier;
-  int32_t shift1;
-  int32_t shift2;
-};
-
-
-// Optimized version for signed 32 bit integers.
-// Derived from Hacker's Delight.
-// Only works for divisors strictly greater than one
-template <>
-class TensorIntDivisor<int32_t, true> {
- public:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorIntDivisor() {
-    magic = 0;
-    shift = 0;
-  }
-  // Must have 2 <= divider
-  EIGEN_DEVICE_FUNC TensorIntDivisor(int32_t divider)  {
-    eigen_assert(divider >= 2);
-    calcMagic(divider);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE int divide(const int32_t n) const {
-#ifdef EIGEN_GPU_COMPILE_PHASE
-    return (__umulhi(magic, n) >> shift);
-#elif defined(SYCL_DEVICE_ONLY)
-    return (cl::sycl::mul_hi(magic, static_cast<uint32_t>(n)) >> shift);
-#else
-    uint64_t v = static_cast<uint64_t>(magic) * static_cast<uint64_t>(n);
-    return (static_cast<uint32_t>(v >> 32) >> shift);
-#endif
-  }
-
-private:
-  // Compute the magic numbers. See Hacker's Delight section 10 for an in
-  // depth explanation.
-  EIGEN_DEVICE_FUNC void calcMagic(int32_t d) {
-   const unsigned two31 = 0x80000000;     // 2**31.
-   unsigned ad = d;
-   unsigned t = two31 + (ad >> 31);
-   unsigned anc = t - 1 - t%ad;     // Absolute value of nc.
-   int p = 31;                      // Init. p.
-   unsigned q1 = two31/anc;         // Init. q1 = 2**p/|nc|.
-   unsigned r1 = two31 - q1*anc;    // Init. r1 = rem(2**p, |nc|).
-   unsigned q2 = two31/ad;          // Init. q2 = 2**p/|d|.
-   unsigned r2 = two31 - q2*ad;     // Init. r2 = rem(2**p, |d|).
-   unsigned delta = 0;
-   do {
-      p = p + 1;
-      q1 = 2*q1;           // Update q1 = 2**p/|nc|.
-      r1 = 2*r1;           // Update r1 = rem(2**p, |nc|).
-      if (r1 >= anc) {     // (Must be an unsigned
-         q1 = q1 + 1;      // comparison here).
-         r1 = r1 - anc;}
-      q2 = 2*q2;           // Update q2 = 2**p/|d|.
-      r2 = 2*r2;           // Update r2 = rem(2**p, |d|).
-      if (r2 >= ad) {      // (Must be an unsigned
-         q2 = q2 + 1;      // comparison here).
-         r2 = r2 - ad;}
-      delta = ad - r2;
-   } while (q1 < delta || (q1 == delta && r1 == 0));
-
-   magic = (unsigned)(q2 + 1);
-   shift = p - 32;
-  }
-
-  uint32_t magic;
-  int32_t shift;
-};
-
-
-template <typename T, bool div_gt_one>
-static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator / (const T& numerator, const TensorIntDivisor<T, div_gt_one>& divisor) {
-  return divisor.divide(numerator);
-}
-
-
-} // end namespace internal
-} // end namespace Eigen
-
-#endif // EIGEN_CXX11_TENSOR_TENSOR_INTDIV_H