xtgeo 4.10.0__cp313-cp313-macosx_11_0_arm64.whl → 4.10.1__cp313-cp313-macosx_11_0_arm64.whl

xtgeo/include/eigen3/Eigen/src/Geometry/Translation.h

@@ -1,202 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008 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_TRANSLATION_H
-#define EIGEN_TRANSLATION_H
-
-namespace Eigen { 
-
-/** \geometry_module \ingroup Geometry_Module
-  *
-  * \class Translation
-  *
-  * \brief Represents a translation transformation
-  *
-  * \tparam _Scalar the scalar type, i.e., the type of the coefficients.
-  * \tparam _Dim the  dimension of the space, can be a compile time value or Dynamic
-  *
-  * \note This class is not aimed to be used to store a translation transformation,
-  * but rather to make easier the constructions and updates of Transform objects.
-  *
-  * \sa class Scaling, class Transform
-  */
-template<typename _Scalar, int _Dim>
-class Translation
-{
-public:
-  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Dim)
-  /** dimension of the space */
-  enum { Dim = _Dim };
-  /** the scalar type of the coefficients */
-  typedef _Scalar Scalar;
-  /** corresponding vector type */
-  typedef Matrix<Scalar,Dim,1> VectorType;
-  /** corresponding linear transformation matrix type */
-  typedef Matrix<Scalar,Dim,Dim> LinearMatrixType;
-  /** corresponding affine transformation type */
-  typedef Transform<Scalar,Dim,Affine> AffineTransformType;
-  /** corresponding isometric transformation type */
-  typedef Transform<Scalar,Dim,Isometry> IsometryTransformType;
-
-protected:
-
-  VectorType m_coeffs;
-
-public:
-
-  /** Default constructor without initialization. */
-  EIGEN_DEVICE_FUNC Translation() {}
-  /**  */
-  EIGEN_DEVICE_FUNC inline Translation(const Scalar& sx, const Scalar& sy)
-  {
-    eigen_assert(Dim==2);
-    m_coeffs.x() = sx;
-    m_coeffs.y() = sy;
-  }
-  /**  */
-  EIGEN_DEVICE_FUNC inline Translation(const Scalar& sx, const Scalar& sy, const Scalar& sz)
-  {
-    eigen_assert(Dim==3);
-    m_coeffs.x() = sx;
-    m_coeffs.y() = sy;
-    m_coeffs.z() = sz;
-  }
-  /** Constructs and initialize the translation transformation from a vector of translation coefficients */
-  EIGEN_DEVICE_FUNC explicit inline Translation(const VectorType& vector) : m_coeffs(vector) {}
-
-  /** \brief Returns the x-translation by value. **/
-  EIGEN_DEVICE_FUNC inline Scalar x() const { return m_coeffs.x(); }
-  /** \brief Returns the y-translation by value. **/
-  EIGEN_DEVICE_FUNC inline Scalar y() const { return m_coeffs.y(); }
-  /** \brief Returns the z-translation by value. **/
-  EIGEN_DEVICE_FUNC inline Scalar z() const { return m_coeffs.z(); }
-
-  /** \brief Returns the x-translation as a reference. **/
-  EIGEN_DEVICE_FUNC inline Scalar& x() { return m_coeffs.x(); }
-  /** \brief Returns the y-translation as a reference. **/
-  EIGEN_DEVICE_FUNC inline Scalar& y() { return m_coeffs.y(); }
-  /** \brief Returns the z-translation as a reference. **/
-  EIGEN_DEVICE_FUNC inline Scalar& z() { return m_coeffs.z(); }
-
-  EIGEN_DEVICE_FUNC const VectorType& vector() const { return m_coeffs; }
-  EIGEN_DEVICE_FUNC VectorType& vector() { return m_coeffs; }
-
-  EIGEN_DEVICE_FUNC const VectorType& translation() const { return m_coeffs; }
-  EIGEN_DEVICE_FUNC VectorType& translation() { return m_coeffs; }
-
-  /** Concatenates two translation */
-  EIGEN_DEVICE_FUNC inline Translation operator* (const Translation& other) const
-  { return Translation(m_coeffs + other.m_coeffs); }
-
-  /** Concatenates a translation and a uniform scaling */
-  EIGEN_DEVICE_FUNC inline AffineTransformType operator* (const UniformScaling<Scalar>& other) const;
-
-  /** Concatenates a translation and a linear transformation */
-  template<typename OtherDerived>
-  EIGEN_DEVICE_FUNC inline AffineTransformType operator* (const EigenBase<OtherDerived>& linear) const;
-
-  /** Concatenates a translation and a rotation */
-  template<typename Derived>
-  EIGEN_DEVICE_FUNC inline IsometryTransformType operator*(const RotationBase<Derived,Dim>& r) const
-  { return *this * IsometryTransformType(r); }
-
-  /** \returns the concatenation of a linear transformation \a l with the translation \a t */
-  // its a nightmare to define a templated friend function outside its declaration
-  template<typename OtherDerived> friend
-  EIGEN_DEVICE_FUNC inline AffineTransformType operator*(const EigenBase<OtherDerived>& linear, const Translation& t)
-  {
-    AffineTransformType res;
-    res.matrix().setZero();
-    res.linear() = linear.derived();
-    res.translation() = linear.derived() * t.m_coeffs;
-    res.matrix().row(Dim).setZero();
-    res(Dim,Dim) = Scalar(1);
-    return res;
-  }
-
-  /** Concatenates a translation and a transformation */
-  template<int Mode, int Options>
-  EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode> operator* (const Transform<Scalar,Dim,Mode,Options>& t) const
-  {
-    Transform<Scalar,Dim,Mode> res = t;
-    res.pretranslate(m_coeffs);
-    return res;
-  }
-
-  /** Applies translation to vector */
-  template<typename Derived>
-  inline typename internal::enable_if<Derived::IsVectorAtCompileTime,VectorType>::type
-  operator* (const MatrixBase<Derived>& vec) const
-  { return m_coeffs + vec.derived(); }
-
-  /** \returns the inverse translation (opposite) */
-  Translation inverse() const { return Translation(-m_coeffs); }
-
-  static const Translation Identity() { return Translation(VectorType::Zero()); }
-
-  /** \returns \c *this with scalar type casted to \a NewScalarType
-    *
-    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
-    * then this function smartly returns a const reference to \c *this.
-    */
-  template<typename NewScalarType>
-  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Translation,Translation<NewScalarType,Dim> >::type cast() const
-  { return typename internal::cast_return_type<Translation,Translation<NewScalarType,Dim> >::type(*this); }
-
-  /** Copy constructor with scalar type conversion */
-  template<typename OtherScalarType>
-  EIGEN_DEVICE_FUNC inline explicit Translation(const Translation<OtherScalarType,Dim>& other)
-  { m_coeffs = other.vector().template cast<Scalar>(); }
-
-  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
-    * determined by \a prec.
-    *
-    * \sa MatrixBase::isApprox() */
-  EIGEN_DEVICE_FUNC bool isApprox(const Translation& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
-  { return m_coeffs.isApprox(other.m_coeffs, prec); }
-
-};
-
-/** \addtogroup Geometry_Module */
-//@{
-typedef Translation<float, 2> Translation2f;
-typedef Translation<double,2> Translation2d;
-typedef Translation<float, 3> Translation3f;
-typedef Translation<double,3> Translation3d;
-//@}
-
-template<typename Scalar, int Dim>
-EIGEN_DEVICE_FUNC inline typename Translation<Scalar,Dim>::AffineTransformType
-Translation<Scalar,Dim>::operator* (const UniformScaling<Scalar>& other) const
-{
-  AffineTransformType res;
-  res.matrix().setZero();
-  res.linear().diagonal().fill(other.factor());
-  res.translation() = m_coeffs;
-  res(Dim,Dim) = Scalar(1);
-  return res;
-}
-
-template<typename Scalar, int Dim>
-template<typename OtherDerived>
-EIGEN_DEVICE_FUNC inline typename Translation<Scalar,Dim>::AffineTransformType
-Translation<Scalar,Dim>::operator* (const EigenBase<OtherDerived>& linear) const
-{
-  AffineTransformType res;
-  res.matrix().setZero();
-  res.linear() = linear.derived();
-  res.translation() = m_coeffs;
-  res.matrix().row(Dim).setZero();
-  res(Dim,Dim) = Scalar(1);
-  return res;
-}
-
-} // end namespace Eigen
-
-#endif // EIGEN_TRANSLATION_H

