xtgeo 4.10.0__cp313-cp313-win_amd64.whl → 4.11.0__cp313-cp313-win_amd64.whl

xtgeo/include/eigen3/Eigen/src/Core/arch/SVE/TypeCasting.h

@@ -1,49 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2020, Arm Limited and Contributors
-//
-// 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_TYPE_CASTING_SVE_H
-#define EIGEN_TYPE_CASTING_SVE_H
-
-namespace Eigen {
-namespace internal {
-
-template <>
-struct type_casting_traits<float, numext::int32_t> {
-  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
-};
-
-template <>
-struct type_casting_traits<numext::int32_t, float> {
-  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
-};
-
-template <>
-EIGEN_STRONG_INLINE PacketXf pcast<PacketXi, PacketXf>(const PacketXi& a) {
-  return svcvt_f32_s32_z(svptrue_b32(), a);
-}
-
-template <>
-EIGEN_STRONG_INLINE PacketXi pcast<PacketXf, PacketXi>(const PacketXf& a) {
-  return svcvt_s32_f32_z(svptrue_b32(), a);
-}
-
-template <>
-EIGEN_STRONG_INLINE PacketXf preinterpret<PacketXf, PacketXi>(const PacketXi& a) {
-  return svreinterpret_f32_s32(a);
-}
-
-template <>
-EIGEN_STRONG_INLINE PacketXi preinterpret<PacketXi, PacketXf>(const PacketXf& a) {
-  return svreinterpret_s32_f32(a);
-}
-
-}  // namespace internal
-}  // namespace Eigen
-
-#endif // EIGEN_TYPE_CASTING_SVE_H

xtgeo/include/eigen3/Eigen/src/Core/arch/SYCL/InteropHeaders.h

