@lakutata/math 0.0.0-stage → 3.1.5

package/vendor/eigen/Eigen/src/Core/util/ForwardDeclarations.h

@@ -0,0 +1,524 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.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_FORWARDDECLARATIONS_H
+#define EIGEN_FORWARDDECLARATIONS_H
+
+// IWYU pragma: private
+#include "../InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+template <typename T>
+struct traits;
+
+// here we say once and for all that traits<const T> == traits<T>
+// When constness must affect traits, it has to be constness on template parameters on which T itself depends.
+// For example, traits<Map<const T> > != traits<Map<T> >, but
+//              traits<const Map<T> > == traits<Map<T> >
+template <typename T>
+struct traits<const T> : traits<T> {};
+
+template <typename Derived>
+struct has_direct_access {
+  enum { ret = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0 };
+};
+
+template <typename Derived>
+struct accessors_level {
+  enum {
+    has_direct_access = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0,
+    has_write_access = (traits<Derived>::Flags & LvalueBit) ? 1 : 0,
+    value = has_direct_access ? (has_write_access ? DirectWriteAccessors : DirectAccessors)
+                              : (has_write_access ? WriteAccessors : ReadOnlyAccessors)
+  };
+};
+
+template <typename T>
+struct evaluator_traits;
+
+template <typename T>
+struct evaluator;
+
+}  // end namespace internal
+
+template <typename T>
+struct NumTraits;
+
+template <typename Derived>
+struct EigenBase;
+template <typename Derived>
+class DenseBase;
+template <typename Derived>
+class PlainObjectBase;
+template <typename Derived, int Level>
+class DenseCoeffsBase;
+
+template <typename Scalar_, int Rows_, int Cols_,
+          int Options_ = AutoAlign | ((Rows_ == 1 && Cols_ != 1)   ? Eigen::RowMajor
+                                      : (Cols_ == 1 && Rows_ != 1) ? Eigen::ColMajor
+                                                                   : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION),
+          int MaxRows_ = Rows_, int MaxCols_ = Cols_>
+class Matrix;
+
+template <typename Derived>
+class MatrixBase;
+template <typename Derived>
+class ArrayBase;
+
+template <typename ExpressionType, unsigned int Added, unsigned int Removed>
+class Flagged;
+template <typename ExpressionType, template <typename> class StorageBase>
+class NoAlias;
+template <typename ExpressionType>
+class NestByValue;
+template <typename ExpressionType>
+class ForceAlignedAccess;
+template <typename ExpressionType>
+class SwapWrapper;
+
+template <typename XprType, int BlockRows = Dynamic, int BlockCols = Dynamic, bool InnerPanel = false>
+class Block;
+template <typename XprType, typename RowIndices, typename ColIndices>
+class IndexedView;
+template <typename XprType, int Rows = Dynamic, int Cols = Dynamic, int Order = 0>
+class Reshaped;
+template <typename FirstType, typename SizeType, typename IncrType>
+class ArithmeticSequence;
+
+template <typename MatrixType, int Size = Dynamic>
+class VectorBlock;
+template <typename MatrixType>
+class Transpose;
+template <typename MatrixType>
+class Conjugate;
+template <typename NullaryOp, typename MatrixType>
+class CwiseNullaryOp;
+template <typename UnaryOp, typename MatrixType>
+class CwiseUnaryOp;
+template <typename BinaryOp, typename Lhs, typename Rhs>
+class CwiseBinaryOp;
+template <typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>
+class CwiseTernaryOp;
+template <typename Decomposition, typename Rhstype>
+class Solve;
+template <typename XprType>
+class Inverse;
+
+template <typename Lhs, typename Rhs, int Option = DefaultProduct>
+class Product;
+
+template <typename Derived>
+class DiagonalBase;
+template <typename DiagonalVectorType_>
+class DiagonalWrapper;
+template <typename Scalar_, int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime>
+class DiagonalMatrix;
+template <typename MatrixType, typename DiagonalType, int ProductOrder>
+class DiagonalProduct;
+template <typename MatrixType, int Index = 0>
+class Diagonal;
+template <typename Derived>
+class SkewSymmetricBase;
+template <typename VectorType_>
+class SkewSymmetricWrapper;
+template <typename Scalar_>
+class SkewSymmetricMatrix3;
+template <int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType = int>
+class PermutationMatrix;
+template <int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType = int>
+class Transpositions;
+template <typename Derived>
+class PermutationBase;
+template <typename Derived>
+class TranspositionsBase;
+template <typename IndicesType_>
+class PermutationWrapper;
+template <typename IndicesType_>
+class TranspositionsWrapper;
+
+template <typename Derived,
+          int Level = internal::accessors_level<Derived>::has_write_access ? WriteAccessors : ReadOnlyAccessors>
+class MapBase;
+template <int OuterStrideAtCompileTime, int InnerStrideAtCompileTime>
+class Stride;
+template <int Value = Dynamic>
+class InnerStride;
+template <int Value = Dynamic>
+class OuterStride;
+template <typename MatrixType, int MapOptions = Unaligned, typename StrideType = Stride<0, 0>>
+class Map;
+template <typename Derived>
+class RefBase;
+template <typename PlainObjectType, int Options = 0,
+          typename StrideType =
+              typename std::conditional_t<PlainObjectType::IsVectorAtCompileTime, InnerStride<1>, OuterStride<>>>
+class Ref;
+template <typename ViewOp, typename MatrixType, typename StrideType = Stride<0, 0>>
+class CwiseUnaryView;
+
+template <typename Derived>
+class TriangularBase;
+template <typename MatrixType, unsigned int Mode>
+class TriangularView;
+template <typename MatrixType, unsigned int Mode>
+class SelfAdjointView;
+template <typename Derived>
+class RealView;
+template <typename MatrixType>
+class SparseView;
+template <typename ExpressionType>
+class WithFormat;
+template <typename MatrixType>
+struct CommaInitializer;
+template <typename Derived>
+class ReturnByValue;
+template <typename ExpressionType>
+class ArrayWrapper;
+template <typename ExpressionType>
+class MatrixWrapper;
+template <typename Derived>
+class SolverBase;
+template <typename XprType>
+class InnerIterator;
+
+namespace internal {
+template <typename XprType>
+class generic_randaccess_stl_iterator;
+template <typename XprType>
+class pointer_based_stl_iterator;
+template <typename XprType, DirectionType Direction>
+class subvector_stl_iterator;
+template <typename XprType, DirectionType Direction>
+class subvector_stl_reverse_iterator;
+template <typename DecompositionType>
+struct kernel_retval_base;
+template <typename DecompositionType>
+struct kernel_retval;
+template <typename DecompositionType>
+struct image_retval_base;
+template <typename DecompositionType>
+struct image_retval;
+}  // end namespace internal
+
+namespace internal {
+template <typename Scalar_, int Rows = Dynamic, int Cols = Dynamic, int Supers = Dynamic, int Subs = Dynamic,
+          int Options = 0>
+class BandMatrix;
+}
+
+namespace internal {
+template <typename Lhs, typename Rhs>
+struct product_type;
+
+template <bool>
+struct EnableIf;
+
+/** \internal
+ * \class product_evaluator
+ * Products need their own evaluator with more template arguments allowing for
+ * easier partial template specializations.
+ */
+template <typename T, int ProductTag = internal::product_type<typename T::Lhs, typename T::Rhs>::ret,
+          typename LhsShape = typename evaluator_traits<typename T::Lhs>::Shape,
+          typename RhsShape = typename evaluator_traits<typename T::Rhs>::Shape,
+          typename LhsScalar = typename traits<typename T::Lhs>::Scalar,
+          typename RhsScalar = typename traits<typename T::Rhs>::Scalar>
+struct product_evaluator;
+}  // namespace internal
+
+template <typename Lhs, typename Rhs, int ProductType = internal::product_type<Lhs, Rhs>::value>
+struct ProductReturnType;
+
+// this is a workaround for sun CC
+template <typename Lhs, typename Rhs>
+struct LazyProductReturnType;
+
+namespace internal {
+
+// Provides scalar/packet-wise product and product with accumulation
+// with optional conjugation of the arguments.
+template <typename LhsScalar, typename RhsScalar, bool ConjLhs = false, bool ConjRhs = false>
+struct conj_helper;
+
+template <typename LhsScalar, typename RhsScalar = LhsScalar>
+struct scalar_sum_op;
+template <typename LhsScalar, typename RhsScalar = LhsScalar>
+struct scalar_difference_op;
+template <typename LhsScalar, typename RhsScalar = LhsScalar>
+struct scalar_conj_product_op;
+template <typename LhsScalar, typename RhsScalar = LhsScalar, int NaNPropagation = PropagateFast>
+struct scalar_min_op;
+template <typename LhsScalar, typename RhsScalar = LhsScalar, int NaNPropagation = PropagateFast>
+struct scalar_max_op;
+template <typename Scalar>
+struct scalar_opposite_op;
+template <typename Scalar>
+struct scalar_conjugate_op;
+template <typename Scalar>
+struct scalar_real_op;
+template <typename Scalar>
+struct scalar_imag_op;
+template <typename Scalar>
+struct scalar_abs_op;
+template <typename Scalar>
+struct scalar_abs2_op;
+template <typename LhsScalar, typename RhsScalar = LhsScalar>
+struct scalar_absolute_difference_op;
+template <typename Scalar>
+struct scalar_sqrt_op;
+template <typename Scalar>
+struct scalar_cbrt_op;
+template <typename Scalar>
+struct scalar_rsqrt_op;
+template <typename Scalar>
+struct scalar_exp_op;
+template <typename Scalar>
+struct scalar_log_op;
+template <typename Scalar>
+struct scalar_cos_op;
+template <typename Scalar>
+struct scalar_sin_op;
+template <typename Scalar>
+struct scalar_acos_op;
+template <typename Scalar>
+struct scalar_asin_op;
+template <typename Scalar>
+struct scalar_tan_op;
+template <typename Scalar>
+struct scalar_atan_op;
+template <typename LhsScalar, typename RhsScalar = LhsScalar>
+struct scalar_atan2_op;
+template <typename Scalar>
+struct scalar_inverse_op;
+template <typename Scalar>
+struct scalar_square_op;
+template <typename Scalar>
+struct scalar_cube_op;
+template <typename Scalar, typename NewType>
+struct scalar_cast_op;
+template <typename Scalar>
+struct scalar_random_op;
+template <typename Scalar>
+struct scalar_constant_op;
+template <typename Scalar>
+struct scalar_identity_op;
+template <typename Scalar>
+struct scalar_sign_op;
+template <typename Scalar, typename ScalarExponent>
+struct scalar_pow_op;
+template <typename Scalar, typename ScalarExponent, bool BaseIsInteger, bool ExponentIsInteger, bool BaseIsComplex,
+          bool ExponentIsComplex>
+struct scalar_unary_pow_op;
+template <typename LhsScalar, typename RhsScalar = LhsScalar>
+struct scalar_hypot_op;
+template <typename LhsScalar, typename RhsScalar = LhsScalar>
+struct scalar_product_op;
+template <typename LhsScalar, typename RhsScalar = LhsScalar>
+struct scalar_quotient_op;
+// logical and bitwise operations
+template <typename Scalar>
+struct scalar_boolean_and_op;
+template <typename Scalar>
+struct scalar_boolean_or_op;
+template <typename Scalar>
+struct scalar_boolean_xor_op;
+template <typename Scalar>
+struct scalar_boolean_not_op;
+template <typename Scalar>
+struct scalar_bitwise_and_op;
+template <typename Scalar>
+struct scalar_bitwise_or_op;
+template <typename Scalar>
+struct scalar_bitwise_xor_op;
+template <typename Scalar>
+struct scalar_bitwise_not_op;
+
+// SpecialFunctions module
+template <typename Scalar>
+struct scalar_lgamma_op;
+template <typename Scalar>
+struct scalar_digamma_op;
+template <typename Scalar>
+struct scalar_erf_op;
+template <typename Scalar>
+struct scalar_erfc_op;
+template <typename Scalar>
+struct scalar_ndtri_op;
+template <typename Scalar>
+struct scalar_igamma_op;
+template <typename Scalar>
+struct scalar_igammac_op;
+template <typename Scalar>
+struct scalar_zeta_op;
+template <typename Scalar>
+struct scalar_betainc_op;
+
+// Bessel functions in SpecialFunctions module
+template <typename Scalar>
+struct scalar_bessel_i0_op;
+template <typename Scalar>
+struct scalar_bessel_i0e_op;
+template <typename Scalar>
+struct scalar_bessel_i1_op;
+template <typename Scalar>
+struct scalar_bessel_i1e_op;
+template <typename Scalar>
+struct scalar_bessel_j0_op;
+template <typename Scalar>
+struct scalar_bessel_y0_op;
+template <typename Scalar>
+struct scalar_bessel_j1_op;
+template <typename Scalar>
+struct scalar_bessel_y1_op;
+template <typename Scalar>
+struct scalar_bessel_k0_op;
+template <typename Scalar>
+struct scalar_bessel_k0e_op;
+template <typename Scalar>
+struct scalar_bessel_k1_op;
+template <typename Scalar>
+struct scalar_bessel_k1e_op;
+
+}  // end namespace internal
+
+struct IOFormat;
+
+// Array module
+template <typename Scalar_, int Rows_, int Cols_,
+          int Options_ = AutoAlign | ((Rows_ == 1 && Cols_ != 1)   ? Eigen::RowMajor
+                                      : (Cols_ == 1 && Rows_ != 1) ? Eigen::ColMajor
+                                                                   : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION),
+          int MaxRows_ = Rows_, int MaxCols_ = Cols_>
+class Array;
+template <typename MatrixType, typename BinaryOp, int Direction>
+class PartialReduxExpr;
+template <typename ExpressionType, int Direction>
+class VectorwiseOp;
+template <typename MatrixType, int RowFactor, int ColFactor>
+class Replicate;
+template <typename MatrixType, int Direction = BothDirections>
+class Reverse;
+
+#if defined(EIGEN_USE_LAPACKE) && defined(lapack_int)
+// Lapacke interface requires StorageIndex to be lapack_int
+typedef lapack_int DefaultPermutationIndex;
+#else
+typedef int DefaultPermutationIndex;
+#endif
+
+template <typename MatrixType, typename PermutationIndex = DefaultPermutationIndex>
+class FullPivLU;
+template <typename MatrixType, typename PermutationIndex = DefaultPermutationIndex>
+class PartialPivLU;
+namespace internal {
+template <typename MatrixType>
+struct inverse_impl;
+}
+template <typename MatrixType>
+class HouseholderQR;
+template <typename MatrixType, typename PermutationIndex = DefaultPermutationIndex>
+class ColPivHouseholderQR;
+template <typename MatrixType, typename PermutationIndex = DefaultPermutationIndex>
+class FullPivHouseholderQR;
+template <typename MatrixType, typename PermutationIndex = DefaultPermutationIndex>
+class CompleteOrthogonalDecomposition;
+template <typename MatrixType>
+class SVDBase;
+template <typename MatrixType, int Options = 0>
+class JacobiSVD;
+template <typename MatrixType, int Options = 0>
+class BDCSVD;
+template <typename MatrixType, int UpLo = Lower>
+class LLT;
+template <typename MatrixType, int UpLo = Lower>
+class LDLT;
+template <typename VectorsType, typename CoeffsType, int Side = OnTheLeft>
+class HouseholderSequence;
+template <typename Scalar>
+class JacobiRotation;
+
+// Geometry module:
+namespace internal {
+template <typename Derived, typename OtherDerived, int Size = MatrixBase<Derived>::SizeAtCompileTime>
+struct cross_impl;
+}
+template <typename Derived, int Dim_>
+class RotationBase;
+template <typename Derived>
+class QuaternionBase;
+template <typename Scalar>
+class Rotation2D;
+template <typename Scalar>
+class AngleAxis;
+template <typename Scalar, int Dim>
+class Translation;
+template <typename Scalar, int Dim>
+class AlignedBox;
+template <typename Scalar, int Options = AutoAlign>
+class Quaternion;
+template <typename Scalar, int Dim, int Mode, int Options_ = AutoAlign>
+class Transform;
+template <typename Scalar_, int AmbientDim_, int Options = AutoAlign>
+class ParametrizedLine;
+template <typename Scalar_, int AmbientDim_, int Options = AutoAlign>
+class Hyperplane;
+template <typename Scalar>
+class UniformScaling;
+template <typename MatrixType, int Direction>
+class Homogeneous;
+
+// Sparse module:
+template <typename Derived>
+class SparseMatrixBase;
+
+// MatrixFunctions module
+template <typename Derived>
+struct MatrixExponentialReturnValue;
+template <typename Derived>
+class MatrixFunctionReturnValue;
+template <typename Derived>
+class MatrixSquareRootReturnValue;
+template <typename Derived>
+class MatrixLogarithmReturnValue;
+template <typename Derived>
+class MatrixPowerReturnValue;
+template <typename Derived>
+class MatrixComplexPowerReturnValue;
+
+namespace internal {
+template <typename Scalar>
+struct stem_function {
+  typedef internal::make_complex_t<Scalar> ComplexScalar;
+  typedef ComplexScalar type(ComplexScalar, int);
+};
+}  // namespace internal
+
+template <typename XprType, typename Device>
+struct DeviceWrapper;
+
+namespace internal {
+template <typename Xpr>
+struct eigen_fill_helper;
+template <typename Xpr, bool use_fill = eigen_fill_helper<Xpr>::value>
+struct eigen_fill_impl;
+template <typename Xpr>
+struct eigen_memset_helper;
+template <typename Xpr, bool use_memset = eigen_memset_helper<Xpr>::value>
+struct eigen_zero_impl;
+
+template <typename Packet>
+struct has_packet_segment : std::false_type {};
+}  // namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_FORWARDDECLARATIONS_H

package/vendor/eigen/Eigen/src/Core/util/GpuHipCudaDefines.inc

@@ -0,0 +1,101 @@
+// 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_CORE_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 gpuMemset2DAsync hipMemset2DAsync
+#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 gpuMemset2DAsync cudaMemset2DAsync
+#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) eigen_assert(COND)
+#endif
+
+#endif  // gpu_assert
+
+#endif  // EIGEN_CORE_GPU_HIP_CUDA_DEFINES_H

package/vendor/eigen/Eigen/src/Core/util/GpuHipCudaUndefines.inc

@@ -0,0 +1,45 @@
+// 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_CORE_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 gpuMemset2DAsync
+#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_CORE_GPU_HIP_CUDA_DEFINES_H
+
+#endif  // EIGEN_CORE_GPU_HIP_CUDA_DEFINES_H