xtgeo/include/eigen3/Eigen/src/Geometry/Umeyama.h

@@ -1,166 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Hauke Heibel <hauke.heibel@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_UMEYAMA_H
-#define EIGEN_UMEYAMA_H
-
-// This file requires the user to include 
-// * Eigen/Core
-// * Eigen/LU 
-// * Eigen/SVD
-// * Eigen/Array
-
-namespace Eigen { 
-
-#ifndef EIGEN_PARSED_BY_DOXYGEN
-
-// These helpers are required since it allows to use mixed types as parameters
-// for the Umeyama. The problem with mixed parameters is that the return type
-// cannot trivially be deduced when float and double types are mixed.
-namespace internal {
-
-// Compile time return type deduction for different MatrixBase types.
-// Different means here different alignment and parameters but the same underlying
-// real scalar type.
-template<typename MatrixType, typename OtherMatrixType>
-struct umeyama_transform_matrix_type
-{
-  enum {
-    MinRowsAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(MatrixType::RowsAtCompileTime, OtherMatrixType::RowsAtCompileTime),
-
-    // When possible we want to choose some small fixed size value since the result
-    // is likely to fit on the stack. So here, EIGEN_SIZE_MIN_PREFER_DYNAMIC is not what we want.
-    HomogeneousDimension = int(MinRowsAtCompileTime) == Dynamic ? Dynamic : int(MinRowsAtCompileTime)+1
-  };
-
-  typedef Matrix<typename traits<MatrixType>::Scalar,
-    HomogeneousDimension,
-    HomogeneousDimension,
-    AutoAlign | (traits<MatrixType>::Flags & RowMajorBit ? RowMajor : ColMajor),
-    HomogeneousDimension,
-    HomogeneousDimension
-  > type;
-};
-
-}
-
-#endif
-
-/**
-* \geometry_module \ingroup Geometry_Module
-*
-* \brief Returns the transformation between two point sets.
-*
-* The algorithm is based on:
-* "Least-squares estimation of transformation parameters between two point patterns",
-* Shinji Umeyama, PAMI 1991, DOI: 10.1109/34.88573
-*
-* It estimates parameters \f$ c, \mathbf{R}, \f$ and \f$ \mathbf{t} \f$ such that
-* \f{align*}
-*   \frac{1}{n} \sum_{i=1}^n \vert\vert y_i - (c\mathbf{R}x_i + \mathbf{t}) \vert\vert_2^2
-* \f}
-* is minimized.
-*
-* The algorithm is based on the analysis of the covariance matrix
-* \f$ \Sigma_{\mathbf{x}\mathbf{y}} \in \mathbb{R}^{d \times d} \f$
-* of the input point sets \f$ \mathbf{x} \f$ and \f$ \mathbf{y} \f$ where 
-* \f$d\f$ is corresponding to the dimension (which is typically small).
-* The analysis is involving the SVD having a complexity of \f$O(d^3)\f$
-* though the actual computational effort lies in the covariance
-* matrix computation which has an asymptotic lower bound of \f$O(dm)\f$ when 
-* the input point sets have dimension \f$d \times m\f$.
-*
-* Currently the method is working only for floating point matrices.
-*
-* \todo Should the return type of umeyama() become a Transform?
-*
-* \param src Source points \f$ \mathbf{x} = \left( x_1, \hdots, x_n \right) \f$.
-* \param dst Destination points \f$ \mathbf{y} = \left( y_1, \hdots, y_n \right) \f$.
-* \param with_scaling Sets \f$ c=1 \f$ when <code>false</code> is passed.
-* \return The homogeneous transformation 
-* \f{align*}
-*   T = \begin{bmatrix} c\mathbf{R} & \mathbf{t} \\ \mathbf{0} & 1 \end{bmatrix}
-* \f}
-* minimizing the residual above. This transformation is always returned as an 
-* Eigen::Matrix.
-*/
-template <typename Derived, typename OtherDerived>
-typename internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type
-umeyama(const MatrixBase<Derived>& src, const MatrixBase<OtherDerived>& dst, bool with_scaling = true)
-{
-  typedef typename internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type TransformationMatrixType;
-  typedef typename internal::traits<TransformationMatrixType>::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-
-  EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL)
-  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename internal::traits<OtherDerived>::Scalar>::value),
-    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
-
-  enum { Dimension = EIGEN_SIZE_MIN_PREFER_DYNAMIC(Derived::RowsAtCompileTime, OtherDerived::RowsAtCompileTime) };
-
-  typedef Matrix<Scalar, Dimension, 1> VectorType;
-  typedef Matrix<Scalar, Dimension, Dimension> MatrixType;
-  typedef typename internal::plain_matrix_type_row_major<Derived>::type RowMajorMatrixType;
-
-  const Index m = src.rows(); // dimension
-  const Index n = src.cols(); // number of measurements
-
-  // required for demeaning ...
-  const RealScalar one_over_n = RealScalar(1) / static_cast<RealScalar>(n);
-
-  // computation of mean
-  const VectorType src_mean = src.rowwise().sum() * one_over_n;
-  const VectorType dst_mean = dst.rowwise().sum() * one_over_n;
-
-  // demeaning of src and dst points
-  const RowMajorMatrixType src_demean = src.colwise() - src_mean;
-  const RowMajorMatrixType dst_demean = dst.colwise() - dst_mean;
-
-  // Eq. (36)-(37)
-  const Scalar src_var = src_demean.rowwise().squaredNorm().sum() * one_over_n;
-
-  // Eq. (38)
-  const MatrixType sigma = one_over_n * dst_demean * src_demean.transpose();
-
-  JacobiSVD<MatrixType> svd(sigma, ComputeFullU | ComputeFullV);
-
-  // Initialize the resulting transformation with an identity matrix...
-  TransformationMatrixType Rt = TransformationMatrixType::Identity(m+1,m+1);
-
-  // Eq. (39)
-  VectorType S = VectorType::Ones(m);
-
-  if  ( svd.matrixU().determinant() * svd.matrixV().determinant() < 0 )
-    S(m-1) = -1;
-
-  // Eq. (40) and (43)
-  Rt.block(0,0,m,m).noalias() = svd.matrixU() * S.asDiagonal() * svd.matrixV().transpose();
-
-  if (with_scaling)
-  {
-    // Eq. (42)
-    const Scalar c = Scalar(1)/src_var * svd.singularValues().dot(S);
-
-    // Eq. (41)
-    Rt.col(m).head(m) = dst_mean;
-    Rt.col(m).head(m).noalias() -= c*Rt.topLeftCorner(m,m)*src_mean;
-    Rt.block(0,0,m,m) *= c;
-  }
-  else
-  {
-    Rt.col(m).head(m) = dst_mean;
-    Rt.col(m).head(m).noalias() -= Rt.topLeftCorner(m,m)*src_mean;
-  }
-
-  return Rt;
-}
-
-} // end namespace Eigen
-
-#endif // EIGEN_UMEYAMA_H

