sequenzo 0.1.17__cp311-cp311-win_amd64.whl → 0.1.19__cp311-cp311-win_amd64.whl

sequenzo/dissimilarity_measures/src/eigen/unsupported/Eigen/CXX11/src/util/EmulateArray.h

@@ -1,261 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_EMULATE_ARRAY_H
-#define EIGEN_EMULATE_ARRAY_H
-
-
-
-// The array class is only available starting with cxx11. Emulate our own here
-// if needed. Beware, msvc still doesn't advertise itself as a c++11 compiler!
-// Moreover, CUDA doesn't support the STL containers, so we use our own instead.
-#if (__cplusplus <= 199711L && EIGEN_COMP_MSVC < 1900) || defined(EIGEN_GPUCC) || defined(EIGEN_AVOID_STL_ARRAY)
-
-namespace Eigen {
-template <typename T, size_t n> class array {
- public:
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE T& operator[] (size_t index) { eigen_internal_assert(index < size()); return values[index]; }
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE const T& operator[] (size_t index) const { eigen_internal_assert(index < size()); return values[index]; }
-
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE T& at(size_t index) { eigen_assert(index < size()); return values[index]; }
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE const T& at(size_t index) const { eigen_assert(index < size()); return values[index]; }
-
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE T& front() { return values[0]; }
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE const T& front() const { return values[0]; }
-
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE T& back() { return values[n-1]; }
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE const T& back() const { return values[n-1]; }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
-  static std::size_t size() { return n; }
-
-  T values[n];
-
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE array() { }
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE array(const T& v) {
-    EIGEN_STATIC_ASSERT(n==1, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    values[0] = v;
-  }
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE array(const T& v1, const T& v2) {
-    EIGEN_STATIC_ASSERT(n==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    values[0] = v1;
-    values[1] = v2;
-  }
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE array(const T& v1, const T& v2, const T& v3) {
-    EIGEN_STATIC_ASSERT(n==3, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    values[0] = v1;
-    values[1] = v2;
-    values[2] = v3;
-  }
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE array(const T& v1, const T& v2, const T& v3,
-                            const T& v4) {
-    EIGEN_STATIC_ASSERT(n==4, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    values[0] = v1;
-    values[1] = v2;
-    values[2] = v3;
-    values[3] = v4;
-  }
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE array(const T& v1, const T& v2, const T& v3, const T& v4,
-                            const T& v5) {
-    EIGEN_STATIC_ASSERT(n==5, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    values[0] = v1;
-    values[1] = v2;
-    values[2] = v3;
-    values[3] = v4;
-    values[4] = v5;
-  }
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE array(const T& v1, const T& v2, const T& v3, const T& v4,
-                            const T& v5, const T& v6) {
-    EIGEN_STATIC_ASSERT(n==6, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    values[0] = v1;
-    values[1] = v2;
-    values[2] = v3;
-    values[3] = v4;
-    values[4] = v5;
-    values[5] = v6;
-  }
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE array(const T& v1, const T& v2, const T& v3, const T& v4,
-                            const T& v5, const T& v6, const T& v7) {
-    EIGEN_STATIC_ASSERT(n==7, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    values[0] = v1;
-    values[1] = v2;
-    values[2] = v3;
-    values[3] = v4;
-    values[4] = v5;
-    values[5] = v6;
-    values[6] = v7;
-  }
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE array(
-      const T& v1, const T& v2, const T& v3, const T& v4,
-      const T& v5, const T& v6, const T& v7, const T& v8) {
-    EIGEN_STATIC_ASSERT(n==8, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    values[0] = v1;
-    values[1] = v2;
-    values[2] = v3;
-    values[3] = v4;
-    values[4] = v5;
-    values[5] = v6;
-    values[6] = v7;
-    values[7] = v8;
-  }
-
-#if EIGEN_HAS_VARIADIC_TEMPLATES
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE array(std::initializer_list<T> l) {
-    eigen_assert(l.size() == n);
-    internal::smart_copy(l.begin(), l.end(), values);
-  }
-#endif
-};
-
-
-// Specialize array for zero size
-template <typename T> class array<T, 0> {
- public:
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE T& operator[] (size_t) {
-    eigen_assert(false && "Can't index a zero size array");
-    return dummy;
-  }
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE const T& operator[] (size_t) const {
-    eigen_assert(false && "Can't index a zero size array");
-    return dummy;
-  }
-
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE T& front() {
-    eigen_assert(false && "Can't index a zero size array");
-    return dummy;
-  }
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE const T& front() const {
-    eigen_assert(false && "Can't index a zero size array");
-    return dummy;
-  }
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE T& back() {
-    eigen_assert(false && "Can't index a zero size array");
-    return dummy;
-  }
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE const T& back() const {
-    eigen_assert(false && "Can't index a zero size array");
-    return dummy;
-  }
-
-  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::size_t size() { return 0; }
-
-  EIGEN_DEVICE_FUNC
-  EIGEN_STRONG_INLINE array() : dummy() { }
-
-#if EIGEN_HAS_VARIADIC_TEMPLATES
-  EIGEN_DEVICE_FUNC array(std::initializer_list<T> l) : dummy() {
-    EIGEN_UNUSED_VARIABLE(l);
-    eigen_assert(l.size() == 0);
-  }
-#endif
-
- private:
-  T dummy;
-};
-
-// Comparison operator
-// Todo: implement !=, <, <=, >,  and >=
-template<class T, std::size_t N>
-EIGEN_DEVICE_FUNC bool operator==(const array<T,N>& lhs, const array<T,N>& rhs) {
-  for (std::size_t i = 0; i < N; ++i) {
-    if (lhs[i] != rhs[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-
-namespace internal {
-template<std::size_t I_, class T, std::size_t N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T& array_get(array<T,N>& a) {
-  return a[I_];
-}
-template<std::size_t I_, class T, std::size_t N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T& array_get(const array<T,N>& a) {
-  return a[I_];
-}
-
-template<class T, std::size_t N> struct array_size<array<T,N> > {
-  enum { value = N };
-};
-template<class T, std::size_t N> struct array_size<array<T,N>& > {
-  enum { value = N };
-};
-template<class T, std::size_t N> struct array_size<const array<T,N> > {
-  enum { value = N };
-};
-template<class T, std::size_t N> struct array_size<const array<T,N>& > {
-  enum { value = N };
-};
-
-}  // end namespace internal
-}  // end namespace Eigen
-
-#else
-
-// The compiler supports c++11, and we're not targeting cuda: use std::array as Eigen::array
-#include <array>
-namespace Eigen {
-
-template <typename T, std::size_t N> using array = std::array<T, N>;
-
-namespace internal {
-/* std::get is only constexpr in C++14, not yet in C++11
- *     - libstdc++ from version 4.7 onwards has it nevertheless,
- *                                          so use that
- *     - libstdc++ older versions: use _M_instance directly
- *     - libc++ all versions so far: use __elems_ directly
- *     - all other libs: use std::get to be portable, but
- *                       this may not be constexpr
- */
-#if defined(__GLIBCXX__) && __GLIBCXX__ < 20120322
-#define STD_GET_ARR_HACK             a._M_instance[I_]
-#elif defined(_LIBCPP_VERSION)
-#define STD_GET_ARR_HACK             a.__elems_[I_]
-#else
-#define STD_GET_ARR_HACK             std::template get<I_, T, N>(a)
-#endif
-
-template<std::size_t I_, class T, std::size_t N> constexpr inline T&       array_get(std::array<T,N>&       a) { return (T&)       STD_GET_ARR_HACK; }
-template<std::size_t I_, class T, std::size_t N> constexpr inline T&&      array_get(std::array<T,N>&&      a) { return (T&&)      STD_GET_ARR_HACK; }
-template<std::size_t I_, class T, std::size_t N> constexpr inline T const& array_get(std::array<T,N> const& a) { return (T const&) STD_GET_ARR_HACK; }
-
-#undef STD_GET_ARR_HACK
-
-}  // end namespace internal
-}  // end namespace Eigen
-
-#endif
-
-#endif  // EIGEN_EMULATE_ARRAY_H

sequenzo/dissimilarity_measures/src/eigen/unsupported/Eigen/CXX11/src/util/MaxSizeVector.h

@@ -1,158 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_FIXEDSIZEVECTOR_H
-#define EIGEN_FIXEDSIZEVECTOR_H
-
-namespace Eigen {
-
-/** \class MaxSizeVector
-  * \ingroup Core
-  *
-  * \brief The MaxSizeVector class.
-  *
-  * The %MaxSizeVector provides a subset of std::vector functionality.
-  *
-  * The goal is to provide basic std::vector operations when using
-  * std::vector is not an option (e.g. on GPU or when compiling using
-  * FMA/AVX, as this can cause either compilation failures or illegal
-  * instruction failures).
-  *
-  * Beware: The constructors are not API compatible with these of
-  * std::vector.
-  */
-template <typename T>
-class MaxSizeVector {
-  static const size_t alignment = EIGEN_PLAIN_ENUM_MAX(EIGEN_ALIGNOF(T), sizeof(void*));
- public:
-  // Construct a new MaxSizeVector, reserve n elements.
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  explicit MaxSizeVector(size_t n)
-      : reserve_(n), size_(0),
-        data_(static_cast<T*>(internal::handmade_aligned_malloc(n * sizeof(T), alignment))) {
-  }
-
-  // Construct a new MaxSizeVector, reserve and resize to n.
-  // Copy the init value to all elements.
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  MaxSizeVector(size_t n, const T& init)
-      : reserve_(n), size_(n),
-        data_(static_cast<T*>(internal::handmade_aligned_malloc(n * sizeof(T), alignment))) {
-    size_t i = 0;
-    EIGEN_TRY
-    {
-      for(; i < size_; ++i) { new (&data_[i]) T(init); }
-    }
-    EIGEN_CATCH(...)
-    {
-      // Construction failed, destruct in reverse order:
-      for(; (i+1) > 0; --i) { data_[i-1].~T(); }
-      internal::handmade_aligned_free(data_);
-      EIGEN_THROW;
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  ~MaxSizeVector() {
-    for (size_t i = size_; i > 0; --i) {
-      data_[i-1].~T();
-    }
-    internal::handmade_aligned_free(data_);
-  }
-
-  void resize(size_t n) {
-    eigen_assert(n <= reserve_);
-    for (; size_ < n; ++size_) {
-      new (&data_[size_]) T;
-    }
-    for (; size_ > n; --size_) {
-      data_[size_-1].~T();
-    }
-    eigen_assert(size_ == n);
-  }
-
-  // Append new elements (up to reserved size).
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  void push_back(const T& t) {
-    eigen_assert(size_ < reserve_);
-    new (&data_[size_++]) T(t);
-  }
-
-  // For C++03 compatibility this only takes one argument
-  template<class X>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  void emplace_back(const X& x) {
-    eigen_assert(size_ < reserve_);
-    new (&data_[size_++]) T(x);
-  }
-
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  const T& operator[] (size_t i) const {
-    eigen_assert(i < size_);
-    return data_[i];
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  T& operator[] (size_t i) {
-    eigen_assert(i < size_);
-    return data_[i];
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  T& back() {
-    eigen_assert(size_ > 0);
-    return data_[size_ - 1];
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  const T& back() const {
-    eigen_assert(size_ > 0);
-    return data_[size_ - 1];
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  void pop_back() {
-    eigen_assert(size_ > 0);
-    data_[--size_].~T();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  size_t size() const { return size_; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  bool empty() const { return size_ == 0; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  T* data() { return data_; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  const T* data() const { return data_; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  T* begin() { return data_; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  T* end() { return data_ + size_; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  const T* begin() const { return data_; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  const T* end() const { return data_ + size_; }
-
- private:
-  size_t reserve_;
-  size_t size_;
-  T* data_;
-};
-
-}  // namespace Eigen
-
-#endif  // EIGEN_FIXEDSIZEVECTOR_H

sequenzo/dissimilarity_measures/src/eigen/unsupported/Eigen/src/AutoDiff/AutoDiffJacobian.h

@@ -1,108 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 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_AUTODIFF_JACOBIAN_H
-#define EIGEN_AUTODIFF_JACOBIAN_H
-
-namespace Eigen
-{
-
-template<typename Functor> class AutoDiffJacobian : public Functor
-{
-public:
-  AutoDiffJacobian() : Functor() {}
-  AutoDiffJacobian(const Functor& f) : Functor(f) {}
-
-  // forward constructors
-#if EIGEN_HAS_VARIADIC_TEMPLATES
-  template<typename... T>
-  AutoDiffJacobian(const T& ...Values) : Functor(Values...) {}
-#else
-  template<typename T0>
-  AutoDiffJacobian(const T0& a0) : Functor(a0) {}
-  template<typename T0, typename T1>
-  AutoDiffJacobian(const T0& a0, const T1& a1) : Functor(a0, a1) {}
-  template<typename T0, typename T1, typename T2>
-  AutoDiffJacobian(const T0& a0, const T1& a1, const T2& a2) : Functor(a0, a1, a2) {}
-#endif
-
-  typedef typename Functor::InputType InputType;
-  typedef typename Functor::ValueType ValueType;
-  typedef typename ValueType::Scalar Scalar;
-
-  enum {
-    InputsAtCompileTime = InputType::RowsAtCompileTime,
-    ValuesAtCompileTime = ValueType::RowsAtCompileTime
-  };
-
-  typedef Matrix<Scalar, ValuesAtCompileTime, InputsAtCompileTime> JacobianType;
-  typedef typename JacobianType::Index Index;
-
-  typedef Matrix<Scalar, InputsAtCompileTime, 1> DerivativeType;
-  typedef AutoDiffScalar<DerivativeType> ActiveScalar;
-
-  typedef Matrix<ActiveScalar, InputsAtCompileTime, 1> ActiveInput;
-  typedef Matrix<ActiveScalar, ValuesAtCompileTime, 1> ActiveValue;
-
-#if EIGEN_HAS_VARIADIC_TEMPLATES
-  // Some compilers don't accept variadic parameters after a default parameter,
-  // i.e., we can't just write _jac=0 but we need to overload operator():
-  EIGEN_STRONG_INLINE
-  void operator() (const InputType& x, ValueType* v) const
-  {
-      this->operator()(x, v, 0);
-  }
-  template<typename... ParamsType>
-  void operator() (const InputType& x, ValueType* v, JacobianType* _jac,
-                   const ParamsType&... Params) const
-#else
-  void operator() (const InputType& x, ValueType* v, JacobianType* _jac=0) const
-#endif
-  {
-    eigen_assert(v!=0);
-
-    if (!_jac)
-    {
-#if EIGEN_HAS_VARIADIC_TEMPLATES
-      Functor::operator()(x, v, Params...);
-#else
-      Functor::operator()(x, v);
-#endif
-      return;
-    }
-
-    JacobianType& jac = *_jac;
-
-    ActiveInput ax = x.template cast<ActiveScalar>();
-    ActiveValue av(jac.rows());
-
-    if(InputsAtCompileTime==Dynamic)
-      for (Index j=0; j<jac.rows(); j++)
-        av[j].derivatives().resize(x.rows());
-
-    for (Index i=0; i<jac.cols(); i++)
-      ax[i].derivatives() = DerivativeType::Unit(x.rows(),i);
-
-#if EIGEN_HAS_VARIADIC_TEMPLATES
-    Functor::operator()(ax, &av, Params...);
-#else
-    Functor::operator()(ax, &av);
-#endif
-
-    for (Index i=0; i<jac.rows(); i++)
-    {
-      (*v)[i] = av[i].value();
-      jac.row(i) = av[i].derivatives();
-    }
-  }
-};
-
-}
-
-#endif // EIGEN_AUTODIFF_JACOBIAN_H