xtgeo 4.10.0__cp310-cp310-macosx_11_0_arm64.whl → 4.11.0__cp310-cp310-macosx_11_0_arm64.whl

xtgeo/include/eigen3/unsupported/Eigen/AlignedVector3

@@ -1,234 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Gael Guennebaud <g.gael@free.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 EIGEN_ALIGNED_VECTOR3
-#define EIGEN_ALIGNED_VECTOR3
-
-#include "../../Eigen/Geometry"
-
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-namespace Eigen {
-
-/**
-  * \defgroup AlignedVector3_Module Aligned vector3 module
-  *
-  * \code
-  * #include <unsupported/Eigen/AlignedVector3>
-  * \endcode
-  */
-  //@{
-
-
-/** \class AlignedVector3
-  *
-  * \brief A vectorization friendly 3D vector
-  *
-  * This class represents a 3D vector internally using a 4D vector
-  * such that vectorization can be seamlessly enabled. Of course,
-  * the same result can be achieved by directly using a 4D vector.
-  * This class makes this process simpler.
-  *
-  */
-// TODO specialize Cwise
-template<typename _Scalar> class AlignedVector3;
-
-namespace internal {
-template<typename _Scalar> struct traits<AlignedVector3<_Scalar> >
-  : traits<Matrix<_Scalar,3,1,0,4,1> >
-{
-};
-}
-
-template<typename _Scalar> class AlignedVector3
-  : public MatrixBase<AlignedVector3<_Scalar> >
-{
-    typedef Matrix<_Scalar,4,1> CoeffType;
-    CoeffType m_coeffs;
-  public:
-
-    typedef MatrixBase<AlignedVector3<_Scalar> > Base;	
-    EIGEN_DENSE_PUBLIC_INTERFACE(AlignedVector3)
-    using Base::operator*;
-
-    inline Index rows() const { return 3; }
-    inline Index cols() const { return 1; }
-    
-    Scalar* data() { return m_coeffs.data(); }
-    const Scalar* data() const { return m_coeffs.data(); }
-    Index innerStride() const { return 1; }
-    Index outerStride() const { return 3; }
-
-    inline const Scalar& coeff(Index row, Index col) const
-    { return m_coeffs.coeff(row, col); }
-
-    inline Scalar& coeffRef(Index row, Index col)
-    { return m_coeffs.coeffRef(row, col); }
-
-    inline const Scalar& coeff(Index index) const
-    { return m_coeffs.coeff(index); }
-
-    inline Scalar& coeffRef(Index index)
-    { return m_coeffs.coeffRef(index);}
-
-
-    inline AlignedVector3()
-    {}
-
-    inline AlignedVector3(const Scalar& x, const Scalar& y, const Scalar& z)
-      : m_coeffs(x, y, z, Scalar(0))
-    {}
-
-    inline AlignedVector3(const AlignedVector3& other)
-      : Base(), m_coeffs(other.m_coeffs)
-    {}
-
-    template<typename XprType, int Size=XprType::SizeAtCompileTime>
-    struct generic_assign_selector {};
-
-    template<typename XprType> struct generic_assign_selector<XprType,4>
-    {
-      inline static void run(AlignedVector3& dest, const XprType& src)
-      {
-        dest.m_coeffs = src;
-      }
-    };
-
-    template<typename XprType> struct generic_assign_selector<XprType,3>
-    {
-      inline static void run(AlignedVector3& dest, const XprType& src)
-      {
-        dest.m_coeffs.template head<3>() = src;
-        dest.m_coeffs.w() = Scalar(0);
-      }
-    };
-
-    template<typename Derived>
-    inline AlignedVector3(const MatrixBase<Derived>& other)
-    {
-      generic_assign_selector<Derived>::run(*this,other.derived());
-    }
-
-    inline AlignedVector3& operator=(const AlignedVector3& other)
-    { m_coeffs = other.m_coeffs; return *this; }
-
-    template <typename Derived>
-    inline AlignedVector3& operator=(const MatrixBase<Derived>& other)
-    {
-      generic_assign_selector<Derived>::run(*this,other.derived());
-      return *this;
-    }
-
-    inline AlignedVector3 operator+(const AlignedVector3& other) const
-    { return AlignedVector3(m_coeffs + other.m_coeffs); }
-
-    inline AlignedVector3& operator+=(const AlignedVector3& other)
-    { m_coeffs += other.m_coeffs; return *this; }
-
-    inline AlignedVector3 operator-(const AlignedVector3& other) const
-    { return AlignedVector3(m_coeffs - other.m_coeffs); }
-
-    inline AlignedVector3 operator-() const
-    { return AlignedVector3(-m_coeffs); }
-
-    inline AlignedVector3 operator-=(const AlignedVector3& other)
-    { m_coeffs -= other.m_coeffs; return *this; }
-
-    inline AlignedVector3 operator*(const Scalar& s) const
-    { return AlignedVector3(m_coeffs * s); }
-
-    inline friend AlignedVector3 operator*(const Scalar& s,const AlignedVector3& vec)
-    { return AlignedVector3(s * vec.m_coeffs); }
-
-    inline AlignedVector3& operator*=(const Scalar& s)
-    { m_coeffs *= s; return *this; }
-
-    inline AlignedVector3 operator/(const Scalar& s) const
-    { return AlignedVector3(m_coeffs / s); }
-
-    inline AlignedVector3& operator/=(const Scalar& s)
-    { m_coeffs /= s; return *this; }
-
-    inline Scalar dot(const AlignedVector3& other) const
-    {
-      eigen_assert(m_coeffs.w()==Scalar(0));
-      eigen_assert(other.m_coeffs.w()==Scalar(0));
-      return m_coeffs.dot(other.m_coeffs);
-    }
-
-    inline void normalize()
-    {
-      m_coeffs /= norm();
-    }
-
-    inline AlignedVector3 normalized() const
-    {
-      return AlignedVector3(m_coeffs / norm());
-    }
-
-    inline Scalar sum() const
-    {
-      eigen_assert(m_coeffs.w()==Scalar(0));
-      return m_coeffs.sum();
-    }
-
-    inline Scalar squaredNorm() const
-    {
-      eigen_assert(m_coeffs.w()==Scalar(0));
-      return m_coeffs.squaredNorm();
-    }
-
-    inline Scalar norm() const
-    {
-      using std::sqrt;
-      return sqrt(squaredNorm());
-    }
-
-    inline AlignedVector3 cross(const AlignedVector3& other) const
-    {
-      return AlignedVector3(m_coeffs.cross3(other.m_coeffs));
-    }
-
-    template<typename Derived>
-    inline bool isApprox(const MatrixBase<Derived>& other, const RealScalar& eps=NumTraits<Scalar>::dummy_precision()) const
-    {
-      return m_coeffs.template head<3>().isApprox(other,eps);
-    }
-    
-    CoeffType& coeffs() { return m_coeffs; }
-    const CoeffType& coeffs() const { return m_coeffs; }
-};
-
-namespace internal {
-
-template<typename _Scalar>
-struct eval<AlignedVector3<_Scalar>, Dense>
-{
- typedef const AlignedVector3<_Scalar>& type;
-};
-
-template<typename Scalar>
-struct evaluator<AlignedVector3<Scalar> >
-  : evaluator<Matrix<Scalar,4,1> >
-{
-  typedef AlignedVector3<Scalar> XprType;
-  typedef evaluator<Matrix<Scalar,4,1> > Base;
-  
-  evaluator(const XprType &m) : Base(m.coeffs()) {}  
-};
-
-}
-
-//@}
-
-}
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif // EIGEN_ALIGNED_VECTOR3

