sequenzo 0.1.18__cp311-cp311-win_amd64.whl → 0.1.20__cp311-cp311-win_amd64.whl

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

@@ -1,302 +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_GENERATOR_H
-#define EIGEN_CXX11_TENSOR_TENSOR_GENERATOR_H
-
-namespace Eigen {
-
-/** \class TensorGeneratorOp
-  * \ingroup CXX11_Tensor_Module
-  *
-  * \brief Tensor generator class.
-  *
-  *
-  */
-namespace internal {
-template<typename Generator, typename XprType>
-struct traits<TensorGeneratorOp<Generator, 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 Generator, typename XprType>
-struct eval<TensorGeneratorOp<Generator, XprType>, Eigen::Dense>
-{
-  typedef const TensorGeneratorOp<Generator, XprType>& type;
-};
-
-template<typename Generator, typename XprType>
-struct nested<TensorGeneratorOp<Generator, XprType>, 1, typename eval<TensorGeneratorOp<Generator, XprType> >::type>
-{
-  typedef TensorGeneratorOp<Generator, XprType> type;
-};
-
-}  // end namespace internal
-
-
-
-template<typename Generator, typename XprType>
-class TensorGeneratorOp : public TensorBase<TensorGeneratorOp<Generator, XprType>, ReadOnlyAccessors>
-{
-  public:
-  typedef typename Eigen::internal::traits<TensorGeneratorOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorGeneratorOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorGeneratorOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorGeneratorOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorGeneratorOp(const XprType& expr, const Generator& generator)
-      : m_xpr(expr), m_generator(generator) {}
-
-    EIGEN_DEVICE_FUNC
-    const Generator& generator() const { return m_generator; }
-
-    EIGEN_DEVICE_FUNC
-    const typename internal::remove_all<typename XprType::Nested>::type&
-    expression() const { return m_xpr; }
-
-  protected:
-    typename XprType::Nested m_xpr;
-    const Generator m_generator;
-};
-
-
-// Eval as rvalue
-template<typename Generator, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorGeneratorOp<Generator, ArgType>, Device>
-{
-  typedef TensorGeneratorOp<Generator, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  typedef typename TensorEvaluator<ArgType, Device>::Dimensions Dimensions;
-  static const int NumDims = internal::array_size<Dimensions>::value;
-  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      = (PacketType<CoeffReturnType, Device>::size > 1),
-    BlockAccess       = true,
-    PreferBlockAccess = true,
-    Layout            = TensorEvaluator<ArgType, Device>::Layout,
-    CoordAccess       = false,  // to be implemented
-    RawAccess         = false
-  };
-
-  typedef internal::TensorIntDivisor<Index> IndexDivisor;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  typedef typename internal::TensorMaterializedBlock<CoeffReturnType, NumDims,
-                                                     Layout, Index>
-      TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      :  m_device(device), m_generator(op.generator())
-  {
-    TensorEvaluator<ArgType, Device> argImpl(op.expression(), device);
-    m_dimensions = argImpl.dimensions();
-
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_strides[0] = 1;
-      EIGEN_UNROLL_LOOP
-      for (int i = 1; i < NumDims; ++i) {
-        m_strides[i] = m_strides[i - 1] * m_dimensions[i - 1];
-        if (m_strides[i] != 0) m_fast_strides[i] = IndexDivisor(m_strides[i]);
-      }
-    } else {
-      m_strides[NumDims - 1] = 1;
-      EIGEN_UNROLL_LOOP
-      for (int i = NumDims - 2; i >= 0; --i) {
-        m_strides[i] = m_strides[i + 1] * m_dimensions[i + 1];
-        if (m_strides[i] != 0) m_fast_strides[i] = IndexDivisor(m_strides[i]);
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
-    return true;
-  }
-  EIGEN_STRONG_INLINE void cleanup() {
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
-  {
-    array<Index, NumDims> coords;
-    extract_coordinates(index, coords);
-    return m_generator(coords);
-  }
-
-  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 typename internal::remove_const<CoeffReturnType>::type values[packetSize];
-    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
-  internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    const size_t target_size = m_device.firstLevelCacheSize();
-    // TODO(ezhulenev): Generator should have a cost.
-    return internal::TensorBlockResourceRequirements::skewed<Scalar>(
-        target_size);
-  }
-
-  struct BlockIteratorState {
-    Index stride;
-    Index span;
-    Index size;
-    Index count;
-  };
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock
-  block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-          bool /*root_of_expr_ast*/ = false) const {
-    static const bool is_col_major =
-        static_cast<int>(Layout) == static_cast<int>(ColMajor);
-
-    // Compute spatial coordinates for the first block element.
-    array<Index, NumDims> coords;
-    extract_coordinates(desc.offset(), coords);
-    array<Index, NumDims> initial_coords = coords;
-
-    // Offset in the output block buffer.
-    Index offset = 0;
-
-    // Initialize output block iterator state. Dimension in this array are
-    // always in inner_most -> outer_most order (col major layout).
-    array<BlockIteratorState, NumDims> it;
-    for (int i = 0; i < NumDims; ++i) {
-      const int dim = is_col_major ? i : NumDims - 1 - i;
-      it[i].size = desc.dimension(dim);
-      it[i].stride = i == 0 ? 1 : (it[i - 1].size * it[i - 1].stride);
-      it[i].span = it[i].stride * (it[i].size - 1);
-      it[i].count = 0;
-    }
-    eigen_assert(it[0].stride == 1);
-
-    // Prepare storage for the materialized generator result.
-    const typename TensorBlock::Storage block_storage =
-        TensorBlock::prepareStorage(desc, scratch);
-
-    CoeffReturnType* block_buffer = block_storage.data();
-
-    static const int packet_size = PacketType<CoeffReturnType, Device>::size;
-
-    static const int inner_dim = is_col_major ? 0 : NumDims - 1;
-    const Index inner_dim_size = it[0].size;
-    const Index inner_dim_vectorized = inner_dim_size - packet_size;
-
-    while (it[NumDims - 1].count < it[NumDims - 1].size) {
-      Index i = 0;
-      // Generate data for the vectorized part of the inner-most dimension.
-      for (; i <= inner_dim_vectorized; i += packet_size) {
-        for (Index j = 0; j < packet_size; ++j) {
-          array<Index, NumDims> j_coords = coords;  // Break loop dependence.
-          j_coords[inner_dim] += j;
-          *(block_buffer + offset + i + j) = m_generator(j_coords);
-        }
-        coords[inner_dim] += packet_size;
-      }
-      // Finalize non-vectorized part of the inner-most dimension.
-      for (; i < inner_dim_size; ++i) {
-        *(block_buffer + offset + i) = m_generator(coords);
-        coords[inner_dim]++;
-      }
-      coords[inner_dim] = initial_coords[inner_dim];
-
-      // For the 1d tensor we need to generate only one inner-most dimension.
-      if (NumDims == 1) break;
-
-      // Update offset.
-      for (i = 1; i < NumDims; ++i) {
-        if (++it[i].count < it[i].size) {
-          offset += it[i].stride;
-          coords[is_col_major ? i : NumDims - 1 - i]++;
-          break;
-        }
-        if (i != NumDims - 1) it[i].count = 0;
-        coords[is_col_major ? i : NumDims - 1 - i] =
-            initial_coords[is_col_major ? i : NumDims - 1 - i];
-        offset -= it[i].span;
-      }
-    }
-
-    return block_storage.AsTensorMaterializedBlock();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost
-  costPerCoeff(bool) const {
-    // TODO(rmlarsen): This is just a placeholder. Define interface to make
-    // generators return their cost.
-    return TensorOpCost(0, 0, TensorOpCost::AddCost<Scalar>() +
-                                  TensorOpCost::MulCost<Scalar>());
-  }
-
-  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&) const {}
-#endif
-
- protected:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  void extract_coordinates(Index index, array<Index, NumDims>& coords) const {
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int i = NumDims - 1; i > 0; --i) {
-        const Index idx = index / m_fast_strides[i];
-        index -= idx * m_strides[i];
-        coords[i] = idx;
-      }
-      coords[0] = index;
-    } else {
-      for (int i = 0; i < NumDims - 1; ++i) {
-        const Index idx = index / m_fast_strides[i];
-        index -= idx * m_strides[i];
-        coords[i] = idx;
-      }
-      coords[NumDims-1] = index;
-    }
-  }
-
-  const Device EIGEN_DEVICE_REF m_device;
-  Dimensions m_dimensions;
-  array<Index, NumDims> m_strides;
-  array<IndexDivisor, NumDims> m_fast_strides;
-  Generator m_generator;
-};
-
-} // end namespace Eigen
-
-#endif // EIGEN_CXX11_TENSOR_TENSOR_GENERATOR_H

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

