sequenzo 0.1.18__cp311-cp311-win_amd64.whl → 0.1.20__cp311-cp311-win_amd64.whl

sequenzo/dissimilarity_measures/src/eigen/test/packetmath_test_shared.h

@@ -1,275 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
-// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@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/.
-
-#include "main.h"
-#include <typeinfo>
-
-#if defined __GNUC__ && __GNUC__>=6
-  #pragma GCC diagnostic ignored "-Wignored-attributes"
-#endif
-// using namespace Eigen;
-
-bool g_first_pass = true;
-
-namespace Eigen {
-namespace internal {
-
-template<typename T> T negate(const T& x) { return -x; }
-
-template<typename T>
-Map<const Array<unsigned char,sizeof(T),1> >
-bits(const T& x) {
-  return Map<const Array<unsigned char,sizeof(T),1> >(reinterpret_cast<const unsigned char *>(&x));
-}
-
-// The following implement bitwise operations on floating point types
-template<typename T,typename Bits,typename Func>
-T apply_bit_op(Bits a, Bits b, Func f) {
-  Array<unsigned char,sizeof(T),1> data;
-  T res;
-  for(Index i = 0; i < data.size(); ++i)
-    data[i] = f(a[i], b[i]);
-  // Note: The reinterpret_cast works around GCC's class-memaccess warnings:
-  std::memcpy(reinterpret_cast<unsigned char*>(&res), data.data(), sizeof(T));
-  return res;
-}
-
-#define EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,T)             \
-  template<> T EIGEN_CAT(p,OP)(const T& a,const T& b) { \
-    return apply_bit_op<T>(bits(a),bits(b),FUNC);     \
-  }
-
-#define EIGEN_TEST_MAKE_BITWISE(OP,FUNC)                  \
-  EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,float)                 \
-  EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,double)                \
-  EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,half)                  \
-  EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,bfloat16)              \
-  EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,std::complex<float>)   \
-  EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,std::complex<double>)
-
-EIGEN_TEST_MAKE_BITWISE(xor,std::bit_xor<unsigned char>())
-EIGEN_TEST_MAKE_BITWISE(and,std::bit_and<unsigned char>())
-EIGEN_TEST_MAKE_BITWISE(or, std::bit_or<unsigned char>())
-struct bit_andnot{
-  template<typename T> T
-  operator()(T a, T b) const { return a & (~b); }
-};
-EIGEN_TEST_MAKE_BITWISE(andnot, bit_andnot())
-template<typename T>
-bool biteq(T a, T b) {
-  return (bits(a) == bits(b)).all();
-}
-
-}
-
-namespace test {
-
-// NOTE: we disable inlining for this function to workaround a GCC issue when using -O3 and the i387 FPU.
-template<typename Scalar> EIGEN_DONT_INLINE
-bool isApproxAbs(const Scalar& a, const Scalar& b, const typename NumTraits<Scalar>::Real& refvalue)
-{
-  return internal::isMuchSmallerThan(a-b, refvalue);
-}
-
-template<typename Scalar>
-inline void print_mismatch(const Scalar* ref, const Scalar* vec, int size) {
-  std::cout << "ref: [" << Map<const Matrix<Scalar,1,Dynamic> >(ref,size) << "]" << " != vec: [" << Map<const Matrix<Scalar,1,Dynamic> >(vec,size) << "]\n";
-}
-
-template<typename Scalar> bool areApproxAbs(const Scalar* a, const Scalar* b, int size, const typename NumTraits<Scalar>::Real& refvalue)
-{
-  for (int i=0; i<size; ++i)
-  {
-    if (!isApproxAbs(a[i],b[i],refvalue))
-    {
-      print_mismatch(a, b, size);
-      return false;
-    }
-  }
-  return true;
-}
-
-template<typename Scalar> bool areApprox(const Scalar* a, const Scalar* b, int size)
-{
-  for (int i=0; i<size; ++i)
-  {
-    if ( a[i]!=b[i] && !internal::isApprox(a[i],b[i]) 
-         && !((numext::isnan)(a[i]) && (numext::isnan)(b[i])) )
-    {
-      print_mismatch(a, b, size);
-      return false;
-    }
-  }
-  return true;
-}
-
-template<typename Scalar> bool areEqual(const Scalar* a, const Scalar* b, int size)
-{
-  for (int i=0; i<size; ++i)
-  {
-    if ( (a[i] != b[i]) && !((numext::isnan)(a[i]) && (numext::isnan)(b[i])) )
-    {
-      print_mismatch(a, b, size);
-      return false;
-    }
-  }
-  return true;
-}
-
-#define CHECK_CWISE1(REFOP, POP) { \
-  for (int i=0; i<PacketSize; ++i) \
-    ref[i] = REFOP(data1[i]); \
-  internal::pstore(data2, POP(internal::pload<Packet>(data1))); \
-  VERIFY(test::areApprox(ref, data2, PacketSize) && #POP); \
-}
-
-// Checks component-wise for input of size N. All of data1, data2, and ref
-// should have size at least ceil(N/PacketSize)*PacketSize to avoid memory
-// access errors.
-#define CHECK_CWISE1_N(REFOP, POP, N) { \
-  for (int i=0; i<N; ++i) \
-    ref[i] = REFOP(data1[i]); \
-  for (int j=0; j<N; j+=PacketSize) \
-    internal::pstore(data2 + j, POP(internal::pload<Packet>(data1 + j))); \
-  VERIFY(test::areApprox(ref, data2, N) && #POP); \
-}
-
-template<bool Cond,typename Packet>
-struct packet_helper
-{
-  template<typename T>
-  inline Packet load(const T* from) const { return internal::pload<Packet>(from); }
-
-  template<typename T>
-  inline Packet loadu(const T* from) const { return internal::ploadu<Packet>(from); }
-
-  template<typename T>
-  inline Packet load(const T* from, unsigned long long umask) const { return internal::ploadu<Packet>(from, umask); }
-
-  template<typename T>
-  inline void store(T* to, const Packet& x) const { internal::pstore(to,x); }
-
-  template<typename T>
-  inline void store(T* to, const Packet& x, unsigned long long umask) const { internal::pstoreu(to, x, umask); }
-
-  template<typename T>
-  inline Packet& forward_reference(Packet& packet, T& /*scalar*/) const { return packet; }
-};
-
-template<typename Packet>
-struct packet_helper<false,Packet>
-{
-  template<typename T>
-  inline T load(const T* from) const { return *from; }
-
-  template<typename T>
-  inline T loadu(const T* from) const { return *from; }
-
-  template<typename T>
-  inline T load(const T* from, unsigned long long) const { return *from; }
-
-  template<typename T>
-  inline void store(T* to, const T& x) const { *to = x; }
-
-  template<typename T>
-  inline void store(T* to, const T& x, unsigned long long) const { *to = x; }
-
-  template<typename T>
-  inline T& forward_reference(Packet& /*packet*/, T& scalar) const { return scalar; }
-};
-
-#define CHECK_CWISE1_IF(COND, REFOP, POP) if(COND) { \
-  test::packet_helper<COND,Packet> h; \
-  for (int i=0; i<PacketSize; ++i) \
-    ref[i] = Scalar(REFOP(data1[i])); \
-  h.store(data2, POP(h.load(data1))); \
-  VERIFY(test::areApprox(ref, data2, PacketSize) && #POP); \
-}
-
-#define CHECK_CWISE1_EXACT_IF(COND, REFOP, POP) if(COND) { \
-  test::packet_helper<COND,Packet> h; \
-  for (int i=0; i<PacketSize; ++i) \
-    ref[i] = Scalar(REFOP(data1[i])); \
-  h.store(data2, POP(h.load(data1))); \
-  VERIFY(test::areEqual(ref, data2, PacketSize) && #POP); \
-}
-
-#define CHECK_CWISE2_IF(COND, REFOP, POP) if(COND) { \
-  test::packet_helper<COND,Packet> h; \
-  for (int i=0; i<PacketSize; ++i) \
-    ref[i] = Scalar(REFOP(data1[i], data1[i+PacketSize]));     \
-  h.store(data2, POP(h.load(data1),h.load(data1+PacketSize))); \
-  VERIFY(test::areApprox(ref, data2, PacketSize) && #POP); \
-}
-
-// One input, one output by reference.
-#define CHECK_CWISE1_BYREF1_IF(COND, REFOP, POP) if(COND) { \
-  test::packet_helper<COND,Packet> h; \
-  for (int i=0; i<PacketSize; ++i) \
-    ref[i] = Scalar(REFOP(data1[i], ref[i+PacketSize]));     \
-  Packet pout; \
-  Scalar sout; \
-  h.store(data2, POP(h.load(data1), h.forward_reference(pout, sout))); \
-  h.store(data2+PacketSize, h.forward_reference(pout, sout)); \
-  VERIFY(test::areApprox(ref, data2, 2 * PacketSize) && #POP); \
-}
-
-#define CHECK_CWISE3_IF(COND, REFOP, POP) if (COND) {                      \
-  test::packet_helper<COND, Packet> h;                                     \
-  for (int i = 0; i < PacketSize; ++i)                                     \
-    ref[i] = Scalar(REFOP(data1[i], data1[i + PacketSize],                 \
-                          data1[i + 2 * PacketSize]));                     \
-  h.store(data2, POP(h.load(data1), h.load(data1 + PacketSize),            \
-                     h.load(data1 + 2 * PacketSize)));                     \
-  VERIFY(test::areApprox(ref, data2, PacketSize) && #POP);                 \
-}
-
-// Specialize the runall struct in your test file by defining run().
-template<
-  typename Scalar,
-  typename PacketType,
-  bool IsComplex = NumTraits<Scalar>::IsComplex,
-  bool IsInteger = NumTraits<Scalar>::IsInteger>
-struct runall;
-
-template<
-  typename Scalar,
-  typename PacketType = typename internal::packet_traits<Scalar>::type,
-  bool Vectorized = internal::packet_traits<Scalar>::Vectorizable,
-  bool HasHalf = !internal::is_same<typename internal::unpacket_traits<PacketType>::half,PacketType>::value >
-struct runner;
-
-template<typename Scalar,typename PacketType>
-struct runner<Scalar,PacketType,true,true>
-{
-  static void run() {
-    runall<Scalar,PacketType>::run();
-    runner<Scalar,typename internal::unpacket_traits<PacketType>::half>::run();
-  }
-};
-
-template<typename Scalar,typename PacketType>
-struct runner<Scalar,PacketType,true,false>
-{
-  static void run() {
-    runall<Scalar,PacketType>::run();
-  }
-};
-
-template<typename Scalar,typename PacketType>
-struct runner<Scalar,PacketType,false,false>
-{
-  static void run() {
-    runall<Scalar,PacketType>::run();
-  }
-};
-
-}
-}