xtgeo/include/eigen3/unsupported/Eigen/ArpackSupport

@@ -1,30 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-//
-// 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_ARPACKSUPPORT_MODULE_H
-#define EIGEN_ARPACKSUPPORT_MODULE_H
-
-#include "../../Eigen/Core"
-
-/** \defgroup ArpackSupport_Module Arpack support module
-  *
-  * This module provides a wrapper to Arpack, a library for sparse eigenvalue decomposition.
-  *
-  * \code
-  * #include <Eigen/ArpackSupport>
-  * \endcode
-  */
-
-#include "../../Eigen/SparseCholesky"
-
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-#include "src/Eigenvalues/ArpackSelfAdjointEigenSolver.h"
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif // EIGEN_ARPACKSUPPORT_MODULE_H

xtgeo/include/eigen3/unsupported/Eigen/AutoDiff

@@ -1,46 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008-2009 Gael Guennebaud <g.gael@free.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 EIGEN_AUTODIFF_MODULE
-#define EIGEN_AUTODIFF_MODULE
-
-namespace Eigen {
-
-/**
-  * \defgroup AutoDiff_Module Auto Diff module
-  *
-  * This module features forward automatic differentation via a simple
-  * templated scalar type wrapper AutoDiffScalar.
-  *
-  * Warning : this should NOT be confused with numerical differentiation, which
-  * is a different method and has its own module in Eigen : \ref NumericalDiff_Module.
-  *
-  * \code
-  * #include <unsupported/Eigen/AutoDiff>
-  * \endcode
-  */
-//@{
-
-}
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-
-#include "src/AutoDiff/AutoDiffScalar.h"
-// #include "src/AutoDiff/AutoDiffVector.h"
-#include "src/AutoDiff/AutoDiffJacobian.h"
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-
-
-namespace Eigen {
-//@}
-}
-
-#endif // EIGEN_AUTODIFF_MODULE