@@ -1,33 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Eugene Brevdo <ebrevdo@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_GLOBAL_FUNCTIONS_H
-#define EIGEN_CXX11_TENSOR_TENSOR_GLOBAL_FUNCTIONS_H
-
-namespace Eigen {
-
-/** \cpp11 \returns an expression of the coefficient-wise betainc(\a x, \a a, \a b) to the given tensors.
- *
- * This function computes the regularized incomplete beta function (integral).
- *
- */
-template <typename ADerived, typename BDerived, typename XDerived>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const
-    TensorCwiseTernaryOp<internal::scalar_betainc_op<typename XDerived::Scalar>,
-                         const ADerived, const BDerived, const XDerived>
-    betainc(const ADerived& a, const BDerived& b, const XDerived& x) {
-  return TensorCwiseTernaryOp<
-      internal::scalar_betainc_op<typename XDerived::Scalar>, const ADerived,
-      const BDerived, const XDerived>(
-      a, b, x, internal::scalar_betainc_op<typename XDerived::Scalar>());
-}
-
-} // end namespace Eigen
-
-#endif // EIGEN_CXX11_TENSOR_TENSOR_GLOBAL_FUNCTIONS_H

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

@@ -1,99 +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>
-// Copyright (C) 2018 Deven Desai <deven.desai.amd@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/.
-
-#if defined(EIGEN_USE_GPU) && !defined(EIGEN_CXX11_TENSOR_GPU_HIP_CUDA_DEFINES_H)
-#define EIGEN_CXX11_TENSOR_GPU_HIP_CUDA_DEFINES_H
-
-// Note that we are using EIGEN_USE_HIP here instead of EIGEN_HIPCC...this is by design
-// There is code in the Tensorflow codebase that will define EIGEN_USE_GPU,  but
-// for some reason gets sent to the gcc/host compiler instead of the gpu/nvcc/hipcc compiler
-// When compiling such files, gcc will end up trying to pick up the CUDA headers by 
-// default (see the code within "unsupported/Eigen/CXX11/Tensor" that is guarded by EIGEN_USE_GPU)
-// This will obviously not work when trying to compile tensorflow on a system with no CUDA
-// To work around this issue for HIP systems (and leave the default behaviour intact), the
-// HIP tensorflow build defines EIGEN_USE_HIP when compiling all source files, and 
-// "unsupported/Eigen/CXX11/Tensor" has been updated to use HIP header when EIGEN_USE_HIP is
-// defined. In continuation of that requirement, the guard here needs to be EIGEN_USE_HIP as well
-
-#if defined(EIGEN_USE_HIP)
-
-#define gpuStream_t hipStream_t
-#define gpuDeviceProp_t hipDeviceProp_t
-#define gpuError_t hipError_t
-#define gpuSuccess hipSuccess
-#define gpuErrorNotReady hipErrorNotReady
-#define gpuGetDeviceCount hipGetDeviceCount
-#define gpuGetLastError hipGetLastError
-#define gpuPeekAtLastError hipPeekAtLastError
-#define gpuGetErrorName hipGetErrorName
-#define gpuGetErrorString hipGetErrorString
-#define gpuGetDeviceProperties hipGetDeviceProperties
-#define gpuStreamDefault hipStreamDefault
-#define gpuGetDevice hipGetDevice
-#define gpuSetDevice hipSetDevice
-#define gpuMalloc hipMalloc
-#define gpuFree hipFree
-#define gpuMemsetAsync hipMemsetAsync
-#define gpuMemcpyAsync hipMemcpyAsync
-#define gpuMemcpyDeviceToDevice hipMemcpyDeviceToDevice
-#define gpuMemcpyDeviceToHost hipMemcpyDeviceToHost
-#define gpuMemcpyHostToDevice hipMemcpyHostToDevice
-#define gpuStreamQuery hipStreamQuery
-#define gpuSharedMemConfig hipSharedMemConfig
-#define gpuDeviceSetSharedMemConfig hipDeviceSetSharedMemConfig
-#define gpuStreamSynchronize hipStreamSynchronize
-#define gpuDeviceSynchronize hipDeviceSynchronize
-#define gpuMemcpy hipMemcpy
-
-#else
-
-#define gpuStream_t cudaStream_t
-#define gpuDeviceProp_t cudaDeviceProp
-#define gpuError_t cudaError_t
-#define gpuSuccess cudaSuccess
-#define gpuErrorNotReady cudaErrorNotReady
-#define gpuGetDeviceCount cudaGetDeviceCount
-#define gpuGetLastError cudaGetLastError
-#define gpuPeekAtLastError cudaPeekAtLastError
-#define gpuGetErrorName cudaGetErrorName
-#define gpuGetErrorString cudaGetErrorString
-#define gpuGetDeviceProperties cudaGetDeviceProperties
-#define gpuStreamDefault cudaStreamDefault
-#define gpuGetDevice cudaGetDevice
-#define gpuSetDevice cudaSetDevice
-#define gpuMalloc cudaMalloc
-#define gpuFree cudaFree
-#define gpuMemsetAsync cudaMemsetAsync
-#define gpuMemcpyAsync cudaMemcpyAsync
-#define gpuMemcpyDeviceToDevice cudaMemcpyDeviceToDevice
-#define gpuMemcpyDeviceToHost cudaMemcpyDeviceToHost
-#define gpuMemcpyHostToDevice cudaMemcpyHostToDevice
-#define gpuStreamQuery cudaStreamQuery
-#define gpuSharedMemConfig cudaSharedMemConfig
-#define gpuDeviceSetSharedMemConfig cudaDeviceSetSharedMemConfig
-#define gpuStreamSynchronize cudaStreamSynchronize
-#define gpuDeviceSynchronize cudaDeviceSynchronize
-#define gpuMemcpy cudaMemcpy
-
-#endif
-
-// gpu_assert can be overridden
-#ifndef gpu_assert
-
-#if defined(EIGEN_HIP_DEVICE_COMPILE)
-// HIPCC do not support the use of assert on the GPU side.
-#define gpu_assert(COND)
-#else
-#define gpu_assert(COND) assert(COND)
-#endif
-
-#endif // gpu_assert
-
-#endif  // EIGEN_CXX11_TENSOR_GPU_HIP_CUDA_DEFINES_H

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