sequenzo/dissimilarity_measures/src/eigen/test/product.h

@@ -1,259 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@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/.
-
-#include "main.h"
-#include <Eigen/QR>
-
-template<typename Derived1, typename Derived2>
-bool areNotApprox(const MatrixBase<Derived1>& m1, const MatrixBase<Derived2>& m2, typename Derived1::RealScalar epsilon = NumTraits<typename Derived1::RealScalar>::dummy_precision())
-{
-  return !((m1-m2).cwiseAbs2().maxCoeff() < epsilon * epsilon
-                          * (std::max)(m1.cwiseAbs2().maxCoeff(), m2.cwiseAbs2().maxCoeff()));
-}
-
-template<typename MatrixType> void product(const MatrixType& m)
-{
-  /* this test covers the following files:
-     Identity.h Product.h
-  */
-  typedef typename MatrixType::Scalar Scalar;
-  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> RowVectorType;
-  typedef Matrix<Scalar, MatrixType::ColsAtCompileTime, 1> ColVectorType;
-  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> RowSquareMatrixType;
-  typedef Matrix<Scalar, MatrixType::ColsAtCompileTime, MatrixType::ColsAtCompileTime> ColSquareMatrixType;
-  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime,
-                         MatrixType::Flags&RowMajorBit?ColMajor:RowMajor> OtherMajorMatrixType;
-
-  Index rows = m.rows();
-  Index cols = m.cols();
-
-  // this test relies a lot on Random.h, and there's not much more that we can do
-  // to test it, hence I consider that we will have tested Random.h
-  MatrixType m1 = MatrixType::Random(rows, cols),
-             m2 = MatrixType::Random(rows, cols),
-             m3(rows, cols);
-  RowSquareMatrixType
-             identity = RowSquareMatrixType::Identity(rows, rows),
-             square = RowSquareMatrixType::Random(rows, rows),
-             res = RowSquareMatrixType::Random(rows, rows);
-  ColSquareMatrixType
-             square2 = ColSquareMatrixType::Random(cols, cols),
-             res2 = ColSquareMatrixType::Random(cols, cols);
-  RowVectorType v1 = RowVectorType::Random(rows);
-  ColVectorType vc2 = ColVectorType::Random(cols), vcres(cols);
-  OtherMajorMatrixType tm1 = m1;
-
-  Scalar s1 = internal::random<Scalar>();
-
-  Index r  = internal::random<Index>(0, rows-1),
-        c  = internal::random<Index>(0, cols-1),
-        c2 = internal::random<Index>(0, cols-1);
-
-  // begin testing Product.h: only associativity for now
-  // (we use Transpose.h but this doesn't count as a test for it)
-  VERIFY_IS_APPROX((m1*m1.transpose())*m2,  m1*(m1.transpose()*m2));
-  m3 = m1;
-  m3 *= m1.transpose() * m2;
-  VERIFY_IS_APPROX(m3,                      m1 * (m1.transpose()*m2));
-  VERIFY_IS_APPROX(m3,                      m1 * (m1.transpose()*m2));
-
-  // continue testing Product.h: distributivity
-  VERIFY_IS_APPROX(square*(m1 + m2),        square*m1+square*m2);
-  VERIFY_IS_APPROX(square*(m1 - m2),        square*m1-square*m2);
-
-  // continue testing Product.h: compatibility with ScalarMultiple.h
-  VERIFY_IS_APPROX(s1*(square*m1),          (s1*square)*m1);
-  VERIFY_IS_APPROX(s1*(square*m1),          square*(m1*s1));
-
-  // test Product.h together with Identity.h
-  VERIFY_IS_APPROX(v1,                      identity*v1);
-  VERIFY_IS_APPROX(v1.transpose(),          v1.transpose() * identity);
-  // again, test operator() to check const-qualification
-  VERIFY_IS_APPROX(MatrixType::Identity(rows, cols)(r,c), static_cast<Scalar>(r==c));
-
-  if (rows!=cols)
-     VERIFY_RAISES_ASSERT(m3 = m1*m1);
-
-  // test the previous tests were not screwed up because operator* returns 0
-  // (we use the more accurate default epsilon)
-  if (!NumTraits<Scalar>::IsInteger && (std::min)(rows,cols)>1)
-  {
-    VERIFY(areNotApprox(m1.transpose()*m2,m2.transpose()*m1));
-  }
-
-  // test optimized operator+= path
-  res = square;
-  res.noalias() += m1 * m2.transpose();
-  VERIFY_IS_APPROX(res, square + m1 * m2.transpose());
-  if (!NumTraits<Scalar>::IsInteger && (std::min)(rows,cols)>1)
-  {
-    VERIFY(areNotApprox(res,square + m2 * m1.transpose()));
-  }
-  vcres = vc2;
-  vcres.noalias() += m1.transpose() * v1;
-  VERIFY_IS_APPROX(vcres, vc2 + m1.transpose() * v1);
-
-  // test optimized operator-= path
-  res = square;
-  res.noalias() -= m1 * m2.transpose();
-  VERIFY_IS_APPROX(res, square - (m1 * m2.transpose()));
-  if (!NumTraits<Scalar>::IsInteger && (std::min)(rows,cols)>1)
-  {
-    VERIFY(areNotApprox(res,square - m2 * m1.transpose()));
-  }
-  vcres = vc2;
-  vcres.noalias() -= m1.transpose() * v1;
-  VERIFY_IS_APPROX(vcres, vc2 - m1.transpose() * v1);
-
-  // test scaled products
-  res = square;
-  res.noalias() = s1 * m1 * m2.transpose();
-  VERIFY_IS_APPROX(res, ((s1*m1).eval() * m2.transpose()));
-  res = square;
-  res.noalias() += s1 * m1 * m2.transpose();
-  VERIFY_IS_APPROX(res, square + ((s1*m1).eval() * m2.transpose()));
-  res = square;
-  res.noalias() -= s1 * m1 * m2.transpose();
-  VERIFY_IS_APPROX(res, square - ((s1*m1).eval() * m2.transpose()));
-
-  // test d ?= a+b*c rules
-  res.noalias() = square + m1 * m2.transpose();
-  VERIFY_IS_APPROX(res, square + m1 * m2.transpose());
-  res.noalias() += square + m1 * m2.transpose();
-  VERIFY_IS_APPROX(res, 2*(square + m1 * m2.transpose()));
-  res.noalias() -= square + m1 * m2.transpose();
-  VERIFY_IS_APPROX(res, square + m1 * m2.transpose());
-
-  // test d ?= a-b*c rules
-  res.noalias() = square - m1 * m2.transpose();
-  VERIFY_IS_APPROX(res, square - m1 * m2.transpose());
-  res.noalias() += square - m1 * m2.transpose();
-  VERIFY_IS_APPROX(res, 2*(square - m1 * m2.transpose()));
-  res.noalias() -= square - m1 * m2.transpose();
-  VERIFY_IS_APPROX(res, square - m1 * m2.transpose());
-
-
-  tm1 = m1;
-  VERIFY_IS_APPROX(tm1.transpose() * v1, m1.transpose() * v1);
-  VERIFY_IS_APPROX(v1.transpose() * tm1, v1.transpose() * m1);
-
-  // test submatrix and matrix/vector product
-  for (int i=0; i<rows; ++i)
-    res.row(i) = m1.row(i) * m2.transpose();
-  VERIFY_IS_APPROX(res, m1 * m2.transpose());
-  // the other way round:
-  for (int i=0; i<rows; ++i)
-    res.col(i) = m1 * m2.transpose().col(i);
-  VERIFY_IS_APPROX(res, m1 * m2.transpose());
-
-  res2 = square2;
-  res2.noalias() += m1.transpose() * m2;
-  VERIFY_IS_APPROX(res2, square2 + m1.transpose() * m2);
-  if (!NumTraits<Scalar>::IsInteger && (std::min)(rows,cols)>1)
-  {
-    VERIFY(areNotApprox(res2,square2 + m2.transpose() * m1));
-  }
-
-  VERIFY_IS_APPROX(res.col(r).noalias() = square.adjoint() * square.col(r), (square.adjoint() * square.col(r)).eval());
-  VERIFY_IS_APPROX(res.col(r).noalias() = square * square.col(r), (square * square.col(r)).eval());
-
-  // vector at runtime (see bug 1166)
-  {
-    RowSquareMatrixType ref(square);
-    ColSquareMatrixType ref2(square2);
-    ref = res = square;
-    VERIFY_IS_APPROX(res.block(0,0,1,rows).noalias() = m1.col(0).transpose() * square.transpose(),            (ref.row(0) = m1.col(0).transpose() * square.transpose()));
-    VERIFY_IS_APPROX(res.block(0,0,1,rows).noalias() = m1.block(0,0,rows,1).transpose() * square.transpose(), (ref.row(0) = m1.col(0).transpose() * square.transpose()));
-    VERIFY_IS_APPROX(res.block(0,0,1,rows).noalias() = m1.col(0).transpose() * square,                        (ref.row(0) = m1.col(0).transpose() * square));
-    VERIFY_IS_APPROX(res.block(0,0,1,rows).noalias() = m1.block(0,0,rows,1).transpose() * square,             (ref.row(0) = m1.col(0).transpose() * square));
-    ref2 = res2 = square2;
-    VERIFY_IS_APPROX(res2.block(0,0,1,cols).noalias() = m1.row(0) * square2.transpose(),                      (ref2.row(0) = m1.row(0) * square2.transpose()));
-    VERIFY_IS_APPROX(res2.block(0,0,1,cols).noalias() = m1.block(0,0,1,cols) * square2.transpose(),           (ref2.row(0) = m1.row(0) * square2.transpose()));
-    VERIFY_IS_APPROX(res2.block(0,0,1,cols).noalias() = m1.row(0) * square2,                                  (ref2.row(0) = m1.row(0) * square2));
-    VERIFY_IS_APPROX(res2.block(0,0,1,cols).noalias() = m1.block(0,0,1,cols) * square2,                       (ref2.row(0) = m1.row(0) * square2));
-  }
-
-  // vector.block() (see bug 1283)
-  {
-    RowVectorType w1(rows);
-    VERIFY_IS_APPROX(square * v1.block(0,0,rows,1), square * v1);
-    VERIFY_IS_APPROX(w1.noalias() = square * v1.block(0,0,rows,1), square * v1);
-    VERIFY_IS_APPROX(w1.block(0,0,rows,1).noalias() = square * v1.block(0,0,rows,1), square * v1);
-
-    Matrix<Scalar,1,MatrixType::ColsAtCompileTime> w2(cols);
-    VERIFY_IS_APPROX(vc2.block(0,0,cols,1).transpose() * square2, vc2.transpose() * square2);
-    VERIFY_IS_APPROX(w2.noalias() = vc2.block(0,0,cols,1).transpose() * square2, vc2.transpose() * square2);
-    VERIFY_IS_APPROX(w2.block(0,0,1,cols).noalias() = vc2.block(0,0,cols,1).transpose() * square2, vc2.transpose() * square2);
-
-    vc2 = square2.block(0,0,1,cols).transpose();
-    VERIFY_IS_APPROX(square2.block(0,0,1,cols) * square2, vc2.transpose() * square2);
-    VERIFY_IS_APPROX(w2.noalias() = square2.block(0,0,1,cols) * square2, vc2.transpose() * square2);
-    VERIFY_IS_APPROX(w2.block(0,0,1,cols).noalias() = square2.block(0,0,1,cols) * square2, vc2.transpose() * square2);
-
-    vc2 = square2.block(0,0,cols,1);
-    VERIFY_IS_APPROX(square2.block(0,0,cols,1).transpose() * square2, vc2.transpose() * square2);
-    VERIFY_IS_APPROX(w2.noalias() = square2.block(0,0,cols,1).transpose() * square2, vc2.transpose() * square2);
-    VERIFY_IS_APPROX(w2.block(0,0,1,cols).noalias() = square2.block(0,0,cols,1).transpose() * square2, vc2.transpose() * square2);
-  }
-
-  // inner product
-  {
-    Scalar x = square2.row(c) * square2.col(c2);
-    VERIFY_IS_APPROX(x, square2.row(c).transpose().cwiseProduct(square2.col(c2)).sum());
-  }
-
-  // outer product
-  {
-    VERIFY_IS_APPROX(m1.col(c) * m1.row(r), m1.block(0,c,rows,1) * m1.block(r,0,1,cols));
-    VERIFY_IS_APPROX(m1.row(r).transpose() * m1.col(c).transpose(), m1.block(r,0,1,cols).transpose() * m1.block(0,c,rows,1).transpose());
-    VERIFY_IS_APPROX(m1.block(0,c,rows,1) * m1.row(r), m1.block(0,c,rows,1) * m1.block(r,0,1,cols));
-    VERIFY_IS_APPROX(m1.col(c) * m1.block(r,0,1,cols), m1.block(0,c,rows,1) * m1.block(r,0,1,cols));
-    VERIFY_IS_APPROX(m1.leftCols(1) * m1.row(r), m1.block(0,0,rows,1) * m1.block(r,0,1,cols));
-    VERIFY_IS_APPROX(m1.col(c) * m1.topRows(1), m1.block(0,c,rows,1) * m1.block(0,0,1,cols));
-  }
-
-  // Aliasing
-  {
-    ColVectorType x(cols); x.setRandom();
-    ColVectorType z(x);
-    ColVectorType y(cols); y.setZero();
-    ColSquareMatrixType A(cols,cols); A.setRandom();
-    // CwiseBinaryOp
-    VERIFY_IS_APPROX(x = y + A*x, A*z);
-    x = z;
-    VERIFY_IS_APPROX(x = y - A*x, A*(-z));
-    x = z;
-    // CwiseUnaryOp
-    VERIFY_IS_APPROX(x = Scalar(1.)*(A*x), A*z);
-  }
-
-  // regression for blas_trais
-  {
-    VERIFY_IS_APPROX(square * (square*square).transpose(), square * square.transpose() * square.transpose());
-    VERIFY_IS_APPROX(square * (-(square*square)), -square * square * square);
-    VERIFY_IS_APPROX(square * (s1*(square*square)), s1 * square * square * square);
-    VERIFY_IS_APPROX(square * (square*square).conjugate(), square * square.conjugate() * square.conjugate());
-  }
-
-  // destination with a non-default inner-stride
-  // see bug 1741
-  if(!MatrixType::IsRowMajor)
-  {
-    typedef Matrix<Scalar,Dynamic,Dynamic> MatrixX;
-    MatrixX buffer(2*rows,2*rows);
-    Map<RowSquareMatrixType,0,Stride<Dynamic,2> > map1(buffer.data(),rows,rows,Stride<Dynamic,2>(2*rows,2));
-    buffer.setZero();
-    VERIFY_IS_APPROX(map1 = m1 * m2.transpose(), (m1 * m2.transpose()).eval());
-    buffer.setZero();
-    VERIFY_IS_APPROX(map1.noalias() = m1 * m2.transpose(), (m1 * m2.transpose()).eval());
-    buffer.setZero();
-    VERIFY_IS_APPROX(map1.noalias() += m1 * m2.transpose(), (m1 * m2.transpose()).eval());
-  }
-
-}