xtgeo/include/eigen3/unsupported/Eigen/BVH

@@ -1,95 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Ilya Baran <ibaran@mit.edu>
-//
-// 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_BVH_MODULE_H
-#define EIGEN_BVH_MODULE_H
-
-#include "../../Eigen/Core"
-#include "../../Eigen/Geometry"
-#include "../../Eigen/StdVector"
-#include <algorithm>
-#include <queue>
-
-namespace Eigen {
-
-/**
-  * \defgroup BVH_Module BVH module
-  * \brief This module provides generic bounding volume hierarchy algorithms
-  * and reference tree implementations.
-  *
-  *
-  * \code
-  * #include <unsupported/Eigen/BVH>
-  * \endcode
-  *
-  * A bounding volume hierarchy (BVH) can accelerate many geometric queries.  This module provides a generic implementation
-  * of the two basic algorithms over a BVH: intersection of a query object against all objects in the hierarchy and minimization
-  * of a function over the objects in the hierarchy.  It also provides intersection and minimization over a cartesian product of
-  * two BVH's.  A BVH accelerates intersection by using the fact that if a query object does not intersect a volume, then it cannot
-  * intersect any object contained in that volume.  Similarly, a BVH accelerates minimization because the minimum of a function
-  * over a volume is no greater than the minimum of a function over any object contained in it.
-  *
-  * Some sample queries that can be written in terms of intersection are:
-  *   - Determine all points where a ray intersects a triangle mesh
-  *   - Given a set of points, determine which are contained in a query sphere
-  *   - Given a set of spheres, determine which contain the query point
-  *   - Given a set of disks, determine if any is completely contained in a query rectangle (represent each 2D disk as a point \f$(x,y,r)\f$
-  *     in 3D and represent the rectangle as a pyramid based on the original rectangle and shrinking in the \f$r\f$ direction)
-  *   - Given a set of points, count how many pairs are \f$d\pm\epsilon\f$ apart (done by looking at the cartesian product of the set
-  *     of points with itself)
-  *
-  * Some sample queries that can be written in terms of function minimization over a set of objects are:
-  *   - Find the intersection between a ray and a triangle mesh closest to the ray origin (function is infinite off the ray)
-  *   - Given a polyline and a query point, determine the closest point on the polyline to the query
-  *   - Find the diameter of a point cloud (done by looking at the cartesian product and using negative distance as the function)
-  *   - Determine how far two meshes are from colliding (this is also a cartesian product query)
-  *
-  * This implementation decouples the basic algorithms both from the type of hierarchy (and the types of the bounding volumes) and
-  * from the particulars of the query.  To enable abstraction from the BVH, the BVH is required to implement a generic mechanism
-  * for traversal.  To abstract from the query, the query is responsible for keeping track of results.
-  *
-  * To be used in the algorithms, a hierarchy must implement the following traversal mechanism (see KdBVH for a sample implementation): \code
-      typedef Volume  //the type of bounding volume
-      typedef Object  //the type of object in the hierarchy
-      typedef Index   //a reference to a node in the hierarchy--typically an int or a pointer
-      typedef VolumeIterator //an iterator type over node children--returns Index
-      typedef ObjectIterator //an iterator over object (leaf) children--returns const Object &
-      Index getRootIndex() const //returns the index of the hierarchy root
-      const Volume &getVolume(Index index) const //returns the bounding volume of the node at given index
-      void getChildren(Index index, VolumeIterator &outVBegin, VolumeIterator &outVEnd,
-                      ObjectIterator &outOBegin, ObjectIterator &outOEnd) const
-      //getChildren takes a node index and makes [outVBegin, outVEnd) range over its node children
-      //and [outOBegin, outOEnd) range over its object children
-    \endcode
-  *
-  * To use the hierarchy, call BVIntersect or BVMinimize, passing it a BVH (or two, for cartesian product) and a minimizer or intersector.
-  * For an intersection query on a single BVH, the intersector encapsulates the query and must provide two functions:
-  * \code
-      bool intersectVolume(const Volume &volume) //returns true if the query intersects the volume
-      bool intersectObject(const Object &object) //returns true if the intersection search should terminate immediately
-    \endcode
-  * The guarantee that BVIntersect provides is that intersectObject will be called on every object whose bounding volume
-  * intersects the query (but possibly on other objects too) unless the search is terminated prematurely.  It is the
-  * responsibility of the intersectObject function to keep track of the results in whatever manner is appropriate.
-  * The cartesian product intersection and the BVMinimize queries are similar--see their individual documentation.
-  *
-  * The following is a simple but complete example for how to use the BVH to accelerate the search for a closest red-blue point pair:
-  * \include BVH_Example.cpp
-  * Output: \verbinclude BVH_Example.out
-  */
-}
-
-//@{
-
-#include "src/BVH/BVAlgorithms.h"
-#include "src/BVH/KdBVH.h"
-
-//@}
-
-#endif // EIGEN_BVH_MODULE_H