@@ -1,44 +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>
-// Copyright (C) 2018 Deven Desai <deven.desai.amd@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/.
-
-#if defined(EIGEN_CXX11_TENSOR_GPU_HIP_CUDA_DEFINES_H)
-
-#ifndef EIGEN_PERMANENTLY_ENABLE_GPU_HIP_CUDA_DEFINES
-
-#undef gpuStream_t
-#undef gpuDeviceProp_t 
-#undef gpuError_t
-#undef gpuSuccess
-#undef gpuErrorNotReady
-#undef gpuGetDeviceCount
-#undef gpuGetErrorString
-#undef gpuGetDeviceProperties
-#undef gpuStreamDefault
-#undef gpuGetDevice
-#undef gpuSetDevice
-#undef gpuMalloc
-#undef gpuFree
-#undef gpuMemsetAsync
-#undef gpuMemcpyAsync
-#undef gpuMemcpyDeviceToDevice
-#undef gpuMemcpyDeviceToHost
-#undef gpuMemcpyHostToDevice
-#undef gpuStreamQuery
-#undef gpuSharedMemConfig
-#undef gpuDeviceSetSharedMemConfig
-#undef gpuStreamSynchronize
-#undef gpuDeviceSynchronize
-#undef gpuMemcpy
-
-#endif // EIGEN_PERMANENTLY_ENABLE_GPU_HIP_CUDA_DEFINES
-
-#undef EIGEN_CXX11_TENSOR_GPU_HIP_CUDA_DEFINES_H
-
-#endif // EIGEN_CXX11_TENSOR_GPU_HIP_CUDA_DEFINES_H

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