sequenzo/dissimilarity_measures/src/eigen/test/random_without_cast_overflow.h

@@ -1,152 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2020 C. Antonio Sanchez <cantonios@google.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/.
-
-// Utilities for generating random numbers without overflows, which might
-// otherwise result in undefined behavior.
-
-namespace Eigen {
-namespace internal {
-
-// Default implementation assuming SrcScalar fits into TgtScalar.
-template <typename SrcScalar, typename TgtScalar, typename EnableIf = void>
-struct random_without_cast_overflow {
-  static SrcScalar value() { return internal::random<SrcScalar>(); }
-};
-
-// Signed to unsigned integer widening cast.
-template <typename SrcScalar, typename TgtScalar>
-struct random_without_cast_overflow<
-    SrcScalar, TgtScalar,
-    typename internal::enable_if<NumTraits<SrcScalar>::IsInteger && NumTraits<TgtScalar>::IsInteger &&
-                                 !NumTraits<TgtScalar>::IsSigned &&
-                                 (std::numeric_limits<SrcScalar>::digits < std::numeric_limits<TgtScalar>::digits ||
-                                  (std::numeric_limits<SrcScalar>::digits == std::numeric_limits<TgtScalar>::digits &&
-                                   NumTraits<SrcScalar>::IsSigned))>::type> {
-  static SrcScalar value() {
-    SrcScalar a = internal::random<SrcScalar>();
-    return a < SrcScalar(0) ? -(a + 1) : a;
-  }
-};
-
-// Integer to unsigned narrowing cast.
-template <typename SrcScalar, typename TgtScalar>
-struct random_without_cast_overflow<
-    SrcScalar, TgtScalar,
-    typename internal::enable_if<
-        NumTraits<SrcScalar>::IsInteger && NumTraits<TgtScalar>::IsInteger && !NumTraits<SrcScalar>::IsSigned &&
-        (std::numeric_limits<SrcScalar>::digits > std::numeric_limits<TgtScalar>::digits)>::type> {
-  static SrcScalar value() {
-    TgtScalar b = internal::random<TgtScalar>();
-    return static_cast<SrcScalar>(b < TgtScalar(0) ? -(b + 1) : b);
-  }
-};
-
-// Integer to signed narrowing cast.
-template <typename SrcScalar, typename TgtScalar>
-struct random_without_cast_overflow<
-    SrcScalar, TgtScalar,
-    typename internal::enable_if<
-        NumTraits<SrcScalar>::IsInteger && NumTraits<TgtScalar>::IsInteger && NumTraits<SrcScalar>::IsSigned &&
-        (std::numeric_limits<SrcScalar>::digits > std::numeric_limits<TgtScalar>::digits)>::type> {
-  static SrcScalar value() { return static_cast<SrcScalar>(internal::random<TgtScalar>()); }
-};
-
-// Unsigned to signed integer narrowing cast.
-template <typename SrcScalar, typename TgtScalar>
-struct random_without_cast_overflow<
-    SrcScalar, TgtScalar,
-    typename internal::enable_if<NumTraits<SrcScalar>::IsInteger && NumTraits<TgtScalar>::IsInteger &&
-                                 !NumTraits<SrcScalar>::IsSigned && NumTraits<TgtScalar>::IsSigned &&
-                                 (std::numeric_limits<SrcScalar>::digits ==
-                                  std::numeric_limits<TgtScalar>::digits)>::type> {
-  static SrcScalar value() { return internal::random<SrcScalar>() / 2; }
-};
-
-// Floating-point to integer, full precision.
-template <typename SrcScalar, typename TgtScalar>
-struct random_without_cast_overflow<
-    SrcScalar, TgtScalar,
-    typename internal::enable_if<
-        !NumTraits<SrcScalar>::IsInteger && !NumTraits<SrcScalar>::IsComplex && NumTraits<TgtScalar>::IsInteger &&
-        (std::numeric_limits<TgtScalar>::digits <= std::numeric_limits<SrcScalar>::digits)>::type> {
-  static SrcScalar value() { return static_cast<SrcScalar>(internal::random<TgtScalar>()); }
-};
-
-// Floating-point to integer, narrowing precision.
-template <typename SrcScalar, typename TgtScalar>
-struct random_without_cast_overflow<
-    SrcScalar, TgtScalar,
-    typename internal::enable_if<
-        !NumTraits<SrcScalar>::IsInteger && !NumTraits<SrcScalar>::IsComplex && NumTraits<TgtScalar>::IsInteger &&
-        (std::numeric_limits<TgtScalar>::digits > std::numeric_limits<SrcScalar>::digits)>::type> {
-  static SrcScalar value() {
-    // NOTE: internal::random<T>() is limited by RAND_MAX, so random<int64_t> is always within that range.
-    // This prevents us from simply shifting bits, which would result in only 0 or -1.
-    // Instead, keep least-significant K bits and sign.
-    static const TgtScalar KeepMask = (static_cast<TgtScalar>(1) << std::numeric_limits<SrcScalar>::digits) - 1;
-    const TgtScalar a = internal::random<TgtScalar>();
-    return static_cast<SrcScalar>(a > TgtScalar(0) ? (a & KeepMask) : -(a & KeepMask));
-  }
-};
-
-// Integer to floating-point, re-use above logic.
-template <typename SrcScalar, typename TgtScalar>
-struct random_without_cast_overflow<
-    SrcScalar, TgtScalar,
-    typename internal::enable_if<NumTraits<SrcScalar>::IsInteger && !NumTraits<TgtScalar>::IsInteger &&
-                                 !NumTraits<TgtScalar>::IsComplex>::type> {
-  static SrcScalar value() {
-    return static_cast<SrcScalar>(random_without_cast_overflow<TgtScalar, SrcScalar>::value());
-  }
-};
-
-// Floating-point narrowing conversion.
-template <typename SrcScalar, typename TgtScalar>
-struct random_without_cast_overflow<
-    SrcScalar, TgtScalar,
-    typename internal::enable_if<!NumTraits<SrcScalar>::IsInteger && !NumTraits<SrcScalar>::IsComplex &&
-                                 !NumTraits<TgtScalar>::IsInteger && !NumTraits<TgtScalar>::IsComplex &&
-                                 (std::numeric_limits<SrcScalar>::digits >
-                                  std::numeric_limits<TgtScalar>::digits)>::type> {
-  static SrcScalar value() { return static_cast<SrcScalar>(internal::random<TgtScalar>()); }
-};
-
-// Complex to non-complex.
-template <typename SrcScalar, typename TgtScalar>
-struct random_without_cast_overflow<
-    SrcScalar, TgtScalar,
-    typename internal::enable_if<NumTraits<SrcScalar>::IsComplex && !NumTraits<TgtScalar>::IsComplex>::type> {
-  typedef typename NumTraits<SrcScalar>::Real SrcReal;
-  static SrcScalar value() { return SrcScalar(random_without_cast_overflow<SrcReal, TgtScalar>::value(), 0); }
-};
-
-// Non-complex to complex.
-template <typename SrcScalar, typename TgtScalar>
-struct random_without_cast_overflow<
-    SrcScalar, TgtScalar,
-    typename internal::enable_if<!NumTraits<SrcScalar>::IsComplex && NumTraits<TgtScalar>::IsComplex>::type> {
-  typedef typename NumTraits<TgtScalar>::Real TgtReal;
-  static SrcScalar value() { return random_without_cast_overflow<SrcScalar, TgtReal>::value(); }
-};
-
-// Complex to complex.
-template <typename SrcScalar, typename TgtScalar>
-struct random_without_cast_overflow<
-    SrcScalar, TgtScalar,
-    typename internal::enable_if<NumTraits<SrcScalar>::IsComplex && NumTraits<TgtScalar>::IsComplex>::type> {
-  typedef typename NumTraits<SrcScalar>::Real SrcReal;
-  typedef typename NumTraits<TgtScalar>::Real TgtReal;
-  static SrcScalar value() {
-    return SrcScalar(random_without_cast_overflow<SrcReal, TgtReal>::value(),
-                     random_without_cast_overflow<SrcReal, TgtReal>::value());
-  }
-};
-
-}  // namespace internal
-}  // namespace Eigen