xtgeo/include/eigen3/unsupported/Eigen/CXX11/Tensor

@@ -1,137 +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) 2013 Christian Seiler <christian@iwakd.de>
-//
-// 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_MODULE
-//#define EIGEN_CXX11_TENSOR_MODULE
-
-#include "../../../Eigen/Core"
-
-#if EIGEN_HAS_CXX11
-
-#include "../SpecialFunctions"
-
-#include "../../../Eigen/src/Core/util/DisableStupidWarnings.h"
-#include "src/util/CXX11Meta.h"
-#include "src/util/MaxSizeVector.h"
-
-/** \defgroup CXX11_Tensor_Module Tensor Module
-  *
-  * This module provides a Tensor class for storing arbitrarily indexed
-  * objects.
-  *
-  * \code
-  * #include <Eigen/CXX11/Tensor>
-  * \endcode
-  *
-  * Much of the documentation can be found \ref eigen_tensors "here".
-  */
-
-#include <atomic>
-#include <chrono>
-#include <cmath>
-#include <cstddef>
-#include <cstring>
-#include <random>
-#include <thread>
-
-#if defined(EIGEN_USE_THREADS) || defined(EIGEN_USE_SYCL)
-#include "ThreadPool"
-#endif
-
-#ifdef EIGEN_USE_GPU
-  #include <iostream>
-  #if defined(EIGEN_USE_HIP)
-    #include <hip/hip_runtime.h>
-  #else
-    #include <cuda_runtime.h>
-  #endif
-#endif
-
-#include "src/Tensor/TensorMacros.h"
-#include "src/Tensor/TensorForwardDeclarations.h"
-#include "src/Tensor/TensorMeta.h"
-#include "src/Tensor/TensorFunctors.h"
-#include "src/Tensor/TensorCostModel.h"
-#include "src/Tensor/TensorDeviceDefault.h"
-#include "src/Tensor/TensorDeviceThreadPool.h"
-#include "src/Tensor/TensorDeviceGpu.h"
-#ifndef gpu_assert
-#define gpu_assert(x)
-#endif
-#include "src/Tensor/TensorDeviceSycl.h"
-#include "src/Tensor/TensorIndexList.h"
-#include "src/Tensor/TensorDimensionList.h"
-#include "src/Tensor/TensorDimensions.h"
-#include "src/Tensor/TensorInitializer.h"
-#include "src/Tensor/TensorTraits.h"
-#include "src/Tensor/TensorRandom.h"
-#include "src/Tensor/TensorUInt128.h"
-#include "src/Tensor/TensorIntDiv.h"
-#include "src/Tensor/TensorGlobalFunctions.h"
-
-#include "src/Tensor/TensorBase.h"
-#include "src/Tensor/TensorBlock.h"
-
-#include "src/Tensor/TensorEvaluator.h"
-#include "src/Tensor/TensorExpr.h"
-#include "src/Tensor/TensorReduction.h"
-#include "src/Tensor/TensorReductionGpu.h"
-#include "src/Tensor/TensorArgMax.h"
-#include "src/Tensor/TensorConcatenation.h"
-#include "src/Tensor/TensorContractionMapper.h"
-#include "src/Tensor/TensorContractionBlocking.h"
-#include "src/Tensor/TensorContraction.h"
-#include "src/Tensor/TensorContractionThreadPool.h"
-#include "src/Tensor/TensorContractionGpu.h"
-#include "src/Tensor/TensorConversion.h"
-#include "src/Tensor/TensorConvolution.h"
-#include "src/Tensor/TensorFFT.h"
-#include "src/Tensor/TensorPatch.h"
-#include "src/Tensor/TensorImagePatch.h"
-#include "src/Tensor/TensorVolumePatch.h"
-#include "src/Tensor/TensorBroadcasting.h"
-#include "src/Tensor/TensorChipping.h"
-#include "src/Tensor/TensorInflation.h"
-#include "src/Tensor/TensorLayoutSwap.h"
-#include "src/Tensor/TensorMorphing.h"
-#include "src/Tensor/TensorPadding.h"
-#include "src/Tensor/TensorReverse.h"
-#include "src/Tensor/TensorShuffling.h"
-#include "src/Tensor/TensorStriding.h"
-#include "src/Tensor/TensorCustomOp.h"
-#include "src/Tensor/TensorEvalTo.h"
-#include "src/Tensor/TensorForcedEval.h"
-#include "src/Tensor/TensorGenerator.h"
-#include "src/Tensor/TensorAssign.h"
-#include "src/Tensor/TensorScan.h"
-#include "src/Tensor/TensorTrace.h"
-
-#ifdef EIGEN_USE_SYCL
-#include "src/Tensor/TensorReductionSycl.h"
-#include "src/Tensor/TensorConvolutionSycl.h"
-#include "src/Tensor/TensorContractionSycl.h"
-#include "src/Tensor/TensorScanSycl.h"
-#endif
-
-#include "src/Tensor/TensorExecutor.h"
-#include "src/Tensor/TensorDevice.h"
-
-#include "src/Tensor/TensorStorage.h"
-#include "src/Tensor/Tensor.h"
-#include "src/Tensor/TensorFixedSize.h"
-#include "src/Tensor/TensorMap.h"
-#include "src/Tensor/TensorRef.h"
-
-#include "src/Tensor/TensorIO.h"
-
-#include "../../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif  // EIGEN_HAS_CXX11
-//#endif // EIGEN_CXX11_TENSOR_MODULE