xtgeo/include/eigen3/Eigen/src/Geometry/arch/Geometry_SIMD.h

@@ -1,168 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Rohit Garg <rpg.314@gmail.com>
-// Copyright (C) 2009-2010 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_GEOMETRY_SIMD_H
-#define EIGEN_GEOMETRY_SIMD_H
-
-namespace Eigen { 
-
-namespace internal {
-
-template<class Derived, class OtherDerived>
-struct quat_product<Architecture::Target, Derived, OtherDerived, float>
-{
-  enum {
-    AAlignment = traits<Derived>::Alignment,
-    BAlignment = traits<OtherDerived>::Alignment,
-    ResAlignment = traits<Quaternion<float> >::Alignment
-  };
-  static inline Quaternion<float> run(const QuaternionBase<Derived>& _a, const QuaternionBase<OtherDerived>& _b)
-  {
-    evaluator<typename Derived::Coefficients> ae(_a.coeffs());
-    evaluator<typename OtherDerived::Coefficients> be(_b.coeffs());
-    Quaternion<float> res;
-    const float neg_zero = numext::bit_cast<float>(0x80000000u);
-    const float arr[4] = {0.f, 0.f, 0.f, neg_zero};
-    const Packet4f mask = ploadu<Packet4f>(arr);
-    Packet4f a = ae.template packet<AAlignment,Packet4f>(0);
-    Packet4f b = be.template packet<BAlignment,Packet4f>(0);
-    Packet4f s1 = pmul(vec4f_swizzle1(a,1,2,0,2),vec4f_swizzle1(b,2,0,1,2));
-    Packet4f s2 = pmul(vec4f_swizzle1(a,3,3,3,1),vec4f_swizzle1(b,0,1,2,1));
-    pstoret<float,Packet4f,ResAlignment>(
-              &res.x(),
-              padd(psub(pmul(a,vec4f_swizzle1(b,3,3,3,3)),
-                                    pmul(vec4f_swizzle1(a,2,0,1,0),
-                                               vec4f_swizzle1(b,1,2,0,0))),
-                         pxor(mask,padd(s1,s2))));
-    
-    return res;
-  }
-};
-
-template<class Derived>
-struct quat_conj<Architecture::Target, Derived, float>
-{
-  enum {
-    ResAlignment = traits<Quaternion<float> >::Alignment
-  };
-  static inline Quaternion<float> run(const QuaternionBase<Derived>& q)
-  {
-    evaluator<typename Derived::Coefficients> qe(q.coeffs());
-    Quaternion<float> res;
-    const float neg_zero = numext::bit_cast<float>(0x80000000u);
-    const float arr[4] = {neg_zero, neg_zero, neg_zero,0.f};
-    const Packet4f mask = ploadu<Packet4f>(arr);
-    pstoret<float,Packet4f,ResAlignment>(&res.x(), pxor(mask, qe.template packet<traits<Derived>::Alignment,Packet4f>(0)));
-    return res;
-  }
-};
-
-
-template<typename VectorLhs,typename VectorRhs>
-struct cross3_impl<Architecture::Target,VectorLhs,VectorRhs,float,true>
-{
-  enum {
-    ResAlignment = traits<typename plain_matrix_type<VectorLhs>::type>::Alignment
-  };
-  static inline typename plain_matrix_type<VectorLhs>::type
-  run(const VectorLhs& lhs, const VectorRhs& rhs)
-  {
-    evaluator<VectorLhs> lhs_eval(lhs);
-    evaluator<VectorRhs> rhs_eval(rhs);
-    Packet4f a = lhs_eval.template packet<traits<VectorLhs>::Alignment,Packet4f>(0);
-    Packet4f b = rhs_eval.template packet<traits<VectorRhs>::Alignment,Packet4f>(0);
-    Packet4f mul1 = pmul(vec4f_swizzle1(a,1,2,0,3),vec4f_swizzle1(b,2,0,1,3));
-    Packet4f mul2 = pmul(vec4f_swizzle1(a,2,0,1,3),vec4f_swizzle1(b,1,2,0,3));
-    typename plain_matrix_type<VectorLhs>::type res;
-    pstoret<float,Packet4f,ResAlignment>(&res.x(),psub(mul1,mul2));
-    return res;
-  }
-};
-
-
-
-#if (defined EIGEN_VECTORIZE_SSE) || (EIGEN_ARCH_ARM64)
-
-template<class Derived, class OtherDerived>
-struct quat_product<Architecture::Target, Derived, OtherDerived, double>
-{
-  enum {
-    BAlignment = traits<OtherDerived>::Alignment,
-    ResAlignment = traits<Quaternion<double> >::Alignment
-  };
-
-  static inline Quaternion<double> run(const QuaternionBase<Derived>& _a, const QuaternionBase<OtherDerived>& _b)
-  {
-  Quaternion<double> res;
-
-  evaluator<typename Derived::Coefficients> ae(_a.coeffs());
-  evaluator<typename OtherDerived::Coefficients> be(_b.coeffs());
-
-  const double* a = _a.coeffs().data();
-  Packet2d b_xy = be.template packet<BAlignment,Packet2d>(0);
-  Packet2d b_zw = be.template packet<BAlignment,Packet2d>(2);
-  Packet2d a_xx = pset1<Packet2d>(a[0]);
-  Packet2d a_yy = pset1<Packet2d>(a[1]);
-  Packet2d a_zz = pset1<Packet2d>(a[2]);
-  Packet2d a_ww = pset1<Packet2d>(a[3]);
-
-  // two temporaries:
-  Packet2d t1, t2;
-
-  /*
-   * t1 = ww*xy + yy*zw
-   * t2 = zz*xy - xx*zw
-   * res.xy = t1 +/- swap(t2)
-   */
-  t1 = padd(pmul(a_ww, b_xy), pmul(a_yy, b_zw));
-  t2 = psub(pmul(a_zz, b_xy), pmul(a_xx, b_zw));
-  pstoret<double,Packet2d,ResAlignment>(&res.x(), paddsub(t1, preverse(t2)));
-  
-  /*
-   * t1 = ww*zw - yy*xy
-   * t2 = zz*zw + xx*xy
-   * res.zw = t1 -/+ swap(t2) = swap( swap(t1) +/- t2)
-   */
-  t1 = psub(pmul(a_ww, b_zw), pmul(a_yy, b_xy));
-  t2 = padd(pmul(a_zz, b_zw), pmul(a_xx, b_xy));
-  pstoret<double,Packet2d,ResAlignment>(&res.z(), preverse(paddsub(preverse(t1), t2)));
-
-  return res;
-}
-};
-
-template<class Derived>
-struct quat_conj<Architecture::Target, Derived, double>
-{
-  enum {
-    ResAlignment = traits<Quaternion<double> >::Alignment
-  };
-  static inline Quaternion<double> run(const QuaternionBase<Derived>& q)
-  {
-    evaluator<typename Derived::Coefficients> qe(q.coeffs());
-    Quaternion<double> res;
-    const double neg_zero = numext::bit_cast<double>(0x8000000000000000ull);
-    const double arr1[2] = {neg_zero, neg_zero};
-    const double arr2[2] = {neg_zero,  0.0};
-    const Packet2d mask0 = ploadu<Packet2d>(arr1);
-    const Packet2d mask2 = ploadu<Packet2d>(arr2);
-    pstoret<double,Packet2d,ResAlignment>(&res.x(), pxor(mask0, qe.template packet<traits<Derived>::Alignment,Packet2d>(0)));
-    pstoret<double,Packet2d,ResAlignment>(&res.z(), pxor(mask2, qe.template packet<traits<Derived>::Alignment,Packet2d>(2)));
-    return res;
-  }
-};
-
-#endif // end EIGEN_VECTORIZE_SSE_OR_EIGEN_ARCH_ARM64
-
-} // end namespace internal
-
-} // end namespace Eigen
-
-#endif // EIGEN_GEOMETRY_SIMD_H