@@ -1,232 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.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/.
-
-/*****************************************************************
- * InteropHeaders.h
- *
- * \brief:
- *  InteropHeaders
- *
- *****************************************************************/
-
-#ifndef EIGEN_INTEROP_HEADERS_SYCL_H
-#define EIGEN_INTEROP_HEADERS_SYCL_H
-
-namespace Eigen {
-
-#if !defined(EIGEN_DONT_VECTORIZE_SYCL)
-
-namespace internal {
-
-template <int has_blend, int lengths>
-struct sycl_packet_traits : default_packet_traits {
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = lengths,
-    HasHalfPacket = 0,
-    HasDiv = 1,
-    HasLog = 1,
-    HasExp = 1,
-    HasSqrt = 1,
-    HasRsqrt = 1,
-    HasSin = 1,
-    HasCos = 1,
-    HasTan = 1,
-    HasASin = 1,
-    HasACos = 1,
-    HasATan = 1,
-    HasSinh = 1,
-    HasCosh = 1,
-    HasTanh = 1,
-    HasLGamma = 0,
-    HasDiGamma = 0,
-    HasZeta = 0,
-    HasPolygamma = 0,
-    HasErf = 0,
-    HasErfc = 0,
-    HasNdtri = 0,
-    HasIGamma = 0,
-    HasIGammac = 0,
-    HasBetaInc = 0,
-    HasBlend = has_blend,
-    // This flag is used to indicate whether packet comparison is supported.
-    // pcmp_eq, pcmp_lt and pcmp_le should be defined for it to be true.
-    HasCmp = 1,
-    HasMax = 1,
-    HasMin = 1,
-    HasMul = 1,
-    HasAdd = 1,
-    HasFloor = 1,
-    HasRound = 1,
-    HasRint = 1,
-    HasLog1p = 1,
-    HasExpm1 = 1,
-    HasCeil = 1,
-  };
-};
-
-#ifdef SYCL_DEVICE_ONLY
-#define SYCL_PACKET_TRAITS(packet_type, has_blend, unpacket_type, lengths) \
-  template <>                                                              \
-  struct packet_traits<unpacket_type>                                      \
-      : sycl_packet_traits<has_blend, lengths> {                           \
-    typedef packet_type type;                                              \
-    typedef packet_type half;                                              \
-  };
-
-SYCL_PACKET_TRAITS(cl::sycl::cl_float4, 1, float, 4)
-SYCL_PACKET_TRAITS(cl::sycl::cl_float4, 1, const float, 4)
-SYCL_PACKET_TRAITS(cl::sycl::cl_double2, 0, double, 2)
-SYCL_PACKET_TRAITS(cl::sycl::cl_double2, 0, const double, 2)
-#undef SYCL_PACKET_TRAITS
-
-// Make sure this is only available when targeting a GPU: we don't want to
-// introduce conflicts between these packet_traits definitions and the ones
-// we'll use on the host side (SSE, AVX, ...)
-#define SYCL_ARITHMETIC(packet_type)  \
-  template <>                         \
-  struct is_arithmetic<packet_type> { \
-    enum { value = true };            \
-  };
-SYCL_ARITHMETIC(cl::sycl::cl_float4)
-SYCL_ARITHMETIC(cl::sycl::cl_double2)
-#undef SYCL_ARITHMETIC
-
-#define SYCL_UNPACKET_TRAITS(packet_type, unpacket_type, lengths)        \
-  template <>                                                            \
-  struct unpacket_traits<packet_type> {                                  \
-    typedef unpacket_type type;                                          \
-    enum { size = lengths, vectorizable = true, alignment = Aligned16 }; \
-    typedef packet_type half;                                            \
-  };
-SYCL_UNPACKET_TRAITS(cl::sycl::cl_float4, float, 4)
-SYCL_UNPACKET_TRAITS(cl::sycl::cl_double2, double, 2)
-
-#undef SYCL_UNPACKET_TRAITS
-#endif
-
-}  // end namespace internal
-
-#endif
-
-namespace TensorSycl {
-namespace internal {
-
-template <typename PacketReturnType, int PacketSize>
-struct PacketWrapper;
-// This function should never get called on the device
-#ifndef SYCL_DEVICE_ONLY
-template <typename PacketReturnType, int PacketSize>
-struct PacketWrapper {
-  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type
-      Scalar;
-  template <typename Index>
-  EIGEN_DEVICE_FUNC static Scalar scalarize(Index, PacketReturnType &) {
-    eigen_assert(false && "THERE IS NO PACKETIZE VERSION FOR  THE CHOSEN TYPE");
-    abort();
-  }
-  EIGEN_DEVICE_FUNC static PacketReturnType convert_to_packet_type(Scalar in,
-                                                                   Scalar) {
-    return ::Eigen::internal::template plset<PacketReturnType>(in);
-  }
-  EIGEN_DEVICE_FUNC static void set_packet(PacketReturnType, Scalar *) {
-    eigen_assert(false && "THERE IS NO PACKETIZE VERSION FOR  THE CHOSEN TYPE");
-    abort();
-  }
-};
-
-#elif defined(SYCL_DEVICE_ONLY)
-template <typename PacketReturnType>
-struct PacketWrapper<PacketReturnType, 4> {
-  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type
-      Scalar;
-  template <typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Scalar scalarize(Index index, PacketReturnType &in) {
-    switch (index) {
-      case 0:
-        return in.x();
-      case 1:
-        return in.y();
-      case 2:
-        return in.z();
-      case 3:
-        return in.w();
-      default:
-      //INDEX MUST BE BETWEEN 0 and 3.There is no abort function in SYCL kernel. so we cannot use abort here. 
-      // The code will never reach here
-      __builtin_unreachable();
-    }
-    __builtin_unreachable();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType convert_to_packet_type(
-      Scalar in, Scalar other) {
-    return PacketReturnType(in, other, other, other);
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static void set_packet(PacketReturnType &lhs, Scalar *rhs) {
-    lhs = PacketReturnType(rhs[0], rhs[1], rhs[2], rhs[3]);
-  }
-};
-
-template <typename PacketReturnType>
-struct PacketWrapper<PacketReturnType, 1> {
-  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type
-      Scalar;
-  template <typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Scalar scalarize(Index, PacketReturnType &in) {
-    return in;
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType convert_to_packet_type(Scalar in,
-                                                                   Scalar) {
-    return PacketReturnType(in);
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static void set_packet(PacketReturnType &lhs, Scalar *rhs) {
-    lhs = rhs[0];
-  }
-};
-
-template <typename PacketReturnType>
-struct PacketWrapper<PacketReturnType, 2> {
-  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type
-      Scalar;
-  template <typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Scalar scalarize(Index index, PacketReturnType &in) {
-    switch (index) {
-      case 0:
-        return in.x();
-      case 1:
-        return in.y();
-      default:
-        //INDEX MUST BE BETWEEN 0 and 1.There is no abort function in SYCL kernel. so we cannot use abort here. 
-      // The code will never reach here
-        __builtin_unreachable();
-    }
-    __builtin_unreachable();
-  }
-  
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType convert_to_packet_type(
-      Scalar in, Scalar other) {
-    return PacketReturnType(in, other);
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static void set_packet(PacketReturnType &lhs, Scalar *rhs) {
-    lhs = PacketReturnType(rhs[0], rhs[1]);
-  }
-};
-
-#endif
-
-}  // end namespace internal
-}  // end namespace TensorSycl
-}  // end namespace Eigen
-
-#endif  // EIGEN_INTEROP_HEADERS_SYCL_H

xtgeo/include/eigen3/Eigen/src/Core/arch/SYCL/MathFunctions.h

@@ -1,301 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.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/.
-
-/*****************************************************************
- * MathFunctions.h
- *
- * \brief:
- *  MathFunctions
- *
- *****************************************************************/
-
-#ifndef EIGEN_MATH_FUNCTIONS_SYCL_H
-#define EIGEN_MATH_FUNCTIONS_SYCL_H
-namespace Eigen {
-
-namespace internal {
-
-// Make sure this is only available when targeting a GPU: we don't want to
-// introduce conflicts between these packet_traits definitions and the ones
-// we'll use on the host side (SSE, AVX, ...)
-#if defined(SYCL_DEVICE_ONLY)
-#define SYCL_PLOG(packet_type)                                         \
-  template <>                                                          \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type plog<packet_type>( \
-      const packet_type& a) {                                          \
-    return cl::sycl::log(a);                                           \
-  }
-
-SYCL_PLOG(cl::sycl::cl_float4)
-SYCL_PLOG(cl::sycl::cl_double2)
-#undef SYCL_PLOG
-
-#define SYCL_PLOG1P(packet_type)                                         \
-  template <>                                                            \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type plog1p<packet_type>( \
-      const packet_type& a) {                                            \
-    return cl::sycl::log1p(a);                                           \
-  }
-
-SYCL_PLOG1P(cl::sycl::cl_float4)
-SYCL_PLOG1P(cl::sycl::cl_double2)
-#undef SYCL_PLOG1P
-
-#define SYCL_PLOG10(packet_type)                                         \
-  template <>                                                            \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type plog10<packet_type>( \
-      const packet_type& a) {                                            \
-    return cl::sycl::log10(a);                                           \
-  }
-
-SYCL_PLOG10(cl::sycl::cl_float4)
-SYCL_PLOG10(cl::sycl::cl_double2)
-#undef SYCL_PLOG10
-
-#define SYCL_PEXP(packet_type)                                         \
-  template <>                                                          \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pexp<packet_type>( \
-      const packet_type& a) {                                          \
-    return cl::sycl::exp(a);                                           \
-  }
-
-SYCL_PEXP(cl::sycl::cl_float4)
-SYCL_PEXP(cl::sycl::cl_float)
-SYCL_PEXP(cl::sycl::cl_double2)
-#undef SYCL_PEXP
-
-#define SYCL_PEXPM1(packet_type)                                         \
-  template <>                                                            \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pexpm1<packet_type>( \
-      const packet_type& a) {                                            \
-    return cl::sycl::expm1(a);                                           \
-  }
-
-SYCL_PEXPM1(cl::sycl::cl_float4)
-SYCL_PEXPM1(cl::sycl::cl_double2)
-#undef SYCL_PEXPM1
-
-#define SYCL_PSQRT(packet_type)                                         \
-  template <>                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type psqrt<packet_type>( \
-      const packet_type& a) {                                           \
-    return cl::sycl::sqrt(a);                                           \
-  }
-
-SYCL_PSQRT(cl::sycl::cl_float4)
-SYCL_PSQRT(cl::sycl::cl_double2)
-#undef SYCL_PSQRT
-
-#define SYCL_PRSQRT(packet_type)                                         \
-  template <>                                                            \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type prsqrt<packet_type>( \
-      const packet_type& a) {                                            \
-    return cl::sycl::rsqrt(a);                                           \
-  }
-
-SYCL_PRSQRT(cl::sycl::cl_float4)
-SYCL_PRSQRT(cl::sycl::cl_double2)
-#undef SYCL_PRSQRT
-
-/** \internal \returns the hyperbolic sine of \a a (coeff-wise) */
-#define SYCL_PSIN(packet_type)                                         \
-  template <>                                                          \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type psin<packet_type>( \
-      const packet_type& a) {                                          \
-    return cl::sycl::sin(a);                                           \
-  }
-
-SYCL_PSIN(cl::sycl::cl_float4)
-SYCL_PSIN(cl::sycl::cl_double2)
-#undef SYCL_PSIN
-
-/** \internal \returns the hyperbolic cosine of \a a (coeff-wise) */
-#define SYCL_PCOS(packet_type)                                         \
-  template <>                                                          \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pcos<packet_type>( \
-      const packet_type& a) {                                          \
-    return cl::sycl::cos(a);                                           \
-  }
-
-SYCL_PCOS(cl::sycl::cl_float4)
-SYCL_PCOS(cl::sycl::cl_double2)
-#undef SYCL_PCOS
-
-/** \internal \returns the hyperbolic tan of \a a (coeff-wise) */
-#define SYCL_PTAN(packet_type)                                         \
-  template <>                                                          \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type ptan<packet_type>( \
-      const packet_type& a) {                                          \
-    return cl::sycl::tan(a);                                           \
-  }
-
-SYCL_PTAN(cl::sycl::cl_float4)
-SYCL_PTAN(cl::sycl::cl_double2)
-#undef SYCL_PTAN
-
-/** \internal \returns the hyperbolic sine of \a a (coeff-wise) */
-#define SYCL_PASIN(packet_type)                                         \
-  template <>                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pasin<packet_type>( \
-      const packet_type& a) {                                           \
-    return cl::sycl::asin(a);                                           \
-  }
-
-SYCL_PASIN(cl::sycl::cl_float4)
-SYCL_PASIN(cl::sycl::cl_double2)
-#undef SYCL_PASIN
-
-/** \internal \returns the hyperbolic cosine of \a a (coeff-wise) */
-#define SYCL_PACOS(packet_type)                                         \
-  template <>                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pacos<packet_type>( \
-      const packet_type& a) {                                           \
-    return cl::sycl::acos(a);                                           \
-  }
-
-SYCL_PACOS(cl::sycl::cl_float4)
-SYCL_PACOS(cl::sycl::cl_double2)
-#undef SYCL_PACOS
-
-/** \internal \returns the hyperbolic tan of \a a (coeff-wise) */
-#define SYCL_PATAN(packet_type)                                         \
-  template <>                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type patan<packet_type>( \
-      const packet_type& a) {                                           \
-    return cl::sycl::atan(a);                                           \
-  }
-
-SYCL_PATAN(cl::sycl::cl_float4)
-SYCL_PATAN(cl::sycl::cl_double2)
-#undef SYCL_PATAN
-
-/** \internal \returns the hyperbolic sine of \a a (coeff-wise) */
-#define SYCL_PSINH(packet_type)                                         \
-  template <>                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type psinh<packet_type>( \
-      const packet_type& a) {                                           \
-    return cl::sycl::sinh(a);                                           \
-  }
-
-SYCL_PSINH(cl::sycl::cl_float4)
-SYCL_PSINH(cl::sycl::cl_double2)
-#undef SYCL_PSINH
-
-/** \internal \returns the hyperbolic cosine of \a a (coeff-wise) */
-#define SYCL_PCOSH(packet_type)                                         \
-  template <>                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pcosh<packet_type>( \
-      const packet_type& a) {                                           \
-    return cl::sycl::cosh(a);                                           \
-  }
-
-SYCL_PCOSH(cl::sycl::cl_float4)
-SYCL_PCOSH(cl::sycl::cl_double2)
-#undef SYCL_PCOSH
-
-/** \internal \returns the hyperbolic tan of \a a (coeff-wise) */
-#define SYCL_PTANH(packet_type)                                         \
-  template <>                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type ptanh<packet_type>( \
-      const packet_type& a) {                                           \
-    return cl::sycl::tanh(a);                                           \
-  }
-
-SYCL_PTANH(cl::sycl::cl_float4)
-SYCL_PTANH(cl::sycl::cl_double2)
-#undef SYCL_PTANH
-
-#define SYCL_PCEIL(packet_type)                                         \
-  template <>                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pceil<packet_type>( \
-      const packet_type& a) {                                           \
-    return cl::sycl::ceil(a);                                           \
-  }
-
-SYCL_PCEIL(cl::sycl::cl_float4)
-SYCL_PCEIL(cl::sycl::cl_double2)
-#undef SYCL_PCEIL
-
-#define SYCL_PROUND(packet_type)                                         \
-  template <>                                                            \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pround<packet_type>( \
-      const packet_type& a) {                                            \
-    return cl::sycl::round(a);                                           \
-  }
-
-SYCL_PROUND(cl::sycl::cl_float4)
-SYCL_PROUND(cl::sycl::cl_double2)
-#undef SYCL_PROUND
-
-#define SYCL_PRINT(packet_type)                                         \
-  template <>                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type print<packet_type>( \
-      const packet_type& a) {                                           \
-    return cl::sycl::rint(a);                                           \
-  }
-
-SYCL_PRINT(cl::sycl::cl_float4)
-SYCL_PRINT(cl::sycl::cl_double2)
-#undef SYCL_PRINT
-
-#define SYCL_FLOOR(packet_type)                                          \
-  template <>                                                            \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pfloor<packet_type>( \
-      const packet_type& a) {                                            \
-    return cl::sycl::floor(a);                                           \
-  }
-
-SYCL_FLOOR(cl::sycl::cl_float4)
-SYCL_FLOOR(cl::sycl::cl_double2)
-#undef SYCL_FLOOR
-
-#define SYCL_PMIN(packet_type, expr)                                   \
-  template <>                                                          \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pmin<packet_type>( \
-      const packet_type& a, const packet_type& b) {                    \
-    return expr;                                                       \
-  }
-
-SYCL_PMIN(cl::sycl::cl_float4, cl::sycl::fmin(a, b))
-SYCL_PMIN(cl::sycl::cl_double2, cl::sycl::fmin(a, b))
-#undef SYCL_PMIN
-
-#define SYCL_PMAX(packet_type, expr)                                   \
-  template <>                                                          \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pmax<packet_type>( \
-      const packet_type& a, const packet_type& b) {                    \
-    return expr;                                                       \
-  }
-
-SYCL_PMAX(cl::sycl::cl_float4, cl::sycl::fmax(a, b))
-SYCL_PMAX(cl::sycl::cl_double2, cl::sycl::fmax(a, b))
-#undef SYCL_PMAX
-
-#define SYCL_PLDEXP(packet_type)                                             \
-  template <>                                                                \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pldexp(                  \
-      const packet_type& a, const packet_type& exponent) {                   \
-    return cl::sycl::ldexp(                                                  \
-        a, exponent.template convert<cl::sycl::cl_int,                       \
-                                     cl::sycl::rounding_mode::automatic>()); \
-  }
-
-SYCL_PLDEXP(cl::sycl::cl_float4)
-SYCL_PLDEXP(cl::sycl::cl_double2)
-#undef SYCL_PLDEXP
-
-#endif
-}  // end namespace internal
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_MATH_FUNCTIONS_SYCL_H