xtgeo/include/eigen3/unsupported/Eigen/CXX11/TensorSymmetry

@@ -1,42 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
-//
-// 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_TENSORSYMMETRY_MODULE
-#define EIGEN_CXX11_TENSORSYMMETRY_MODULE
-
-#include "Tensor"
-
-#include "../../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-#include "src/util/CXX11Meta.h"
-
-/** \defgroup CXX11_TensorSymmetry_Module Tensor Symmetry Module
-  *
-  * This module provides a classes that allow for the definition of
-  * symmetries w.r.t. tensor indices.
-  *
-  * Including this module will implicitly include the Tensor module.
-  *
-  * \code
-  * #include <Eigen/TensorSymmetry>
-  * \endcode
-  */
-
-#include "src/TensorSymmetry/util/TemplateGroupTheory.h"
-#include "src/TensorSymmetry/Symmetry.h"
-#include "src/TensorSymmetry/StaticSymmetry.h"
-#include "src/TensorSymmetry/DynamicSymmetry.h"
-
-#include "../../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif // EIGEN_CXX11_TENSORSYMMETRY_MODULE
-
-/*
- * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle;
- */

xtgeo/include/eigen3/unsupported/Eigen/CXX11/ThreadPool

@@ -1,74 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 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_THREADPOOL_MODULE
-#define EIGEN_CXX11_THREADPOOL_MODULE
-
-#include "../../../Eigen/Core"
-
-#include "../../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-/** \defgroup CXX11_ThreadPool_Module C++11 ThreadPool Module
-  *
-  * This module provides 2 threadpool implementations
-  *  - a simple reference implementation
-  *  - a faster non blocking implementation
-  *
-  * This module requires C++11.
-  *
-  * \code
-  * #include <Eigen/CXX11/ThreadPool>
-  * \endcode
-  */
-
-
-// The code depends on CXX11, so only include the module if the
-// compiler supports it.
-#if (EIGEN_COMP_CXXVER >= 11)
-#include <cstddef>
-#include <cstring>
-#include <time.h>
-
-#include <vector>
-#include <atomic>
-#include <condition_variable>
-#include <deque>
-#include <mutex>
-#include <thread>
-#include <functional>
-#include <memory>
-#include <utility>
-
-// There are non-parenthesized calls to "max" in the  <unordered_map> header,
-// which trigger a check in test/main.h causing compilation to fail.
-// We work around the check here by removing the check for max in
-// the case where we have to emulate thread_local.
-#ifdef max
-#undef max
-#endif
-#include <unordered_map>
-
-#include "src/util/CXX11Meta.h"
-#include "src/util/MaxSizeVector.h"
-
-#include "src/ThreadPool/ThreadLocal.h"
-#include "src/ThreadPool/ThreadYield.h"
-#include "src/ThreadPool/ThreadCancel.h"
-#include "src/ThreadPool/EventCount.h"
-#include "src/ThreadPool/RunQueue.h"
-#include "src/ThreadPool/ThreadPoolInterface.h"
-#include "src/ThreadPool/ThreadEnvironment.h"
-#include "src/ThreadPool/Barrier.h"
-#include "src/ThreadPool/NonBlockingThreadPool.h"
-
-#endif
-
-#include "../../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif // EIGEN_CXX11_THREADPOOL_MODULE