xtgeo/include/eigen3/Eigen/src/Householder/BlockHouseholder.h

@@ -1,110 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2010 Vincent Lejeune
-// Copyright (C) 2010 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_BLOCK_HOUSEHOLDER_H
-#define EIGEN_BLOCK_HOUSEHOLDER_H
-
-// This file contains some helper function to deal with block householder reflectors
-
-namespace Eigen { 
-
-namespace internal {
-  
-/** \internal */
-// template<typename TriangularFactorType,typename VectorsType,typename CoeffsType>
-// void make_block_householder_triangular_factor(TriangularFactorType& triFactor, const VectorsType& vectors, const CoeffsType& hCoeffs)
-// {
-//   typedef typename VectorsType::Scalar Scalar;
-//   const Index nbVecs = vectors.cols();
-//   eigen_assert(triFactor.rows() == nbVecs && triFactor.cols() == nbVecs && vectors.rows()>=nbVecs);
-// 
-//   for(Index i = 0; i < nbVecs; i++)
-//   {
-//     Index rs = vectors.rows() - i;
-//     // Warning, note that hCoeffs may alias with vectors.
-//     // It is then necessary to copy it before modifying vectors(i,i). 
-//     typename CoeffsType::Scalar h = hCoeffs(i);
-//     // This hack permits to pass trough nested Block<> and Transpose<> expressions.
-//     Scalar *Vii_ptr = const_cast<Scalar*>(vectors.data() + vectors.outerStride()*i + vectors.innerStride()*i);
-//     Scalar Vii = *Vii_ptr;
-//     *Vii_ptr = Scalar(1);
-//     triFactor.col(i).head(i).noalias() = -h * vectors.block(i, 0, rs, i).adjoint()
-//                                        * vectors.col(i).tail(rs);
-//     *Vii_ptr = Vii;
-//     // FIXME add .noalias() once the triangular product can work inplace
-//     triFactor.col(i).head(i) = triFactor.block(0,0,i,i).template triangularView<Upper>()
-//                              * triFactor.col(i).head(i);
-//     triFactor(i,i) = hCoeffs(i);
-//   }
-// }
-
-/** \internal */
-// This variant avoid modifications in vectors
-template<typename TriangularFactorType,typename VectorsType,typename CoeffsType>
-void make_block_householder_triangular_factor(TriangularFactorType& triFactor, const VectorsType& vectors, const CoeffsType& hCoeffs)
-{
-  const Index nbVecs = vectors.cols();
-  eigen_assert(triFactor.rows() == nbVecs && triFactor.cols() == nbVecs && vectors.rows()>=nbVecs);
-
-  for(Index i = nbVecs-1; i >=0 ; --i)
-  {
-    Index rs = vectors.rows() - i - 1;
-    Index rt = nbVecs-i-1;
-
-    if(rt>0)
-    {
-      triFactor.row(i).tail(rt).noalias() = -hCoeffs(i) * vectors.col(i).tail(rs).adjoint()
-                                                        * vectors.bottomRightCorner(rs, rt).template triangularView<UnitLower>();
-            
-      // FIXME use the following line with .noalias() once the triangular product can work inplace
-      // triFactor.row(i).tail(rt) = triFactor.row(i).tail(rt) * triFactor.bottomRightCorner(rt,rt).template triangularView<Upper>();
-      for(Index j=nbVecs-1; j>i; --j)
-      {
-        typename TriangularFactorType::Scalar z = triFactor(i,j);
-        triFactor(i,j) = z * triFactor(j,j);
-        if(nbVecs-j-1>0)
-          triFactor.row(i).tail(nbVecs-j-1) += z * triFactor.row(j).tail(nbVecs-j-1);
-      }
-      
-    }
-    triFactor(i,i) = hCoeffs(i);
-  }
-}
-
-/** \internal
-  * if forward then perform   mat = H0 * H1 * H2 * mat
-  * otherwise perform         mat = H2 * H1 * H0 * mat
-  */
-template<typename MatrixType,typename VectorsType,typename CoeffsType>
-void apply_block_householder_on_the_left(MatrixType& mat, const VectorsType& vectors, const CoeffsType& hCoeffs, bool forward)
-{
-  enum { TFactorSize = MatrixType::ColsAtCompileTime };
-  Index nbVecs = vectors.cols();
-  Matrix<typename MatrixType::Scalar, TFactorSize, TFactorSize, RowMajor> T(nbVecs,nbVecs);
-  
-  if(forward) make_block_householder_triangular_factor(T, vectors, hCoeffs);
-  else        make_block_householder_triangular_factor(T, vectors, hCoeffs.conjugate());  
-  const TriangularView<const VectorsType, UnitLower> V(vectors);
-
-  // A -= V T V^* A
-  Matrix<typename MatrixType::Scalar,VectorsType::ColsAtCompileTime,MatrixType::ColsAtCompileTime,
-         (VectorsType::MaxColsAtCompileTime==1 && MatrixType::MaxColsAtCompileTime!=1)?RowMajor:ColMajor,
-         VectorsType::MaxColsAtCompileTime,MatrixType::MaxColsAtCompileTime> tmp = V.adjoint() * mat;
-  // FIXME add .noalias() once the triangular product can work inplace
-  if(forward) tmp = T.template triangularView<Upper>()           * tmp;
-  else        tmp = T.template triangularView<Upper>().adjoint() * tmp;
-  mat.noalias() -= V * tmp;
-}
-
-} // end namespace internal
-
-} // end namespace Eigen
-
-#endif // EIGEN_BLOCK_HOUSEHOLDER_H