@@ -1,79 +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_IO_H
-#define EIGEN_CXX11_TENSOR_TENSOR_IO_H
-
-namespace Eigen {
-
-namespace internal {
-
-// Print the tensor as a 2d matrix
-template <typename Tensor, int Rank>
-struct TensorPrinter {
-  static void run (std::ostream& os, const Tensor& tensor) {
-    typedef typename internal::remove_const<typename Tensor::Scalar>::type Scalar;
-    typedef typename Tensor::Index Index;
-    const Index total_size = internal::array_prod(tensor.dimensions());
-    if (total_size > 0) {
-      const Index first_dim = Eigen::internal::array_get<0>(tensor.dimensions());
-      static const int layout = Tensor::Layout;
-      Map<const Array<Scalar, Dynamic, Dynamic, layout> > matrix(const_cast<Scalar*>(tensor.data()), first_dim, total_size/first_dim);
-      os << matrix;
-    }
-  }
-};
-
-
-// Print the tensor as a vector
-template <typename Tensor>
-struct TensorPrinter<Tensor, 1> {
-  static void run (std::ostream& os, const Tensor& tensor) {
-    typedef typename internal::remove_const<typename Tensor::Scalar>::type Scalar;
-    typedef typename Tensor::Index Index;
-    const Index total_size = internal::array_prod(tensor.dimensions());
-    if (total_size > 0) {
-      Map<const Array<Scalar, Dynamic, 1> > array(const_cast<Scalar*>(tensor.data()), total_size);
-      os << array;
-    }
-  }
-};
-
-
-// Print the tensor as a scalar
-template <typename Tensor>
-struct TensorPrinter<Tensor, 0> {
-  static void run (std::ostream& os, const Tensor& tensor) {
-    os << tensor.coeff(0);
-  }
-};
-}
-
-template <typename T>
-std::ostream& operator << (std::ostream& os, const TensorBase<T, ReadOnlyAccessors>& expr) {
-  typedef TensorEvaluator<const TensorForcedEvalOp<const T>, DefaultDevice> Evaluator;
-  typedef typename Evaluator::Dimensions Dimensions;
-
-  // Evaluate the expression if needed
-  TensorForcedEvalOp<const T> eval = expr.eval();
-  Evaluator tensor(eval, DefaultDevice());
-  tensor.evalSubExprsIfNeeded(NULL);
-
-  // Print the result
-  static const int rank = internal::array_size<Dimensions>::value;
-  internal::TensorPrinter<Evaluator, rank>::run(os, tensor);
-
-  // Cleanup.
-  tensor.cleanup();
-  return os;
-}
-
-} // end namespace Eigen
-
-#endif // EIGEN_CXX11_TENSOR_TENSOR_IO_H