Upload 191 files

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/AnnoyingScalar.h

@@ -0,0 +1,204 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011-2018 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_TEST_ANNOYING_SCALAR_H
+#define EIGEN_TEST_ANNOYING_SCALAR_H
+
+#include <ostream>
+
+#if EIGEN_COMP_GNUC
+#pragma GCC diagnostic ignored "-Wshadow"
+#endif
+
+#if defined(EIGEN_EXCEPTIONS) && !defined(EIGEN_TEST_ANNOYING_SCALAR_DONT_THROW)
+struct my_exception {
+  my_exception() {}
+  ~my_exception() {}
+};
+#endif
+
+// An AnnoyingScalar is a pseudo scalar type that:
+// - can randomly through an exception in operator +
+// - randomly allocate on the heap or initialize a reference to itself making it non trivially copyable, nor movable,
+// nor relocatable.
+
+class AnnoyingScalar {
+ public:
+  AnnoyingScalar() {
+    init();
+    *v = 0;
+  }
+  AnnoyingScalar(long double _v) {
+    init();
+    *v = static_cast<float>(_v);
+  }
+  AnnoyingScalar(double _v) {
+    init();
+    *v = static_cast<float>(_v);
+  }
+  AnnoyingScalar(float _v) {
+    init();
+    *v = _v;
+  }
+  AnnoyingScalar(int _v) {
+    init();
+    *v = static_cast<float>(_v);
+  }
+  AnnoyingScalar(long _v) {
+    init();
+    *v = static_cast<float>(_v);
+  }
+  AnnoyingScalar(long long _v) {
+    init();
+    *v = static_cast<float>(_v);
+  }
+  AnnoyingScalar(const AnnoyingScalar& other) {
+    init();
+    *v = *(other.v);
+  }
+  ~AnnoyingScalar() {
+    if (v != &data) delete v;
+    instances--;
+  }
+
+  void init() {
+    if (internal::random<bool>())
+      v = new float;
+    else
+      v = &data;
+    instances++;
+  }
+
+  AnnoyingScalar operator+(const AnnoyingScalar& other) const {
+#if defined(EIGEN_EXCEPTIONS) && !defined(EIGEN_TEST_ANNOYING_SCALAR_DONT_THROW)
+    countdown--;
+    if (countdown <= 0 && !dont_throw) throw my_exception();
+#endif
+    return AnnoyingScalar(*v + *other.v);
+  }
+
+  AnnoyingScalar operator-() const { return AnnoyingScalar(-*v); }
+
+  AnnoyingScalar operator-(const AnnoyingScalar& other) const { return AnnoyingScalar(*v - *other.v); }
+
+  AnnoyingScalar operator*(const AnnoyingScalar& other) const { return AnnoyingScalar((*v) * (*other.v)); }
+
+  AnnoyingScalar operator/(const AnnoyingScalar& other) const { return AnnoyingScalar((*v) / (*other.v)); }
+
+  AnnoyingScalar& operator+=(const AnnoyingScalar& other) {
+    *v += *other.v;
+    return *this;
+  }
+  AnnoyingScalar& operator-=(const AnnoyingScalar& other) {
+    *v -= *other.v;
+    return *this;
+  }
+  AnnoyingScalar& operator*=(const AnnoyingScalar& other) {
+    *v *= *other.v;
+    return *this;
+  }
+  AnnoyingScalar& operator/=(const AnnoyingScalar& other) {
+    *v /= *other.v;
+    return *this;
+  }
+  AnnoyingScalar& operator=(const AnnoyingScalar& other) {
+    *v = *other.v;
+    return *this;
+  }
+
+  bool operator==(const AnnoyingScalar& other) const { return numext::equal_strict(*v, *other.v); }
+  bool operator!=(const AnnoyingScalar& other) const { return numext::not_equal_strict(*v, *other.v); }
+  bool operator<=(const AnnoyingScalar& other) const { return *v <= *other.v; }
+  bool operator<(const AnnoyingScalar& other) const { return *v < *other.v; }
+  bool operator>=(const AnnoyingScalar& other) const { return *v >= *other.v; }
+  bool operator>(const AnnoyingScalar& other) const { return *v > *other.v; }
+
+  float* v;
+  float data;
+  static int instances;
+#ifndef EIGEN_TEST_ANNOYING_SCALAR_DONT_THROW
+  static int countdown;
+  static bool dont_throw;
+#endif
+};
+
+AnnoyingScalar real(const AnnoyingScalar& x) { return x; }
+AnnoyingScalar imag(const AnnoyingScalar&) { return 0; }
+AnnoyingScalar conj(const AnnoyingScalar& x) { return x; }
+AnnoyingScalar sqrt(const AnnoyingScalar& x) { return std::sqrt(*x.v); }
+AnnoyingScalar abs(const AnnoyingScalar& x) { return std::abs(*x.v); }
+AnnoyingScalar cos(const AnnoyingScalar& x) { return std::cos(*x.v); }
+AnnoyingScalar sin(const AnnoyingScalar& x) { return std::sin(*x.v); }
+AnnoyingScalar acos(const AnnoyingScalar& x) { return std::acos(*x.v); }
+AnnoyingScalar atan2(const AnnoyingScalar& y, const AnnoyingScalar& x) { return std::atan2(*y.v, *x.v); }
+
+std::ostream& operator<<(std::ostream& stream, const AnnoyingScalar& x) {
+  stream << (*(x.v));
+  return stream;
+}
+
+int AnnoyingScalar::instances = 0;
+
+#ifndef EIGEN_TEST_ANNOYING_SCALAR_DONT_THROW
+int AnnoyingScalar::countdown = 0;
+bool AnnoyingScalar::dont_throw = false;
+#endif
+
+namespace Eigen {
+template <>
+struct NumTraits<AnnoyingScalar> : NumTraits<float> {
+  enum {
+    RequireInitialization = 1,
+  };
+  typedef AnnoyingScalar Real;
+  typedef AnnoyingScalar Nested;
+  typedef AnnoyingScalar Literal;
+  typedef AnnoyingScalar NonInteger;
+};
+
+template <>
+inline AnnoyingScalar test_precision<AnnoyingScalar>() {
+  return test_precision<float>();
+}
+
+namespace numext {
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool(isfinite)(const AnnoyingScalar& x) {
+  return (numext::isfinite)(*x.v);
+}
+}  // namespace numext
+
+namespace internal {
+template <>
+EIGEN_STRONG_INLINE double cast(const AnnoyingScalar& x) {
+  return double(*x.v);
+}
+template <>
+EIGEN_STRONG_INLINE float cast(const AnnoyingScalar& x) {
+  return *x.v;
+}
+
+}  // namespace internal
+}  // namespace Eigen
+
+AnnoyingScalar get_test_precision(const AnnoyingScalar&) { return Eigen::test_precision<AnnoyingScalar>(); }
+
+AnnoyingScalar test_relative_error(const AnnoyingScalar& a, const AnnoyingScalar& b) {
+  return test_relative_error(*a.v, *b.v);
+}
+
+inline bool test_isApprox(const AnnoyingScalar& a, const AnnoyingScalar& b) {
+  return internal::isApprox(*a.v, *b.v, test_precision<float>());
+}
+
+inline bool test_isMuchSmallerThan(const AnnoyingScalar& a, const AnnoyingScalar& b) {
+  return test_isMuchSmallerThan(*a.v, *b.v);
+}
+
+#endif  // EIGEN_TEST_ANNOYING_SCALAR_H

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/CMakeLists.txt

@@ -0,0 +1,506 @@
+# The file split_test_helper.h was generated at first run,
+# it is now included in test/
+if(EXISTS ${CMAKE_CURRENT_BINARY_DIR}/split_test_helper.h)
+  file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/split_test_helper.h)
+endif()
+
+# check if we have a Fortran compiler
+include(CheckLanguage)
+check_language(Fortran)
+if(CMAKE_Fortran_COMPILER)
+  enable_language(Fortran)
+  set(EIGEN_Fortran_COMPILER_WORKS ON)
+else()
+  set(EIGEN_Fortran_COMPILER_WORKS OFF)
+  # search for a default Lapack library to complete Eigen's one
+  find_package(LAPACK QUIET)
+endif()
+
+# TODO do the same for EXTERNAL_LAPACK
+option(EIGEN_TEST_EXTERNAL_BLAS "Use external BLAS library for testsuite" OFF)
+if(EIGEN_TEST_EXTERNAL_BLAS)
+  find_package(BLAS REQUIRED)
+  message(STATUS "BLAS_COMPILER_FLAGS: ${BLAS_COMPILER_FLAGS}")
+  add_definitions("-DEIGEN_USE_BLAS") # is adding  ${BLAS_COMPILER_FLAGS} necessary?
+  list(APPEND EXTERNAL_LIBS "${BLAS_LIBRARIES}")
+endif()
+
+# configure blas/lapack (use Eigen's ones)
+set(EIGEN_BLAS_LIBRARIES eigen_blas)
+set(EIGEN_LAPACK_LIBRARIES eigen_lapack)
+
+set(EIGEN_TEST_MATRIX_DIR "" CACHE STRING "Enable testing of realword sparse matrices contained in the specified path")
+if(EIGEN_TEST_MATRIX_DIR)
+  if(NOT WIN32)
+    message(STATUS "Test realworld sparse matrices: ${EIGEN_TEST_MATRIX_DIR}")
+    add_definitions( -DTEST_REAL_CASES="${EIGEN_TEST_MATRIX_DIR}" )
+  else()
+    message(STATUS "REAL CASES CAN NOT BE CURRENTLY TESTED ON WIN32")
+  endif()
+endif()
+
+set(SPARSE_LIBS " ")
+
+find_package(CHOLMOD)
+if(CHOLMOD_FOUND AND EIGEN_BUILD_BLAS AND EIGEN_BUILD_LAPACK)
+  add_definitions("-DEIGEN_CHOLMOD_SUPPORT")
+  include_directories(${CHOLMOD_INCLUDES})
+  set(SPARSE_LIBS ${SPARSE_LIBS} ${CHOLMOD_LIBRARIES} ${EIGEN_BLAS_LIBRARIES} ${EIGEN_LAPACK_LIBRARIES})
+  set(CHOLMOD_ALL_LIBS  ${CHOLMOD_LIBRARIES} ${EIGEN_BLAS_LIBRARIES} ${EIGEN_LAPACK_LIBRARIES})
+  ei_add_property(EIGEN_TESTED_BACKENDS "CHOLMOD, ")
+
+  ei_add_test(cholmod_support "" "${CHOLMOD_ALL_LIBS}")
+else()
+  ei_add_property(EIGEN_MISSING_BACKENDS "CHOLMOD, ")
+endif()
+
+find_package(UMFPACK)
+if(UMFPACK_FOUND AND EIGEN_BUILD_BLAS)
+  add_definitions("-DEIGEN_UMFPACK_SUPPORT")
+  include_directories(${UMFPACK_INCLUDES})
+  set(SPARSE_LIBS ${SPARSE_LIBS} ${UMFPACK_LIBRARIES} ${EIGEN_BLAS_LIBRARIES})
+  set(UMFPACK_ALL_LIBS ${UMFPACK_LIBRARIES} ${EIGEN_BLAS_LIBRARIES})
+  ei_add_property(EIGEN_TESTED_BACKENDS "UMFPACK, ")
+
+  ei_add_test(umfpack_support "" "${UMFPACK_ALL_LIBS}")
+else()
+  ei_add_property(EIGEN_MISSING_BACKENDS "UMFPACK, ")
+endif()
+
+find_package(KLU)
+if(KLU_FOUND AND EIGEN_BUILD_BLAS)
+  add_definitions("-DEIGEN_KLU_SUPPORT")
+  include_directories(${KLU_INCLUDES})
+  set(SPARSE_LIBS ${SPARSE_LIBS} ${KLU_LIBRARIES} ${EIGEN_BLAS_LIBRARIES})
+  set(KLU_ALL_LIBS ${KLU_LIBRARIES} ${EIGEN_BLAS_LIBRARIES})
+  ei_add_property(EIGEN_TESTED_BACKENDS "KLU, ")
+
+  ei_add_test(klu_support "" "${KLU_ALL_LIBS}")
+else()
+  ei_add_property(EIGEN_MISSING_BACKENDS "KLU, ")
+endif()
+
+find_package(SuperLU 4.0)
+if(SuperLU_FOUND AND EIGEN_BUILD_BLAS)
+  add_definitions("-DEIGEN_SUPERLU_SUPPORT")
+  include_directories(${SUPERLU_INCLUDES})
+  set(SPARSE_LIBS ${SPARSE_LIBS} ${SUPERLU_LIBRARIES} ${EIGEN_BLAS_LIBRARIES})
+  set(SUPERLU_ALL_LIBS ${SUPERLU_LIBRARIES} ${EIGEN_BLAS_LIBRARIES})
+  ei_add_property(EIGEN_TESTED_BACKENDS  "SuperLU, ")
+
+  ei_add_test(superlu_support "" "${SUPERLU_ALL_LIBS}")
+else()
+  ei_add_property(EIGEN_MISSING_BACKENDS  "SuperLU, ")
+endif()
+
+
+find_package(PASTIX QUIET COMPONENTS METIS SEQ)
+# check that the PASTIX found is a version without MPI
+find_path(PASTIX_pastix_nompi.h_INCLUDE_DIRS
+  NAMES pastix_nompi.h
+  HINTS ${PASTIX_INCLUDE_DIRS}
+)
+if (NOT PASTIX_pastix_nompi.h_INCLUDE_DIRS)
+  message(STATUS "A version of Pastix has been found but pastix_nompi.h does not exist in the include directory."
+                 " Because Eigen tests require a version without MPI, we disable the Pastix backend.")
+endif()
+if(PASTIX_FOUND AND PASTIX_pastix_nompi.h_INCLUDE_DIRS)
+  add_definitions("-DEIGEN_PASTIX_SUPPORT")
+  include_directories(${PASTIX_INCLUDE_DIRS_DEP})
+  if(SCOTCH_FOUND)
+    include_directories(${SCOTCH_INCLUDE_DIRS})
+    set(PASTIX_LIBRARIES ${PASTIX_LIBRARIES} ${SCOTCH_LIBRARIES})
+  elseif(METIS_FOUND)
+    include_directories(${METIS_INCLUDE_DIRS})
+    set(PASTIX_LIBRARIES ${PASTIX_LIBRARIES} ${METIS_LIBRARIES})
+  else()
+    ei_add_property(EIGEN_MISSING_BACKENDS  "PaStiX, ")
+  endif()
+  set(SPARSE_LIBS ${SPARSE_LIBS} ${PASTIX_LIBRARIES_DEP} ${ORDERING_LIBRARIES})
+  set(PASTIX_ALL_LIBS ${PASTIX_LIBRARIES_DEP})
+  ei_add_property(EIGEN_TESTED_BACKENDS  "PaStiX, ")
+else()
+  ei_add_property(EIGEN_MISSING_BACKENDS  "PaStiX, ")
+endif()
+
+if(METIS_FOUND)
+  add_definitions("-DEIGEN_METIS_SUPPORT")
+  include_directories(${METIS_INCLUDE_DIRS})
+  ei_add_property(EIGEN_TESTED_BACKENDS "METIS, ")
+else()
+  ei_add_property(EIGEN_MISSING_BACKENDS "METIS, ")
+endif()
+
+find_package(SPQR)
+if(SPQR_FOUND AND CHOLMOD_FOUND AND EIGEN_BUILD_BLAS AND EIGEN_BUILD_LAPACK AND (EIGEN_Fortran_COMPILER_WORKS OR LAPACK_FOUND) )
+  add_definitions("-DEIGEN_SPQR_SUPPORT")
+  include_directories(${SPQR_INCLUDES})
+  set(SPQR_ALL_LIBS ${SPQR_LIBRARIES} ${CHOLMOD_LIBRARIES} ${EIGEN_LAPACK_LIBRARIES} ${EIGEN_BLAS_LIBRARIES} ${LAPACK_LIBRARIES})
+  set(SPARSE_LIBS ${SPARSE_LIBS} ${SPQR_ALL_LIBS})
+  ei_add_property(EIGEN_TESTED_BACKENDS "SPQR, ")
+else()
+  ei_add_property(EIGEN_MISSING_BACKENDS "SPQR, ")
+endif()
+
+find_package(Accelerate)
+if(Accelerate_FOUND)
+  add_definitions("-DEIGEN_ACCELERATE_SUPPORT")
+  include_directories(${Accelerate_INCLUDES})
+  set(SPARSE_LIBS ${SPARSE_LIBS} ${Accelerate_LIBRARIES})
+  set(Accelerate_ALL_LIBS ${Accelerate_LIBRARIES})
+  ei_add_property(EIGEN_TESTED_BACKENDS "Accelerate, ")
+else()
+  ei_add_property(EIGEN_MISSING_BACKENDS "Accelerate, ")
+endif()
+
+option(EIGEN_TEST_NOQT "Disable Qt support in unit tests" OFF)
+if(NOT EIGEN_TEST_NOQT)
+  find_package(Qt4)
+  if(QT4_FOUND)
+    include(${QT_USE_FILE})
+    ei_add_property(EIGEN_TESTED_BACKENDS  "Qt4 support, ")
+  else()
+    ei_add_property(EIGEN_MISSING_BACKENDS  "Qt4 support, ")
+  endif()
+endif()
+
+if(TEST_LIB)
+  add_definitions("-DEIGEN_EXTERN_INSTANTIATIONS=1")
+endif()
+
+set_property(GLOBAL PROPERTY EIGEN_CURRENT_SUBPROJECT "Official")
+add_custom_target(BuildOfficial)
+
+ei_add_test(clz)
+ei_add_test(rand)
+ei_add_test(meta)
+ei_add_test(maxsizevector)
+ei_add_test(numext)
+ei_add_test(sizeof)
+ei_add_test(dynalloc)
+ei_add_test(nomalloc)
+ei_add_test(first_aligned)
+ei_add_test(type_alias)
+ei_add_test(nullary)
+ei_add_test(mixingtypes)
+ei_add_test(float_conversion)
+ei_add_test(io)
+ei_add_test(packetmath "-DEIGEN_FAST_MATH=1")
+ei_add_test(packet_segment)
+ei_add_test(vectorization_logic)
+ei_add_test(basicstuff)
+ei_add_test(constexpr)
+ei_add_test(constructor)
+ei_add_test(linearstructure)
+ei_add_test(integer_types)
+ei_add_test(unalignedcount)
+if(NOT EIGEN_TEST_NO_EXCEPTIONS AND NOT EIGEN_TEST_OPENMP)
+  ei_add_test(exceptions)
+endif()
+ei_add_test(redux)
+ei_add_test(visitor)
+ei_add_test(block)
+ei_add_test(corners)
+ei_add_test(symbolic_index)
+ei_add_test(indexed_view)
+ei_add_test(reshape)
+ei_add_test(swap)
+ei_add_test(resize)
+ei_add_test(conservative_resize)
+ei_add_test(product_small)
+ei_add_test(product_large)
+ei_add_test(product_extra)
+ei_add_test(diagonalmatrices)
+ei_add_test(skew_symmetric_matrix3)
+ei_add_test(adjoint)
+ei_add_test(diagonal)
+ei_add_test(miscmatrices)
+ei_add_test(commainitializer)
+ei_add_test(smallvectors)
+ei_add_test(mapped_matrix)
+ei_add_test(mapstride)
+ei_add_test(unaryview)
+ei_add_test(mapstaticmethods)
+ei_add_test(array_cwise)
+ei_add_test(matrix_cwise)
+ei_add_test(array_for_matrix)
+ei_add_test(array_replicate)
+ei_add_test(array_reverse)
+ei_add_test(ref)
+ei_add_test(is_same_dense)
+ei_add_test(triangular)
+ei_add_test(selfadjoint)
+ei_add_test(product_selfadjoint)
+ei_add_test(product_symm)
+ei_add_test(product_syrk)
+ei_add_test(product_trmv)
+ei_add_test(product_trmm)
+ei_add_test(product_trsolve)
+ei_add_test(product_mmtr)
+ei_add_test(product_notemporary)
+ei_add_test(product_threaded "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
+ei_add_test(stable_norm)
+ei_add_test(permutationmatrices)
+ei_add_test(bandmatrix)
+ei_add_test(cholesky)
+ei_add_test(lu)
+ei_add_test(determinant)
+ei_add_test(inverse)
+ei_add_test(qr)
+ei_add_test(qr_colpivoting)
+ei_add_test(qr_fullpivoting)
+ei_add_test(upperbidiagonalization)
+ei_add_test(hessenberg)
+ei_add_test(schur_real)
+ei_add_test(schur_complex)
+ei_add_test(eigensolver_selfadjoint)
+ei_add_test(eigensolver_generic)
+ei_add_test(eigensolver_complex)
+ei_add_test(real_qz)
+ei_add_test(complex_qz)
+ei_add_test(eigensolver_generalized_real)
+ei_add_test(jacobi)
+ei_add_test(jacobisvd)
+ei_add_test(bdcsvd)
+ei_add_test(householder)
+ei_add_test(geo_orthomethods)
+ei_add_test(geo_quaternion)
+ei_add_test(geo_eulerangles)
+ei_add_test(geo_parametrizedline)
+ei_add_test(geo_alignedbox)
+ei_add_test(geo_hyperplane)
+ei_add_test(geo_transformations)
+ei_add_test(geo_homogeneous)
+ei_add_test(stdvector)
+ei_add_test(stdvector_overload)
+ei_add_test(stdlist)
+ei_add_test(stdlist_overload)
+ei_add_test(stddeque)
+ei_add_test(stddeque_overload)
+ei_add_test(sparse_basic)
+ei_add_test(sparse_block)
+ei_add_test(sparse_vector)
+ei_add_test(sparse_product)
+ei_add_test(sparse_ref)
+ei_add_test(sparse_solvers)
+ei_add_test(sparse_permutations)
+ei_add_test(simplicial_cholesky)
+ei_add_test(conjugate_gradient)
+ei_add_test(incomplete_cholesky)
+ei_add_test(incomplete_LUT)
+ei_add_test(bicgstab)
+ei_add_test(lscg)
+ei_add_test(sparselu)
+ei_add_test(sparseqr)
+ei_add_test(umeyama)
+ei_add_test(nesting_ops "${CMAKE_CXX_FLAGS_DEBUG}")
+ei_add_test(nestbyvalue)
+ei_add_test(zerosized)
+ei_add_test(dontalign)
+ei_add_test(evaluators)
+if(NOT EIGEN_TEST_NO_EXCEPTIONS)
+  ei_add_test(sizeoverflow)
+endif()
+ei_add_test(prec_inverse_4x4)
+ei_add_test(vectorwiseop)
+ei_add_test(special_numbers)
+ei_add_test(rvalue_types)
+ei_add_test(dense_storage)
+ei_add_test(ctorleak)
+ei_add_test(inplace_decomposition)
+ei_add_test(half_float)
+ei_add_test(bfloat16_float)
+ei_add_test(array_of_string)
+ei_add_test(num_dimensions)
+ei_add_test(stl_iterators)
+ei_add_test(blasutil)
+ei_add_test(random_matrix)
+ei_add_test(initializer_list_construction)
+ei_add_test(diagonal_matrix_variadic_ctor)
+ei_add_test(serializer)
+ei_add_test(tuple_test)
+ei_add_test(threads_eventcount "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
+ei_add_test(threads_runqueue "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
+ei_add_test(threads_non_blocking_thread_pool "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
+ei_add_test(threads_fork_join "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
+add_executable(bug1213 bug1213.cpp bug1213_main.cpp)
+target_link_libraries(bug1213 Eigen3::Eigen)
+
+check_cxx_compiler_flag("-ffast-math" COMPILER_SUPPORT_FASTMATH)
+if(COMPILER_SUPPORT_FASTMATH)
+  set(EIGEN_FASTMATH_FLAGS "-ffast-math")
+else()
+  check_cxx_compiler_flag("/fp:fast" COMPILER_SUPPORT_FPFAST)
+  if(COMPILER_SUPPORT_FPFAST)
+    set(EIGEN_FASTMATH_FLAGS "/fp:fast")
+  endif()
+endif()
+
+ei_add_test(fastmath "${EIGEN_FASTMATH_FLAGS}")
+
+# # ei_add_test(denseLM)
+
+if(QT4_FOUND)
+  ei_add_test(qtvector "" "${QT_QTCORE_LIBRARY}")
+endif()
+
+if(PARDISO_FOUND)
+  ei_add_test(pardiso_support "" "${PARDISO_ALL_LIBS}")
+endif()
+
+if(PASTIX_FOUND AND (SCOTCH_FOUND OR METIS_FOUND))
+  ei_add_test(pastix_support "" "${PASTIX_ALL_LIBS}")
+endif()
+
+if(SPQR_FOUND AND CHOLMOD_FOUND AND EIGEN_BUILD_BLAS AND EIGEN_BUILD_LAPACK)
+  ei_add_test(spqr_support "" "${SPQR_ALL_LIBS}")
+endif()
+
+if(METIS_FOUND)
+ei_add_test(metis_support "" "${METIS_LIBRARIES}")
+endif()
+
+if(Accelerate_FOUND)
+  ei_add_test(accelerate_support "" "${Accelerate_ALL_LIBS}")
+endif()
+
+string(TOLOWER "${CMAKE_CXX_COMPILER}" cmake_cxx_compiler_tolower)
+if(cmake_cxx_compiler_tolower MATCHES "qcc")
+  set(CXX_IS_QCC "ON")
+endif()
+
+ei_add_property(EIGEN_TESTING_SUMMARY "CXX:               ${CMAKE_CXX_COMPILER}\n")
+if(CMAKE_COMPILER_IS_GNUCXX AND NOT CXX_IS_QCC)
+  execute_process(COMMAND ${CMAKE_CXX_COMPILER} --version COMMAND head -n 1 OUTPUT_VARIABLE EIGEN_CXX_VERSION_STRING OUTPUT_STRIP_TRAILING_WHITESPACE)
+  ei_add_property(EIGEN_TESTING_SUMMARY "CXX_VERSION:       ${EIGEN_CXX_VERSION_STRING}\n")
+endif()
+ei_add_property(EIGEN_TESTING_SUMMARY "CXX_FLAGS:         ${CMAKE_CXX_FLAGS}\n")
+if (EIGEN_TEST_CUSTOM_CXX_FLAGS)
+  ei_add_property(EIGEN_TESTING_SUMMARY "Custom CXX flags:  ${EIGEN_TEST_CUSTOM_CXX_FLAGS}\n")
+endif()
+ei_add_property(EIGEN_TESTING_SUMMARY "Sparse lib flags:  ${SPARSE_LIBS}\n")
+
+option(EIGEN_TEST_EIGEN2 "Run whole Eigen2 test suite against EIGEN2_SUPPORT" OFF)
+mark_as_advanced(EIGEN_TEST_EIGEN2)
+if(EIGEN_TEST_EIGEN2)
+  message(WARNING "The Eigen2 test suite has been removed")
+endif()
+
+# boost MP unit test
+find_package(Boost 1.53.0 CONFIG)
+if(Boost_FOUND)
+  include_directories(${Boost_INCLUDE_DIRS})
+  ei_add_test(boostmultiprec "" "${Boost_LIBRARIES}")
+  ei_add_property(EIGEN_TESTED_BACKENDS "Boost.Multiprecision, ")
+else()
+  ei_add_property(EIGEN_MISSING_BACKENDS "Boost.Multiprecision, ")
+endif()
+
+
+# CUDA unit tests
+option(EIGEN_TEST_CUDA "Enable CUDA support in unit tests" OFF)
+option(EIGEN_TEST_CUDA_CLANG "Use clang instead of nvcc to compile the CUDA tests" OFF)
+
+if(EIGEN_TEST_CUDA_CLANG AND NOT CMAKE_CXX_COMPILER MATCHES "clang")
+  message(WARNING "EIGEN_TEST_CUDA_CLANG is set, but CMAKE_CXX_COMPILER does not appear to be clang.")
+endif()
+
+find_package(CUDA 9.0)
+if(CUDA_FOUND AND EIGEN_TEST_CUDA)
+  # Make sure to compile without the -pedantic, -Wundef, -Wnon-virtual-dtor
+  # and -fno-check-new flags since they trigger thousands of compilation warnings
+  # in the CUDA runtime
+  string(REPLACE "-pedantic" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+  string(REPLACE "-Wundef" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+  string(REPLACE "-Wnon-virtual-dtor" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+  string(REPLACE "-fno-check-new" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+
+  if(EIGEN_TEST_CUDA_CLANG)
+    string(APPEND CMAKE_CXX_FLAGS " --cuda-path=${CUDA_TOOLKIT_ROOT_DIR}")
+    foreach(GPU IN LISTS EIGEN_CUDA_COMPUTE_ARCH)
+      string(APPEND CMAKE_CXX_FLAGS " --cuda-gpu-arch=sm_${GPU}")
+    endforeach()
+    string(APPEND CMAKE_CXX_FLAGS " ${EIGEN_CUDA_CXX_FLAGS}")
+  else()
+    set(CUDA_PROPAGATE_HOST_FLAGS OFF)
+    set(NVCC_ARCH_FLAGS)
+    # Define an -arch=sm_<arch>, otherwise if GPU does not exactly match one of
+    # those in the arch list for -gencode, the kernels will fail to run with
+    #    cudaErrorNoKernelImageForDevice
+    # This can happen with newer cards (e.g. sm_75) and compiling with older
+    # versions of nvcc (e.g. 9.2) that do not support their specific arch.
+    list(LENGTH EIGEN_CUDA_COMPUTE_ARCH EIGEN_CUDA_COMPUTE_ARCH_SIZE)
+    if(EIGEN_CUDA_COMPUTE_ARCH_SIZE)
+      list(GET EIGEN_CUDA_COMPUTE_ARCH 0 EIGEN_CUDA_COMPUTE_DEFAULT)
+      set(NVCC_ARCH_FLAGS " -arch=sm_${EIGEN_CUDA_COMPUTE_DEFAULT}")
+    endif()
+    foreach(ARCH IN LISTS EIGEN_CUDA_COMPUTE_ARCH)
+      string(APPEND NVCC_ARCH_FLAGS " -gencode arch=compute_${ARCH},code=sm_${ARCH}")
+    endforeach()
+    set(CUDA_NVCC_FLAGS  "--expt-relaxed-constexpr -Xcudafe \"--display_error_number\" ${NVCC_ARCH_FLAGS} ${CUDA_NVCC_FLAGS} ${EIGEN_CUDA_CXX_FLAGS}")
+    cuda_include_directories("${CMAKE_CURRENT_BINARY_DIR}" "${CUDA_TOOLKIT_ROOT_DIR}/include")
+  endif()
+
+  set(EIGEN_ADD_TEST_FILENAME_EXTENSION  "cu")
+
+  ei_add_test(gpu_example)
+  ei_add_test(gpu_basic)
+
+  unset(EIGEN_ADD_TEST_FILENAME_EXTENSION)
+
+endif()
+
+
+# HIP unit tests
+option(EIGEN_TEST_HIP "Add HIP support." OFF)
+if (EIGEN_TEST_HIP)
+
+  set(ROCM_PATH "/opt/rocm" CACHE STRING "Path to the ROCm installation.")
+
+  if (EXISTS ${ROCM_PATH}/hip)
+    set(HIP_PATH ${ROCM_PATH}/hip)
+    list(APPEND CMAKE_MODULE_PATH ${HIP_PATH}/cmake)
+  elseif (EXISTS ${ROCM_PATH}/lib/cmake/hip)
+    set(HIP_PATH ${ROCM_PATH})
+    list(APPEND CMAKE_MODULE_PATH ${HIP_PATH}/lib/cmake/hip)
+  else ()
+    message(FATAL_ERROR "EIGEN_TEST_HIP is ON, but could not find the ROCm installation under ${ROCM_PATH}")
+  endif()
+
+  find_package(HIP REQUIRED)
+  if (HIP_FOUND)
+    execute_process(COMMAND ${HIP_PATH}/bin/hipconfig --platform OUTPUT_VARIABLE HIP_PLATFORM)
+
+    if ((${HIP_PLATFORM} STREQUAL "hcc") OR (${HIP_PLATFORM} STREQUAL "amd"))
+
+      include_directories(${HIP_PATH}/include)
+
+      set(EIGEN_ADD_TEST_FILENAME_EXTENSION  "cu")
+      ei_add_test(gpu_basic)
+      ei_add_test(gpu_example)
+      unset(EIGEN_ADD_TEST_FILENAME_EXTENSION)
+
+    elseif ((${HIP_PLATFORM} STREQUAL "nvcc") OR (${HIP_PLATFORM} STREQUAL "nvidia"))
+      message(FATAL_ERROR "HIP_PLATFORM = nvcc is not supported within Eigen")
+    else ()
+      message(FATAL_ERROR "Unknown HIP_PLATFORM = ${HIP_PLATFORM}")
+    endif()
+  endif()
+endif()
+
+if(EIGEN_TEST_SYCL)
+  set(EIGEN_SYCL ON)
+  include(SyclConfigureTesting)
+
+  ei_add_test(sycl_basic)
+  set(EIGEN_SYCL OFF)
+endif()
+
+cmake_dependent_option(EIGEN_TEST_BUILD_DOCUMENTATION "Test building the doxygen documentation" OFF "EIGEN_BUILD_DOC" OFF)
+if(EIGEN_TEST_BUILD_DOCUMENTATION)
+  add_dependencies(buildtests doc)
+endif()
+
+# Register all smoke tests
+include("EigenSmokeTestList")
+ei_add_smoke_tests("${ei_smoke_test_list}")

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/CustomComplex.h

@@ -0,0 +1,132 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2025 The Eigen Authors.
+//
+// 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_TEST_CUSTOM_COMPLEX_H
+#define EIGEN_TEST_CUSTOM_COMPLEX_H
+
+#include <ostream>
+#include <sstream>
+
+namespace custom_complex {
+
+template <typename Real>
+struct CustomComplex {
+  CustomComplex() : re{0}, im{0} {}
+  CustomComplex(const CustomComplex& other) = default;
+  CustomComplex(CustomComplex&& other) = default;
+  CustomComplex& operator=(const CustomComplex& other) = default;
+  CustomComplex& operator=(CustomComplex&& other) = default;
+  CustomComplex(Real x) : re{x}, im{0} {}
+  CustomComplex(Real x, Real y) : re{x}, im{y} {}
+
+  CustomComplex operator+(const CustomComplex& other) const { return CustomComplex(re + other.re, im + other.im); }
+
+  CustomComplex operator-() const { return CustomComplex(-re, -im); }
+
+  CustomComplex operator-(const CustomComplex& other) const { return CustomComplex(re - other.re, im - other.im); }
+
+  CustomComplex operator*(const CustomComplex& other) const {
+    return CustomComplex(re * other.re - im * other.im, re * other.im + im * other.re);
+  }
+
+  CustomComplex operator/(const CustomComplex& other) const {
+    // Smith's complex division (https://arxiv.org/pdf/1210.4539.pdf),
+    // guards against over/under-flow.
+    const bool scale_imag = numext::abs(other.im) <= numext::abs(other.re);
+    const Real rscale = scale_imag ? Real(1) : other.re / other.im;
+    const Real iscale = scale_imag ? other.im / other.re : Real(1);
+    const Real denominator = other.re * rscale + other.im * iscale;
+    return CustomComplex((re * rscale + im * iscale) / denominator, (im * rscale - re * iscale) / denominator);
+  }
+
+  CustomComplex& operator+=(const CustomComplex& other) {
+    *this = *this + other;
+    return *this;
+  }
+  CustomComplex& operator-=(const CustomComplex& other) {
+    *this = *this - other;
+    return *this;
+  }
+  CustomComplex& operator*=(const CustomComplex& other) {
+    *this = *this * other;
+    return *this;
+  }
+  CustomComplex& operator/=(const CustomComplex& other) {
+    *this = *this / other;
+    return *this;
+  }
+
+  bool operator==(const CustomComplex& other) const {
+    return numext::equal_strict(re, other.re) && numext::equal_strict(im, other.im);
+  }
+  bool operator!=(const CustomComplex& other) const { return !(*this == other); }
+
+  friend CustomComplex operator+(const Real& a, const CustomComplex& b) { return CustomComplex(a + b.re, b.im); }
+
+  friend CustomComplex operator-(const Real& a, const CustomComplex& b) { return CustomComplex(a - b.re, -b.im); }
+
+  friend CustomComplex operator*(const Real& a, const CustomComplex& b) { return CustomComplex(a * b.re, a * b.im); }
+
+  friend CustomComplex operator*(const CustomComplex& a, const Real& b) { return CustomComplex(a.re * b, a.im * b); }
+
+  friend CustomComplex operator/(const CustomComplex& a, const Real& b) { return CustomComplex(a.re / b, a.im / b); }
+
+  friend std::ostream& operator<<(std::ostream& stream, const CustomComplex& x) {
+    std::stringstream ss;
+    ss << "(" << x.re << ", " << x.im << ")";
+    stream << ss.str();
+    return stream;
+  }
+
+  Real re;
+  Real im;
+};
+
+template <typename Real>
+Real real(const CustomComplex<Real>& x) {
+  return x.re;
+}
+template <typename Real>
+Real imag(const CustomComplex<Real>& x) {
+  return x.im;
+}
+template <typename Real>
+CustomComplex<Real> conj(const CustomComplex<Real>& x) {
+  return CustomComplex<Real>(x.re, -x.im);
+}
+template <typename Real>
+CustomComplex<Real> sqrt(const CustomComplex<Real>& x) {
+  return Eigen::internal::complex_sqrt(x);
+}
+template <typename Real>
+Real abs(const CustomComplex<Real>& x) {
+  return Eigen::numext::sqrt(x.re * x.re + x.im * x.im);
+}
+
+}  // namespace custom_complex
+
+template <typename Real>
+using CustomComplex = custom_complex::CustomComplex<Real>;
+
+namespace Eigen {
+template <typename Real>
+struct NumTraits<CustomComplex<Real>> : NumTraits<Real> {
+  enum { IsComplex = 1 };
+};
+
+namespace numext {
+template <typename Real>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool(isfinite)(const CustomComplex<Real>& x) {
+  return (numext::isfinite)(x.re) && (numext::isfinite)(x.im);
+}
+
+}  // namespace numext
+}  // namespace Eigen
+
+#endif  // EIGEN_TEST_CUSTOM_COMPLEX_H

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/MovableScalar.h

@@ -0,0 +1,54 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2020 Sebastien Boisvert <seb@boisvert.info>
+//
+// 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_MISC_MOVABLE_SCALAR_H
+#define EIGEN_MISC_MOVABLE_SCALAR_H
+
+namespace Eigen {
+template <typename Scalar>
+struct MovableScalar {
+  MovableScalar() : m_data(new Scalar) {}
+  ~MovableScalar() { delete m_data; }
+  MovableScalar(const MovableScalar& other) : m_data(new Scalar) { set(other.get()); }
+  MovableScalar(MovableScalar&& other) noexcept : m_data(other.m_data) { other.m_data = nullptr; }
+  MovableScalar& operator=(const MovableScalar& other) {
+    set(other.get());
+    return *this;
+  }
+  MovableScalar& operator=(MovableScalar&& other) noexcept {
+    m_data = other.m_data;
+    other.m_data = nullptr;
+    return *this;
+  }
+  MovableScalar(const Scalar& scalar) : m_data(new Scalar) { set(scalar); }
+
+  operator Scalar() const { return get(); }
+
+ private:
+  void set(const Scalar& value) {
+    eigen_assert(m_data != nullptr);
+    // suppress compiler warnings
+    if (m_data != nullptr) *m_data = value;
+  }
+  Scalar get() const {
+    eigen_assert(m_data != nullptr);
+    // suppress compiler warnings
+    return m_data == nullptr ? Scalar() : *m_data;
+  }
+  Scalar* m_data = nullptr;
+};
+
+template <typename Scalar>
+struct NumTraits<MovableScalar<Scalar>> : NumTraits<Scalar> {
+  enum { RequireInitialization = 1 };
+};
+
+}  // namespace Eigen
+
+#endif

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/OffByOneScalar.h

@@ -0,0 +1,20 @@
+
+// A Scalar with internal representation T+1 so that zero is internally
+// represented by T(1). This is used to test memory fill.
+//
+#pragma once
+template <typename T>
+class OffByOneScalar {
+ public:
+  OffByOneScalar() : val_(1) {}
+  OffByOneScalar(const OffByOneScalar& other) = default;
+  OffByOneScalar& operator=(const OffByOneScalar& other) = default;
+
+  OffByOneScalar(T val) : val_(val + 1) {}
+  OffByOneScalar& operator=(T val) { val_ = val + 1; }
+
+  operator T() const { return val_ - 1; }
+
+ private:
+  T val_;
+};

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/SafeScalar.h

@@ -0,0 +1,33 @@
+
+// A Scalar that asserts for uninitialized access.
+template <typename T>
+class SafeScalar {
+ public:
+  SafeScalar() : initialized_(false) {}
+
+  SafeScalar(const T& val) : val_(val), initialized_(true) {}
+
+  template <typename Source>
+  explicit SafeScalar(const Source& val) : SafeScalar(T(val)) {}
+
+  operator T() const {
+    VERIFY(initialized_ && "Uninitialized access.");
+    return val_;
+  }
+
+  template <typename Target>
+  explicit operator Target() const {
+    return Target(this->operator T());
+  }
+
+ private:
+  T val_;
+  bool initialized_;
+};
+
+namespace Eigen {
+template <typename T>
+struct NumTraits<SafeScalar<T>> : GenericNumTraits<T> {
+  enum { RequireInitialization = 1 };
+};
+}  // namespace Eigen

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/accelerate_support.cpp

@@ -0,0 +1,166 @@
+#define EIGEN_NO_DEBUG_SMALL_PRODUCT_BLOCKS
+#include "sparse_solver.h"
+
+#if defined(DEBUG)
+#undef DEBUG
+#endif
+
+#include <Eigen/AccelerateSupport>
+
+template <typename MatrixType, typename DenseMat>
+int generate_sparse_rectangular_problem(MatrixType& A, DenseMat& dA, int maxRows = 300, int maxCols = 300) {
+  typedef typename MatrixType::Scalar Scalar;
+  int rows = internal::random<int>(1, maxRows);
+  int cols = internal::random<int>(1, maxCols);
+  double density = (std::max)(8.0 / (rows * cols), 0.01);
+
+  A.resize(rows, cols);
+  dA.resize(rows, cols);
+  initSparse<Scalar>(density, dA, A, ForceNonZeroDiag);
+  A.makeCompressed();
+  return rows;
+}
+
+template <typename MatrixType, typename DenseMat>
+int generate_sparse_square_symmetric_problem(MatrixType& A, DenseMat& dA, int maxSize = 300) {
+  typedef typename MatrixType::Scalar Scalar;
+  int rows = internal::random<int>(1, maxSize);
+  int cols = rows;
+  double density = (std::max)(8.0 / (rows * cols), 0.01);
+
+  A.resize(rows, cols);
+  dA.resize(rows, cols);
+  initSparse<Scalar>(density, dA, A, ForceNonZeroDiag);
+  dA = dA * dA.transpose();
+  A = A * A.transpose();
+  A.makeCompressed();
+  return rows;
+}
+
+template <typename Scalar, typename Solver>
+void test_accelerate_ldlt() {
+  typedef SparseMatrix<Scalar> MatrixType;
+  typedef Matrix<Scalar, Dynamic, 1> DenseVector;
+
+  MatrixType A;
+  Matrix<Scalar, Dynamic, Dynamic> dA;
+
+  generate_sparse_square_symmetric_problem(A, dA);
+
+  DenseVector b = DenseVector::Random(A.rows());
+
+  Solver solver;
+  solver.compute(A);
+
+  if (solver.info() != Success) {
+    std::cerr << "sparse LDLT factorization failed\n";
+    exit(0);
+    return;
+  }
+
+  DenseVector x = solver.solve(b);
+
+  if (solver.info() != Success) {
+    std::cerr << "sparse LDLT factorization failed\n";
+    exit(0);
+    return;
+  }
+
+  // Compare with a dense solver
+  DenseVector refX = dA.ldlt().solve(b);
+  VERIFY((A * x).isApprox(A * refX, test_precision<Scalar>()));
+}
+
+template <typename Scalar, typename Solver>
+void test_accelerate_llt() {
+  typedef SparseMatrix<Scalar> MatrixType;
+  typedef Matrix<Scalar, Dynamic, 1> DenseVector;
+
+  MatrixType A;
+  Matrix<Scalar, Dynamic, Dynamic> dA;
+
+  generate_sparse_square_symmetric_problem(A, dA);
+
+  DenseVector b = DenseVector::Random(A.rows());
+
+  Solver solver;
+  solver.compute(A);
+
+  if (solver.info() != Success) {
+    std::cerr << "sparse LLT factorization failed\n";
+    exit(0);
+    return;
+  }
+
+  DenseVector x = solver.solve(b);
+
+  if (solver.info() != Success) {
+    std::cerr << "sparse LLT factorization failed\n";
+    exit(0);
+    return;
+  }
+
+  // Compare with a dense solver
+  DenseVector refX = dA.llt().solve(b);
+  VERIFY((A * x).isApprox(A * refX, test_precision<Scalar>()));
+}
+
+template <typename Scalar, typename Solver>
+void test_accelerate_qr() {
+  typedef SparseMatrix<Scalar> MatrixType;
+  typedef Matrix<Scalar, Dynamic, 1> DenseVector;
+
+  MatrixType A;
+  Matrix<Scalar, Dynamic, Dynamic> dA;
+
+  generate_sparse_rectangular_problem(A, dA);
+
+  DenseVector b = DenseVector::Random(A.rows());
+
+  Solver solver;
+  solver.compute(A);
+
+  if (solver.info() != Success) {
+    std::cerr << "sparse QR factorization failed\n";
+    exit(0);
+    return;
+  }
+
+  DenseVector x = solver.solve(b);
+
+  if (solver.info() != Success) {
+    std::cerr << "sparse QR factorization failed\n";
+    exit(0);
+    return;
+  }
+
+  // Compare with a dense solver
+  DenseVector refX = dA.colPivHouseholderQr().solve(b);
+  VERIFY((A * x).isApprox(A * refX, test_precision<Scalar>()));
+}
+
+template <typename Scalar>
+void run_tests() {
+  typedef SparseMatrix<Scalar> MatrixType;
+
+  test_accelerate_ldlt<Scalar, AccelerateLDLT<MatrixType, Lower> >();
+  test_accelerate_ldlt<Scalar, AccelerateLDLTUnpivoted<MatrixType, Lower> >();
+  test_accelerate_ldlt<Scalar, AccelerateLDLTSBK<MatrixType, Lower> >();
+  test_accelerate_ldlt<Scalar, AccelerateLDLTTPP<MatrixType, Lower> >();
+
+  test_accelerate_ldlt<Scalar, AccelerateLDLT<MatrixType, Upper> >();
+  test_accelerate_ldlt<Scalar, AccelerateLDLTUnpivoted<MatrixType, Upper> >();
+  test_accelerate_ldlt<Scalar, AccelerateLDLTSBK<MatrixType, Upper> >();
+  test_accelerate_ldlt<Scalar, AccelerateLDLTTPP<MatrixType, Upper> >();
+
+  test_accelerate_llt<Scalar, AccelerateLLT<MatrixType, Lower> >();
+
+  test_accelerate_llt<Scalar, AccelerateLLT<MatrixType, Upper> >();
+
+  test_accelerate_qr<Scalar, AccelerateQR<MatrixType> >();
+}
+
+EIGEN_DECLARE_TEST(accelerate_support) {
+  CALL_SUBTEST_1(run_tests<float>());
+  CALL_SUBTEST_2(run_tests<double>());
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/adjoint.cpp

@@ -0,0 +1,236 @@
+// 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"
+
+template <bool IsInteger>
+struct adjoint_specific;
+
+template <>
+struct adjoint_specific<true> {
+  template <typename Vec, typename Mat, typename Scalar>
+  static void run(const Vec& v1, const Vec& v2, Vec& v3, const Mat& square, Scalar s1, Scalar s2) {
+    VERIFY(test_isApproxWithRef((s1 * v1 + s2 * v2).dot(v3),
+                                numext::conj(s1) * v1.dot(v3) + numext::conj(s2) * v2.dot(v3), 0));
+    VERIFY(test_isApproxWithRef(v3.dot(s1 * v1 + s2 * v2), s1 * v3.dot(v1) + s2 * v3.dot(v2), 0));
+
+    // check compatibility of dot and adjoint
+    VERIFY(test_isApproxWithRef(v1.dot(square * v2), (square.adjoint() * v1).dot(v2), 0));
+  }
+};
+
+template <>
+struct adjoint_specific<false> {
+  template <typename Vec, typename Mat, typename Scalar>
+  static void run(const Vec& v1, const Vec& v2, Vec& v3, const Mat& square, Scalar s1, Scalar s2) {
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    using std::abs;
+
+    RealScalar ref = NumTraits<Scalar>::IsInteger ? RealScalar(0) : (std::max)((s1 * v1 + s2 * v2).norm(), v3.norm());
+    VERIFY(test_isApproxWithRef((s1 * v1 + s2 * v2).dot(v3),
+                                numext::conj(s1) * v1.dot(v3) + numext::conj(s2) * v2.dot(v3), ref));
+    VERIFY(test_isApproxWithRef(v3.dot(s1 * v1 + s2 * v2), s1 * v3.dot(v1) + s2 * v3.dot(v2), ref));
+
+    VERIFY_IS_APPROX(v1.squaredNorm(), v1.norm() * v1.norm());
+    // check normalized() and normalize()
+    VERIFY_IS_APPROX(v1, v1.norm() * v1.normalized());
+    v3 = v1;
+    v3.normalize();
+    VERIFY_IS_APPROX(v1, v1.norm() * v3);
+    VERIFY_IS_APPROX(v3, v1.normalized());
+    VERIFY_IS_APPROX(v3.norm(), RealScalar(1));
+
+    // check null inputs
+    VERIFY_IS_APPROX((v1 * 0).normalized(), (v1 * 0));
+#if (!EIGEN_ARCH_i386) || defined(EIGEN_VECTORIZE)
+    RealScalar very_small = (std::numeric_limits<RealScalar>::min)();
+    VERIFY(numext::is_exactly_zero((v1 * very_small).norm()));
+    VERIFY_IS_APPROX((v1 * very_small).normalized(), (v1 * very_small));
+    v3 = v1 * very_small;
+    v3.normalize();
+    VERIFY_IS_APPROX(v3, (v1 * very_small));
+#endif
+
+    // check compatibility of dot and adjoint
+    ref = NumTraits<Scalar>::IsInteger ? 0
+                                       : (std::max)((std::max)(v1.norm(), v2.norm()),
+                                                    (std::max)((square * v2).norm(), (square.adjoint() * v1).norm()));
+    VERIFY(internal::isMuchSmallerThan(abs(v1.dot(square * v2) - (square.adjoint() * v1).dot(v2)), ref,
+                                       test_precision<Scalar>()));
+
+    // check that Random().normalized() works: tricky as the random xpr must be evaluated by
+    // normalized() in order to produce a consistent result.
+    VERIFY_IS_APPROX(Vec::Random(v1.size()).normalized().norm(), RealScalar(1));
+  }
+};
+
+template <typename MatrixType, typename Scalar = typename MatrixType::Scalar>
+MatrixType RandomMatrix(Index rows, Index cols, Scalar min, Scalar max) {
+  MatrixType M = MatrixType(rows, cols);
+  for (Index i = 0; i < rows; ++i) {
+    for (Index j = 0; j < cols; ++j) {
+      M(i, j) = Eigen::internal::random<Scalar>(min, max);
+    }
+  }
+  return M;
+}
+
+template <typename MatrixType>
+void adjoint(const MatrixType& m) {
+  /* this test covers the following files:
+     Transpose.h Conjugate.h Dot.h
+  */
+  using std::abs;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> SquareMatrixType;
+  const Index PacketSize = internal::packet_traits<Scalar>::size;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  // Avoid integer overflow by limiting input values.
+  RealScalar rmin = static_cast<RealScalar>(NumTraits<Scalar>::IsInteger ? NumTraits<Scalar>::IsSigned ? -100 : 0 : -1);
+  RealScalar rmax = static_cast<RealScalar>(NumTraits<Scalar>::IsInteger ? 100 : 1);
+
+  MatrixType m1 = RandomMatrix<MatrixType>(rows, cols, rmin, rmax),
+             m2 = RandomMatrix<MatrixType>(rows, cols, rmin, rmax), m3(rows, cols),
+             square = RandomMatrix<SquareMatrixType>(rows, rows, rmin, rmax);
+  VectorType v1 = RandomMatrix<VectorType>(rows, 1, rmin, rmax), v2 = RandomMatrix<VectorType>(rows, 1, rmin, rmax),
+             v3 = RandomMatrix<VectorType>(rows, 1, rmin, rmax), vzero = VectorType::Zero(rows);
+
+  Scalar s1 = internal::random<Scalar>(rmin, rmax), s2 = internal::random<Scalar>(rmin, rmax);
+
+  // check basic compatibility of adjoint, transpose, conjugate
+  VERIFY_IS_APPROX(m1.transpose().conjugate().adjoint(), m1);
+  VERIFY_IS_APPROX(m1.adjoint().conjugate().transpose(), m1);
+
+  // check multiplicative behavior
+  VERIFY_IS_APPROX((m1.adjoint() * m2).adjoint(), m2.adjoint() * m1);
+  VERIFY_IS_APPROX((s1 * m1).adjoint(), numext::conj(s1) * m1.adjoint());
+
+  // check basic properties of dot, squaredNorm
+  VERIFY_IS_APPROX(numext::conj(v1.dot(v2)), v2.dot(v1));
+  VERIFY_IS_APPROX(numext::real(v1.dot(v1)), v1.squaredNorm());
+
+  adjoint_specific<NumTraits<Scalar>::IsInteger>::run(v1, v2, v3, square, s1, s2);
+
+  VERIFY_IS_MUCH_SMALLER_THAN(abs(vzero.dot(v1)), static_cast<RealScalar>(1));
+
+  // like in testBasicStuff, test operator() to check const-qualification
+  Index r = internal::random<Index>(0, rows - 1), c = internal::random<Index>(0, cols - 1);
+  VERIFY_IS_APPROX(m1.conjugate()(r, c), numext::conj(m1(r, c)));
+  VERIFY_IS_APPROX(m1.adjoint()(c, r), numext::conj(m1(r, c)));
+
+  // check inplace transpose
+  m3 = m1;
+  m3.transposeInPlace();
+  VERIFY_IS_APPROX(m3, m1.transpose());
+  m3.transposeInPlace();
+  VERIFY_IS_APPROX(m3, m1);
+
+  if (PacketSize < m3.rows() && PacketSize < m3.cols()) {
+    m3 = m1;
+    Index i = internal::random<Index>(0, m3.rows() - PacketSize);
+    Index j = internal::random<Index>(0, m3.cols() - PacketSize);
+    m3.template block<PacketSize, PacketSize>(i, j).transposeInPlace();
+    VERIFY_IS_APPROX((m3.template block<PacketSize, PacketSize>(i, j)),
+                     (m1.template block<PacketSize, PacketSize>(i, j).transpose()));
+    m3.template block<PacketSize, PacketSize>(i, j).transposeInPlace();
+    VERIFY_IS_APPROX(m3, m1);
+  }
+
+  // check inplace adjoint
+  m3 = m1;
+  m3.adjointInPlace();
+  VERIFY_IS_APPROX(m3, m1.adjoint());
+  m3.transposeInPlace();
+  VERIFY_IS_APPROX(m3, m1.conjugate());
+
+  // check mixed dot product
+  typedef Matrix<RealScalar, MatrixType::RowsAtCompileTime, 1> RealVectorType;
+  RealVectorType rv1 = RandomMatrix<RealVectorType>(rows, 1, rmin, rmax);
+
+  VERIFY_IS_APPROX(v1.dot(rv1.template cast<Scalar>()), v1.dot(rv1));
+  VERIFY_IS_APPROX(rv1.template cast<Scalar>().dot(v1), rv1.dot(v1));
+
+  VERIFY(is_same_type(m1, m1.template conjugateIf<false>()));
+  VERIFY(is_same_type(m1.conjugate(), m1.template conjugateIf<true>()));
+}
+
+template <int>
+void adjoint_extra() {
+  MatrixXcf a(10, 10), b(10, 10);
+  VERIFY_RAISES_ASSERT(a = a.transpose());
+  VERIFY_RAISES_ASSERT(a = a.transpose() + b);
+  VERIFY_RAISES_ASSERT(a = b + a.transpose());
+  VERIFY_RAISES_ASSERT(a = a.conjugate().transpose());
+  VERIFY_RAISES_ASSERT(a = a.adjoint());
+  VERIFY_RAISES_ASSERT(a = a.adjoint() + b);
+  VERIFY_RAISES_ASSERT(a = b + a.adjoint());
+
+  // no assertion should be triggered for these cases:
+  a.transpose() = a.transpose();
+  a.transpose() += a.transpose();
+  a.transpose() += a.transpose() + b;
+  a.transpose() = a.adjoint();
+  a.transpose() += a.adjoint();
+  a.transpose() += a.adjoint() + b;
+
+  // regression tests for check_for_aliasing
+  MatrixXd c(10, 10);
+  c = 1.0 * MatrixXd::Ones(10, 10) + c;
+  c = MatrixXd::Ones(10, 10) * 1.0 + c;
+  c = c + MatrixXd::Ones(10, 10).cwiseProduct(MatrixXd::Zero(10, 10));
+  c = MatrixXd::Ones(10, 10) * MatrixXd::Zero(10, 10);
+
+  // regression for bug 1646
+  for (int j = 0; j < 10; ++j) {
+    c.col(j).head(j) = c.row(j).head(j);
+  }
+
+  for (int j = 0; j < 10; ++j) {
+    c.col(j) = c.row(j);
+  }
+
+  a.conservativeResize(1, 1);
+  a = a.transpose();
+
+  a.conservativeResize(0, 0);
+  a = a.transpose();
+}
+
+EIGEN_DECLARE_TEST(adjoint) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(adjoint(Matrix<float, 1, 1>()));
+    CALL_SUBTEST_2(adjoint(Matrix3d()));
+    CALL_SUBTEST_3(adjoint(Matrix4f()));
+
+    CALL_SUBTEST_4(adjoint(MatrixXcf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2),
+                                     internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2))));
+    CALL_SUBTEST_5(adjoint(
+        MatrixXi(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_6(adjoint(
+        MatrixXf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+
+    // Complement for 128 bits vectorization:
+    CALL_SUBTEST_8(adjoint(Matrix2d()));
+    CALL_SUBTEST_9(adjoint(Matrix<int, 4, 4>()));
+
+    // 256 bits vectorization:
+    CALL_SUBTEST_10(adjoint(Matrix<float, 8, 8>()));
+    CALL_SUBTEST_11(adjoint(Matrix<double, 4, 4>()));
+    CALL_SUBTEST_12(adjoint(Matrix<int, 8, 8>()));
+  }
+  // test a large static matrix only once
+  CALL_SUBTEST_7(adjoint(Matrix<float, 100, 100>()));
+
+  CALL_SUBTEST_13(adjoint_extra<0>());
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/array_cwise.cpp

@@ -0,0 +1,1432 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include <vector>
+#include "main.h"
+#include "random_without_cast_overflow.h"
+
+// suppress annoying unsigned integer warnings
+template <typename Scalar, bool IsSigned = NumTraits<Scalar>::IsSigned>
+struct negative_or_zero_impl {
+  static Scalar run(const Scalar& a) { return -a; }
+};
+template <typename Scalar>
+struct negative_or_zero_impl<Scalar, false> {
+  static Scalar run(const Scalar&) { return 0; }
+};
+template <typename Scalar>
+Scalar negative_or_zero(const Scalar& a) {
+  return negative_or_zero_impl<Scalar>::run(a);
+}
+
+template <typename Scalar, std::enable_if_t<NumTraits<Scalar>::IsInteger, int> = 0>
+std::vector<Scalar> special_values() {
+  const Scalar zero = Scalar(0);
+  const Scalar one = Scalar(1);
+  const Scalar two = Scalar(2);
+  const Scalar three = Scalar(3);
+  const Scalar min = (std::numeric_limits<Scalar>::min)();
+  const Scalar max = (std::numeric_limits<Scalar>::max)();
+  return {zero, min, one, two, three, max};
+}
+
+template <typename Scalar, std::enable_if_t<!NumTraits<Scalar>::IsInteger, int> = 0>
+std::vector<Scalar> special_values() {
+  const Scalar zero = Scalar(0);
+  const Scalar eps = Eigen::NumTraits<Scalar>::epsilon();
+  const Scalar one_half = Scalar(0.5);
+  const Scalar one = Scalar(1);
+  const Scalar two = Scalar(2);
+  const Scalar three = Scalar(3);
+  const Scalar sqrt_half = Scalar(std::sqrt(0.5));
+  const Scalar sqrt2 = Scalar(std::sqrt(2));
+  const Scalar inf = Eigen::NumTraits<Scalar>::infinity();
+  const Scalar nan = Eigen::NumTraits<Scalar>::quiet_NaN();
+  // For 32-bit arm, working within or near the subnormal range can lead to incorrect results
+  // due to FTZ.
+  const Scalar denorm_min = EIGEN_ARCH_ARM ? zero : std::numeric_limits<Scalar>::denorm_min();
+  const Scalar min =
+      EIGEN_ARCH_ARM ? Scalar(1.1) * (std::numeric_limits<Scalar>::min)() : (std::numeric_limits<Scalar>::min)();
+  const Scalar max = (std::numeric_limits<Scalar>::max)();
+  const Scalar max_exp = (static_cast<Scalar>(int(Eigen::NumTraits<Scalar>::max_exponent())) * Scalar(EIGEN_LN2)) / eps;
+  std::vector<Scalar> values = {zero,  denorm_min, min,   eps,     sqrt_half, one_half, one,
+                                sqrt2, two,        three, max_exp, max,       inf,      nan};
+  std::vector<Scalar> signed_values;
+  for (Scalar value : values) {
+    signed_values.push_back(value);
+    signed_values.push_back(-value);
+  }
+  return signed_values;
+}
+
+template <typename Scalar>
+void special_value_pairs(Array<Scalar, Dynamic, Dynamic>& x, Array<Scalar, Dynamic, Dynamic>& y) {
+  std::vector<Scalar> vals = special_values<Scalar>();
+  std::size_t num_cases = vals.size() * vals.size();
+  // ensure both vectorized and non-vectorized paths taken
+  const Index num_repeats = 2 * (Index)internal::packet_traits<Scalar>::size + 1;
+  x.resize(num_repeats, num_cases);
+  y.resize(num_repeats, num_cases);
+  int count = 0;
+  for (const Scalar x_case : vals) {
+    for (const Scalar y_case : vals) {
+      for (Index repeat = 0; repeat < num_repeats; ++repeat) {
+        x(repeat, count) = x_case;
+        y(repeat, count) = y_case;
+      }
+      ++count;
+    }
+  }
+}
+
+template <typename Scalar, typename Fn, typename RefFn>
+void binary_op_test(std::string name, Fn fun, RefFn ref) {
+  const Scalar tol = test_precision<Scalar>();
+  Array<Scalar, Dynamic, Dynamic> lhs;
+  Array<Scalar, Dynamic, Dynamic> rhs;
+  special_value_pairs(lhs, rhs);
+
+  Array<Scalar, Dynamic, Dynamic> actual = fun(lhs, rhs);
+  bool all_pass = true;
+  for (Index i = 0; i < lhs.rows(); ++i) {
+    for (Index j = 0; j < lhs.cols(); ++j) {
+      Scalar e = static_cast<Scalar>(ref(lhs(i, j), rhs(i, j)));
+      Scalar a = actual(i, j);
+#if EIGEN_ARCH_ARM
+      // Work around NEON flush-to-zero mode.
+      // If ref returns a subnormal value and Eigen returns 0, then skip the test.
+      if (a == Scalar(0) && (e > -(std::numeric_limits<Scalar>::min)() && e < (std::numeric_limits<Scalar>::min)()) &&
+          (e <= -std::numeric_limits<Scalar>::denorm_min() || e >= std::numeric_limits<Scalar>::denorm_min())) {
+        continue;
+      }
+#endif
+      bool success = (a == e) || ((numext::isfinite)(e) && internal::isApprox(a, e, tol)) ||
+                     ((numext::isnan)(a) && (numext::isnan)(e));
+      if ((a == a) && (e == e)) success &= (bool)numext::signbit(e) == (bool)numext::signbit(a);
+      all_pass &= success;
+      if (!success) {
+        std::cout << name << "(" << lhs(i, j) << "," << rhs(i, j) << ") = " << a << " !=  " << e << std::endl;
+      }
+    }
+  }
+  VERIFY(all_pass);
+}
+
+#define BINARY_FUNCTOR_TEST_ARGS(fun)                                        \
+  #fun, [](const auto& x_, const auto& y_) { return (Eigen::fun)(x_, y_); }, \
+      [](const auto& x_, const auto& y_) { return (std::fun)(x_, y_); }
+
+template <typename Scalar>
+void binary_ops_test() {
+  binary_op_test<Scalar>(BINARY_FUNCTOR_TEST_ARGS(pow));
+#ifndef EIGEN_COMP_MSVC
+  binary_op_test<Scalar>(BINARY_FUNCTOR_TEST_ARGS(atan2));
+#else
+  binary_op_test<Scalar>(
+      "atan2", [](const auto& x, const auto& y) { return Eigen::atan2(x, y); },
+      [](Scalar x, Scalar y) {
+        auto t = Scalar(std::atan2(x, y));
+        // Work around MSVC return value on underflow.
+        // |atan(y/x)| is bounded above by |y/x|, so on underflow return y/x according to POSIX spec.
+        // MSVC otherwise returns denorm_min.
+        if (EIGEN_PREDICT_FALSE(std::abs(t) == std::numeric_limits<decltype(t)>::denorm_min())) {
+          return x / y;
+        }
+        return t;
+      });
+#endif
+}
+
+template <typename Scalar, typename Fn, typename RefFn>
+void unary_op_test(std::string name, Fn fun, RefFn ref) {
+  const Scalar tol = test_precision<Scalar>();
+  auto values = special_values<Scalar>();
+  Map<Array<Scalar, Dynamic, 1>> valuesMap(values.data(), values.size());
+
+  Array<Scalar, Dynamic, Dynamic> actual = fun(valuesMap);
+  bool all_pass = true;
+  for (Index i = 0; i < valuesMap.size(); ++i) {
+    Scalar e = static_cast<Scalar>(ref(valuesMap(i)));
+    Scalar a = actual(i);
+#if EIGEN_ARCH_ARM
+    // Work around NEON flush-to-zero mode.
+    // If ref returns a subnormal value and Eigen returns 0, then skip the test.
+    if (a == Scalar(0) && (e > -(std::numeric_limits<Scalar>::min)() && e < (std::numeric_limits<Scalar>::min)()) &&
+        (e <= -std::numeric_limits<Scalar>::denorm_min() || e >= std::numeric_limits<Scalar>::denorm_min())) {
+      continue;
+    }
+#endif
+    bool success = (a == e) || ((numext::isfinite)(e) && internal::isApprox(a, e, tol)) ||
+                   ((numext::isnan)(a) && (numext::isnan)(e));
+    if ((a == a) && (e == e)) success &= (bool)numext::signbit(e) == (bool)numext::signbit(a);
+    all_pass &= success;
+    if (!success) {
+      std::cout << name << "(" << valuesMap(i) << ") = " << a << " !=  " << e << std::endl;
+    }
+  }
+  VERIFY(all_pass);
+}
+
+#define UNARY_FUNCTOR_TEST_ARGS(fun) \
+  #fun, [](const auto& x_) { return (Eigen::fun)(x_); }, [](const auto& y_) { return (std::fun)(y_); }
+
+template <typename Scalar>
+void unary_ops_test() {
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(sqrt));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(cbrt));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(exp));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(exp2));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(log));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(sin));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(cos));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(tan));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(asin));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(acos));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(atan));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(sinh));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(cosh));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(tanh));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(asinh));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(acosh));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(atanh));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(rint));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(floor));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(ceil));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(round));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(trunc));
+  /* FIXME: Enable when the behavior of rsqrt on denormals for half and double is fixed.
+  unary_op_test<Scalar>("rsqrt",
+                        [](const auto& x) { return Eigen::rsqrt(x); },
+                        [](Scalar x) {
+                          if (x >= 0 && x < (std::numeric_limits<Scalar>::min)()) {
+                            // rsqrt return +inf for positive subnormals.
+                            return NumTraits<Scalar>::infinity();
+                          } else {
+                            return  Scalar(std::sqrt(Scalar(1)/x));
+                          }
+                        });
+  */
+}
+
+template <typename Base, typename Exponent, bool ExpIsInteger = NumTraits<Exponent>::IsInteger>
+struct ref_pow {
+  static Base run(Base base, Exponent exponent) {
+    EIGEN_USING_STD(pow);
+    return static_cast<Base>(pow(base, static_cast<Base>(exponent)));
+  }
+};
+
+template <typename Base, typename Exponent>
+struct ref_pow<Base, Exponent, true> {
+  static Base run(Base base, Exponent exponent) {
+    EIGEN_USING_STD(pow);
+    return static_cast<Base>(pow(base, exponent));
+  }
+};
+
+template <typename Exponent, bool ExpIsInteger = NumTraits<Exponent>::IsInteger>
+struct pow_helper {
+  static bool is_integer_impl(const Exponent& exp) { return (numext::isfinite)(exp) && exp == numext::floor(exp); }
+  static bool is_odd_impl(const Exponent& exp) {
+    Exponent exp_div_2 = exp / Exponent(2);
+    Exponent floor_exp_div_2 = numext::floor(exp_div_2);
+    return exp_div_2 != floor_exp_div_2;
+  }
+};
+template <typename Exponent>
+struct pow_helper<Exponent, true> {
+  static bool is_integer_impl(const Exponent&) { return true; }
+  static bool is_odd_impl(const Exponent& exp) { return exp % 2 != 0; }
+};
+template <typename Exponent>
+bool is_integer(const Exponent& exp) {
+  return pow_helper<Exponent>::is_integer_impl(exp);
+}
+template <typename Exponent>
+bool is_odd(const Exponent& exp) {
+  return pow_helper<Exponent>::is_odd_impl(exp);
+}
+
+template <typename Base, typename Exponent>
+void float_pow_test_impl() {
+  const Base tol = test_precision<Base>();
+  std::vector<Base> abs_base_vals = special_values<Base>();
+  std::vector<Exponent> abs_exponent_vals = special_values<Exponent>();
+  for (int i = 0; i < 100; i++) {
+    abs_base_vals.push_back(internal::random<Base>(Base(0), Base(10)));
+    abs_exponent_vals.push_back(internal::random<Exponent>(Exponent(0), Exponent(10)));
+  }
+  const Index num_repeats = internal::packet_traits<Base>::size + 1;
+  ArrayX<Base> bases(num_repeats), eigenPow(num_repeats);
+  bool all_pass = true;
+  for (Base abs_base : abs_base_vals)
+    for (Base base : {negative_or_zero(abs_base), abs_base}) {
+      bases.setConstant(base);
+      for (Exponent abs_exponent : abs_exponent_vals) {
+        for (Exponent exponent : {negative_or_zero(abs_exponent), abs_exponent}) {
+          eigenPow = bases.pow(exponent);
+          for (Index j = 0; j < num_repeats; j++) {
+            Base e = ref_pow<Base, Exponent>::run(bases(j), exponent);
+            if (is_integer(exponent)) {
+              // std::pow may return an incorrect result for a very large integral exponent
+              // if base is negative and the exponent is odd, then the result must be negative
+              // if std::pow returns otherwise, flip the sign
+              bool exp_is_odd = is_odd(exponent);
+              bool base_is_neg = !(numext::isnan)(base) && (bool)numext::signbit(base);
+              bool result_is_neg = exp_is_odd && base_is_neg;
+              bool ref_is_neg = !(numext::isnan)(e) && (bool)numext::signbit(e);
+              bool flip_sign = result_is_neg != ref_is_neg;
+              if (flip_sign) e = -e;
+            }
+
+            Base a = eigenPow(j);
+#ifdef EIGEN_COMP_MSVC
+            // Work around MSVC return value on underflow.
+            // if std::pow returns 0 and Eigen returns a denormalized value, then skip the test
+            int eigen_fpclass = std::fpclassify(a);
+            if (e == Base(0) && eigen_fpclass == FP_SUBNORMAL) continue;
+#endif
+
+#ifdef EIGEN_VECTORIZE_NEON
+            // Work around NEON flush-to-zero mode
+            // if std::pow returns denormalized value and Eigen returns 0, then skip the test
+            int ref_fpclass = std::fpclassify(e);
+            if (a == Base(0) && ref_fpclass == FP_SUBNORMAL) continue;
+#endif
+
+            bool both_nan = (numext::isnan)(a) && (numext::isnan)(e);
+            bool exact_or_approx = (a == e) || internal::isApprox(a, e, tol);
+            bool same_sign = (bool)numext::signbit(e) == (bool)numext::signbit(a);
+            bool success = both_nan || (exact_or_approx && same_sign);
+            all_pass &= success;
+            if (!success) {
+              std::cout << "Base type: " << type_name(base) << ", Exponent type: " << type_name(exponent) << std::endl;
+              std::cout << "pow(" << bases(j) << "," << exponent << ")   =   " << a << " !=  " << e << std::endl;
+            }
+          }
+        }
+      }
+    }
+  VERIFY(all_pass);
+}
+
+template <typename Scalar, typename ScalarExponent>
+Scalar calc_overflow_threshold(const ScalarExponent exponent) {
+  EIGEN_USING_STD(exp2);
+  EIGEN_USING_STD(log2);
+  EIGEN_STATIC_ASSERT((NumTraits<Scalar>::digits() < 2 * NumTraits<double>::digits()), BASE_TYPE_IS_TOO_BIG);
+
+  if (exponent < 2)
+    return NumTraits<Scalar>::highest();
+  else {
+    // base^e <= highest ==> base <= 2^(log2(highest)/e)
+    // For floating-point types, consider the bound for integer values that can be reproduced exactly = 2 ^ digits
+    double highest_bits = numext::mini(static_cast<double>(NumTraits<Scalar>::digits()),
+                                       static_cast<double>(log2(NumTraits<Scalar>::highest())));
+    return static_cast<Scalar>(numext::floor(exp2(highest_bits / static_cast<double>(exponent))));
+  }
+}
+
+template <typename Base, typename Exponent>
+void test_exponent(Exponent exponent) {
+  EIGEN_STATIC_ASSERT(NumTraits<Base>::IsInteger, THIS TEST IS ONLY INTENDED FOR BASE INTEGER TYPES)
+  const Base max_abs_bases = static_cast<Base>(10000);
+  // avoid integer overflow in Base type
+  Base threshold = calc_overflow_threshold<Base, Exponent>(numext::abs(exponent));
+  // avoid numbers that can't be verified with std::pow
+  double double_threshold = calc_overflow_threshold<double, Exponent>(numext::abs(exponent));
+  // use the lesser of these two thresholds
+  Base testing_threshold =
+      static_cast<double>(threshold) < double_threshold ? threshold : static_cast<Base>(double_threshold);
+  // test both vectorized and non-vectorized code paths
+  const Index array_size = 2 * internal::packet_traits<Base>::size + 1;
+
+  Base max_base = numext::mini(testing_threshold, max_abs_bases);
+  Base min_base = negative_or_zero(max_base);
+
+  ArrayX<Base> x(array_size), y(array_size);
+  bool all_pass = true;
+  for (Base base = min_base; base <= max_base; base++) {
+    if (exponent < 0 && base == 0) continue;
+    x.setConstant(base);
+    y = x.pow(exponent);
+    for (Base a : y) {
+      Base e = ref_pow<Base, Exponent>::run(base, exponent);
+      bool pass = (a == e);
+      all_pass &= pass;
+      if (!pass) {
+        std::cout << "pow(" << base << "," << exponent << ")   =   " << a << " !=  " << e << std::endl;
+      }
+    }
+  }
+  VERIFY(all_pass);
+}
+
+template <typename Base, typename Exponent>
+void int_pow_test_impl() {
+  Exponent max_exponent = static_cast<Exponent>(NumTraits<Base>::digits());
+  Exponent min_exponent = negative_or_zero(max_exponent);
+
+  for (Exponent exponent = min_exponent; exponent < max_exponent; ++exponent) {
+    test_exponent<Base, Exponent>(exponent);
+  }
+}
+
+void float_pow_test() {
+  float_pow_test_impl<float, float>();
+  float_pow_test_impl<double, double>();
+}
+
+void mixed_pow_test() {
+  // The following cases will test promoting a smaller exponent type
+  // to a wider base type.
+  float_pow_test_impl<double, int>();
+  float_pow_test_impl<double, float>();
+  float_pow_test_impl<float, half>();
+  float_pow_test_impl<double, half>();
+  float_pow_test_impl<float, bfloat16>();
+  float_pow_test_impl<double, bfloat16>();
+
+  // Although in the following cases the exponent cannot be represented exactly
+  // in the base type, we do not perform a conversion, but implement
+  // the operation using repeated squaring.
+  float_pow_test_impl<float, int>();
+  float_pow_test_impl<double, long long>();
+
+  // The following cases will test promoting a wider exponent type
+  // to a narrower base type. This should compile but would generate a
+  // deprecation warning:
+  // unary_pow_test<float, double>();
+}
+
+void int_pow_test() {
+  int_pow_test_impl<int, int>();
+  int_pow_test_impl<unsigned int, unsigned int>();
+  int_pow_test_impl<long long, long long>();
+  int_pow_test_impl<unsigned long long, unsigned long long>();
+
+  // Although in the following cases the exponent cannot be represented exactly
+  // in the base type, we do not perform a conversion, but implement the
+  // operation using repeated squaring.
+  int_pow_test_impl<long long, int>();
+  int_pow_test_impl<int, unsigned int>();
+  int_pow_test_impl<unsigned int, int>();
+  int_pow_test_impl<long long, unsigned long long>();
+  int_pow_test_impl<unsigned long long, long long>();
+  int_pow_test_impl<long long, int>();
+}
+
+namespace Eigen {
+namespace internal {
+template <typename Scalar>
+struct test_signbit_op {
+  Scalar constexpr operator()(const Scalar& a) const { return numext::signbit(a); }
+  template <typename Packet>
+  inline Packet packetOp(const Packet& a) const {
+    return psignbit(a);
+  }
+};
+template <typename Scalar>
+struct functor_traits<test_signbit_op<Scalar>> {
+  enum { Cost = 1, PacketAccess = true };  // todo: define HasSignbit flag
+};
+}  // namespace internal
+}  // namespace Eigen
+
+template <typename Scalar>
+void signbit_test() {
+  const size_t size = 100 * internal::packet_traits<Scalar>::size;
+  ArrayX<Scalar> x(size), y(size);
+  x.setRandom();
+  std::vector<Scalar> special_vals = special_values<Scalar>();
+  for (size_t i = 0; i < special_vals.size(); i++) {
+    x(2 * i + 0) = special_vals[i];
+    x(2 * i + 1) = negative_or_zero(special_vals[i]);
+  }
+  y = x.unaryExpr(internal::test_signbit_op<Scalar>());
+
+  bool all_pass = true;
+  for (size_t i = 0; i < size; i++) {
+    const Scalar ref_val = numext::signbit(x(i));
+    bool not_same = internal::predux_any(internal::bitwise_helper<Scalar>::bitwise_xor(ref_val, y(i)));
+    if (not_same) std::cout << "signbit(" << x(i) << ") != " << y(i) << "\n";
+    all_pass = all_pass && !not_same;
+  }
+
+  VERIFY(all_pass);
+}
+void signbit_tests() {
+  signbit_test<float>();
+  signbit_test<double>();
+  signbit_test<Eigen::half>();
+  signbit_test<Eigen::bfloat16>();
+  signbit_test<int8_t>();
+  signbit_test<int16_t>();
+  signbit_test<int32_t>();
+  signbit_test<int64_t>();
+}
+
+template <typename ArrayType>
+void array_generic(const ArrayType& m) {
+  typedef typename ArrayType::Scalar Scalar;
+  typedef typename ArrayType::RealScalar RealScalar;
+  typedef Array<Scalar, ArrayType::RowsAtCompileTime, 1> ColVectorType;
+  typedef Array<Scalar, 1, ArrayType::ColsAtCompileTime> RowVectorType;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  ArrayType m1 = ArrayType::Random(rows, cols);
+  if (NumTraits<RealScalar>::IsInteger && NumTraits<RealScalar>::IsSigned && !NumTraits<Scalar>::IsComplex) {
+    // Here we cap the size of the values in m1 such that pow(3)/cube()
+    // doesn't overflow and result in undefined behavior. Notice that because
+    // pow(int, int) promotes its inputs and output to double (according to
+    // the C++ standard), we have to make sure that the result fits in 53 bits
+    // for int64,
+    RealScalar max_val =
+        numext::mini(RealScalar(std::cbrt(NumTraits<RealScalar>::highest())), RealScalar(std::cbrt(1LL << 53))) / 2;
+    m1.array() = (m1.abs().array() <= max_val).select(m1, Scalar(max_val));
+  }
+  ArrayType m2 = ArrayType::Random(rows, cols), m3(rows, cols);
+  ArrayType m4 = m1;  // copy constructor
+  VERIFY_IS_APPROX(m1, m4);
+
+  ColVectorType cv1 = ColVectorType::Random(rows);
+  RowVectorType rv1 = RowVectorType::Random(cols);
+
+  Scalar s1 = internal::random<Scalar>(), s2 = internal::random<Scalar>();
+
+  // scalar addition
+  VERIFY_IS_APPROX(m1 + s1, s1 + m1);
+  VERIFY_IS_APPROX(m1 + s1, ArrayType::Constant(rows, cols, s1) + m1);
+  VERIFY_IS_APPROX(s1 - m1, (-m1) + s1);
+  VERIFY_IS_APPROX(m1 - s1, m1 - ArrayType::Constant(rows, cols, s1));
+  VERIFY_IS_APPROX(s1 - m1, ArrayType::Constant(rows, cols, s1) - m1);
+  VERIFY_IS_APPROX((m1 * Scalar(2)) - s2, (m1 + m1) - ArrayType::Constant(rows, cols, s2));
+  m3 = m1;
+  m3 += s2;
+  VERIFY_IS_APPROX(m3, m1 + s2);
+  m3 = m1;
+  m3 -= s1;
+  VERIFY_IS_APPROX(m3, m1 - s1);
+
+  // scalar operators via Maps
+  m3 = m1;
+  m4 = m1;
+  ArrayType::Map(m4.data(), m4.rows(), m4.cols()) -= ArrayType::Map(m2.data(), m2.rows(), m2.cols());
+  VERIFY_IS_APPROX(m4, m3 - m2);
+
+  m3 = m1;
+  m4 = m1;
+  ArrayType::Map(m4.data(), m4.rows(), m4.cols()) += ArrayType::Map(m2.data(), m2.rows(), m2.cols());
+  VERIFY_IS_APPROX(m4, m3 + m2);
+
+  m3 = m1;
+  m4 = m1;
+  ArrayType::Map(m4.data(), m4.rows(), m4.cols()) *= ArrayType::Map(m2.data(), m2.rows(), m2.cols());
+  VERIFY_IS_APPROX(m4, m3 * m2);
+
+  m3 = m1;
+  m4 = m1;
+  m2 = ArrayType::Random(rows, cols);
+  m2 = (m2 == 0).select(1, m2);
+  ArrayType::Map(m4.data(), m4.rows(), m4.cols()) /= ArrayType::Map(m2.data(), m2.rows(), m2.cols());
+  VERIFY_IS_APPROX(m4, m3 / m2);
+
+  // reductions
+  VERIFY_IS_APPROX(m1.abs().colwise().sum().sum(), m1.abs().sum());
+  VERIFY_IS_APPROX(m1.abs().rowwise().sum().sum(), m1.abs().sum());
+  using numext::abs;
+  VERIFY_IS_MUCH_SMALLER_THAN(abs(m1.colwise().sum().sum() - m1.sum()), m1.abs().sum());
+  VERIFY_IS_MUCH_SMALLER_THAN(abs(m1.rowwise().sum().sum() - m1.sum()), m1.abs().sum());
+  if (!internal::isMuchSmallerThan(abs(m1.sum() - (m1 + m2).sum()), m1.abs().sum(), test_precision<Scalar>()))
+    VERIFY_IS_NOT_APPROX(((m1 + m2).rowwise().sum()).sum(), m1.sum());
+  VERIFY_IS_APPROX(m1.colwise().sum(), m1.colwise().redux(internal::scalar_sum_op<Scalar, Scalar>()));
+
+  // vector-wise ops
+  m3 = m1;
+  VERIFY_IS_APPROX(m3.colwise() += cv1, m1.colwise() + cv1);
+  m3 = m1;
+  VERIFY_IS_APPROX(m3.colwise() -= cv1, m1.colwise() - cv1);
+  m3 = m1;
+  VERIFY_IS_APPROX(m3.rowwise() += rv1, m1.rowwise() + rv1);
+  m3 = m1;
+  VERIFY_IS_APPROX(m3.rowwise() -= rv1, m1.rowwise() - rv1);
+
+  // Conversion from scalar
+  VERIFY_IS_APPROX((m3 = s1), ArrayType::Constant(rows, cols, s1));
+  VERIFY_IS_APPROX((m3 = 1), ArrayType::Constant(rows, cols, 1));
+  VERIFY_IS_APPROX((m3.topLeftCorner(rows, cols) = 1), ArrayType::Constant(rows, cols, 1));
+  typedef Array<Scalar, ArrayType::RowsAtCompileTime == Dynamic ? 2 : ArrayType::RowsAtCompileTime,
+                ArrayType::ColsAtCompileTime == Dynamic ? 2 : ArrayType::ColsAtCompileTime, ArrayType::Options>
+      FixedArrayType;
+  {
+    FixedArrayType f1(s1);
+    VERIFY_IS_APPROX(f1, FixedArrayType::Constant(s1));
+    FixedArrayType f2(numext::real(s1));
+    VERIFY_IS_APPROX(f2, FixedArrayType::Constant(numext::real(s1)));
+    FixedArrayType f3((int)100 * numext::real(s1));
+    VERIFY_IS_APPROX(f3, FixedArrayType::Constant((int)100 * numext::real(s1)));
+    f1.setRandom();
+    FixedArrayType f4(f1.data());
+    VERIFY_IS_APPROX(f4, f1);
+  }
+  {
+    FixedArrayType f1{s1};
+    VERIFY_IS_APPROX(f1, FixedArrayType::Constant(s1));
+    FixedArrayType f2{numext::real(s1)};
+    VERIFY_IS_APPROX(f2, FixedArrayType::Constant(numext::real(s1)));
+    FixedArrayType f3{(int)100 * numext::real(s1)};
+    VERIFY_IS_APPROX(f3, FixedArrayType::Constant((int)100 * numext::real(s1)));
+    f1.setRandom();
+    FixedArrayType f4{f1.data()};
+    VERIFY_IS_APPROX(f4, f1);
+  }
+
+  // pow
+  VERIFY_IS_APPROX(m1.pow(2), m1.square());
+  VERIFY_IS_APPROX(pow(m1, 2), m1.square());
+  VERIFY_IS_APPROX(m1.pow(3), m1.cube());
+  VERIFY_IS_APPROX(pow(m1, 3), m1.cube());
+  VERIFY_IS_APPROX((-m1).pow(3), -m1.cube());
+  VERIFY_IS_APPROX(pow(2 * m1, 3), 8 * m1.cube());
+  ArrayType exponents = ArrayType::Constant(rows, cols, RealScalar(2));
+  VERIFY_IS_APPROX(Eigen::pow(m1, exponents), m1.square());
+  VERIFY_IS_APPROX(m1.pow(exponents), m1.square());
+  VERIFY_IS_APPROX(Eigen::pow(2 * m1, exponents), 4 * m1.square());
+  VERIFY_IS_APPROX((2 * m1).pow(exponents), 4 * m1.square());
+  VERIFY_IS_APPROX(Eigen::pow(m1, 2 * exponents), m1.square().square());
+  VERIFY_IS_APPROX(m1.pow(2 * exponents), m1.square().square());
+  VERIFY_IS_APPROX(Eigen::pow(m1(0, 0), exponents), ArrayType::Constant(rows, cols, m1(0, 0) * m1(0, 0)));
+
+  // Check possible conflicts with 1D ctor
+  typedef Array<Scalar, Dynamic, 1> OneDArrayType;
+  {
+    OneDArrayType o1(rows);
+    VERIFY(o1.size() == rows);
+    OneDArrayType o2(static_cast<int>(rows));
+    VERIFY(o2.size() == rows);
+  }
+  {
+    OneDArrayType o1{rows};
+    VERIFY(o1.size() == rows);
+    OneDArrayType o4{int(rows)};
+    VERIFY(o4.size() == rows);
+  }
+  // Check possible conflicts with 2D ctor
+  typedef Array<Scalar, Dynamic, Dynamic> TwoDArrayType;
+  typedef Array<Scalar, 2, 1> ArrayType2;
+  {
+    TwoDArrayType o1(rows, cols);
+    VERIFY(o1.rows() == rows);
+    VERIFY(o1.cols() == cols);
+    TwoDArrayType o2(static_cast<int>(rows), static_cast<int>(cols));
+    VERIFY(o2.rows() == rows);
+    VERIFY(o2.cols() == cols);
+
+    ArrayType2 o3(rows, cols);
+    VERIFY(o3(0) == RealScalar(rows) && o3(1) == RealScalar(cols));
+    ArrayType2 o4(static_cast<int>(rows), static_cast<int>(cols));
+    VERIFY(o4(0) == RealScalar(rows) && o4(1) == RealScalar(cols));
+  }
+  {
+    TwoDArrayType o1{rows, cols};
+    VERIFY(o1.rows() == rows);
+    VERIFY(o1.cols() == cols);
+    TwoDArrayType o2{int(rows), int(cols)};
+    VERIFY(o2.rows() == rows);
+    VERIFY(o2.cols() == cols);
+
+    ArrayType2 o3{rows, cols};
+    VERIFY(o3(0) == RealScalar(rows) && o3(1) == RealScalar(cols));
+    ArrayType2 o4{int(rows), int(cols)};
+    VERIFY(o4(0) == RealScalar(rows) && o4(1) == RealScalar(cols));
+  }
+}
+
+template <typename ArrayType>
+void comparisons(const ArrayType& m) {
+  using numext::abs;
+  typedef typename ArrayType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  Index r = internal::random<Index>(0, rows - 1), c = internal::random<Index>(0, cols - 1);
+
+  ArrayType m1 = ArrayType::Random(rows, cols), m2 = ArrayType::Random(rows, cols), m3(rows, cols), m4 = m1;
+
+  m4 = (m4.abs() == Scalar(0)).select(1, m4);
+
+  // use operator overloads with default return type
+
+  VERIFY(((m1 + Scalar(1)) > m1).all());
+  VERIFY(((m1 - Scalar(1)) < m1).all());
+  if (rows * cols > 1) {
+    m3 = m1;
+    m3(r, c) += 1;
+    VERIFY(!(m1 < m3).all());
+    VERIFY(!(m1 > m3).all());
+  }
+  VERIFY(!(m1 > m2 && m1 < m2).any());
+  VERIFY((m1 <= m2 || m1 >= m2).all());
+
+  // comparisons array to scalar
+  VERIFY((m1 != (m1(r, c) + 1)).any());
+  VERIFY((m1 > (m1(r, c) - 1)).any());
+  VERIFY((m1 < (m1(r, c) + 1)).any());
+  VERIFY((m1 == m1(r, c)).any());
+
+  // comparisons scalar to array
+  VERIFY(((m1(r, c) + 1) != m1).any());
+  VERIFY(((m1(r, c) - 1) < m1).any());
+  VERIFY(((m1(r, c) + 1) > m1).any());
+  VERIFY((m1(r, c) == m1).any());
+
+  // currently, any() / all() are not vectorized, so use VERIFY_IS_CWISE_EQUAL to test vectorized path
+
+  // use typed comparisons, regardless of operator overload behavior
+  typename ArrayType::ConstantReturnType typed_true = ArrayType::Constant(rows, cols, Scalar(1));
+  // (m1 + Scalar(1)) > m1).all()
+  VERIFY_IS_CWISE_EQUAL((m1 + Scalar(1)).cwiseTypedGreater(m1), typed_true);
+  // (m1 - Scalar(1)) < m1).all()
+  VERIFY_IS_CWISE_EQUAL((m1 - Scalar(1)).cwiseTypedLess(m1), typed_true);
+  // (m1 + Scalar(1)) == (m1 + Scalar(1))).all()
+  VERIFY_IS_CWISE_EQUAL((m1 + Scalar(1)).cwiseTypedEqual(m1 + Scalar(1)), typed_true);
+  // (m1 - Scalar(1)) != m1).all()
+  VERIFY_IS_CWISE_EQUAL((m1 - Scalar(1)).cwiseTypedNotEqual(m1), typed_true);
+  // (m1 <= m2 || m1 >= m2).all()
+  VERIFY_IS_CWISE_EQUAL(m1.cwiseTypedGreaterOrEqual(m2) || m1.cwiseTypedLessOrEqual(m2), typed_true);
+
+  // use boolean comparisons, regardless of operator overload behavior
+  ArrayXX<bool>::ConstantReturnType bool_true = ArrayXX<bool>::Constant(rows, cols, true);
+  // (m1 + Scalar(1)) > m1).all()
+  VERIFY_IS_CWISE_EQUAL((m1 + Scalar(1)).cwiseGreater(m1), bool_true);
+  // (m1 - Scalar(1)) < m1).all()
+  VERIFY_IS_CWISE_EQUAL((m1 - Scalar(1)).cwiseLess(m1), bool_true);
+  // (m1 + Scalar(1)) == (m1 + Scalar(1))).all()
+  VERIFY_IS_CWISE_EQUAL((m1 + Scalar(1)).cwiseEqual(m1 + Scalar(1)), bool_true);
+  // (m1 - Scalar(1)) != m1).all()
+  VERIFY_IS_CWISE_EQUAL((m1 - Scalar(1)).cwiseNotEqual(m1), bool_true);
+  // (m1 <= m2 || m1 >= m2).all()
+  VERIFY_IS_CWISE_EQUAL(m1.cwiseLessOrEqual(m2) || m1.cwiseGreaterOrEqual(m2), bool_true);
+
+  // test typed comparisons with scalar argument
+  VERIFY_IS_CWISE_EQUAL((m1 - m1).cwiseTypedEqual(Scalar(0)), typed_true);
+  VERIFY_IS_CWISE_EQUAL((m1.abs() + Scalar(1)).cwiseTypedNotEqual(Scalar(0)), typed_true);
+  VERIFY_IS_CWISE_EQUAL((m1 + Scalar(1)).cwiseTypedGreater(m1.minCoeff()), typed_true);
+  VERIFY_IS_CWISE_EQUAL((m1 - Scalar(1)).cwiseTypedLess(m1.maxCoeff()), typed_true);
+  VERIFY_IS_CWISE_EQUAL(m1.abs().cwiseTypedLessOrEqual(NumTraits<Scalar>::highest()), typed_true);
+  VERIFY_IS_CWISE_EQUAL(m1.abs().cwiseTypedGreaterOrEqual(Scalar(0)), typed_true);
+
+  // test boolean comparisons with scalar argument
+  VERIFY_IS_CWISE_EQUAL((m1 - m1).cwiseEqual(Scalar(0)), bool_true);
+  VERIFY_IS_CWISE_EQUAL((m1.abs() + Scalar(1)).cwiseNotEqual(Scalar(0)), bool_true);
+  VERIFY_IS_CWISE_EQUAL((m1 + Scalar(1)).cwiseGreater(m1.minCoeff()), bool_true);
+  VERIFY_IS_CWISE_EQUAL((m1 - Scalar(1)).cwiseLess(m1.maxCoeff()), bool_true);
+  VERIFY_IS_CWISE_EQUAL(m1.abs().cwiseLessOrEqual(NumTraits<Scalar>::highest()), bool_true);
+  VERIFY_IS_CWISE_EQUAL(m1.abs().cwiseGreaterOrEqual(Scalar(0)), bool_true);
+
+  // test select
+  VERIFY_IS_APPROX((m1 < m2).select(m1, m2), m1.cwiseMin(m2));
+  VERIFY_IS_APPROX((m1 > m2).select(m1, m2), m1.cwiseMax(m2));
+  Scalar mid = (m1.cwiseAbs().minCoeff() + m1.cwiseAbs().maxCoeff()) / Scalar(2);
+  for (int j = 0; j < cols; ++j)
+    for (int i = 0; i < rows; ++i) m3(i, j) = abs(m1(i, j)) < mid ? 0 : m1(i, j);
+  VERIFY_IS_APPROX((m1.abs() < ArrayType::Constant(rows, cols, mid)).select(ArrayType::Zero(rows, cols), m1), m3);
+  // shorter versions:
+  VERIFY_IS_APPROX((m1.abs() < ArrayType::Constant(rows, cols, mid)).select(0, m1), m3);
+  VERIFY_IS_APPROX((m1.abs() >= ArrayType::Constant(rows, cols, mid)).select(m1, 0), m3);
+  // even shorter version:
+  VERIFY_IS_APPROX((m1.abs() < mid).select(0, m1), m3);
+
+  // count
+  VERIFY(((m1.abs() + 1) > RealScalar(0.1)).count() == rows * cols);
+
+  // and/or
+  VERIFY((m1 < RealScalar(0) && m1 > RealScalar(0)).count() == 0);
+  VERIFY((m1 < RealScalar(0) || m1 >= RealScalar(0)).count() == rows * cols);
+  RealScalar a = m1.abs().mean();
+  VERIFY((m1 < -a || m1 > a).count() == (m1.abs() > a).count());
+
+  typedef Array<Index, Dynamic, 1> ArrayOfIndices;
+
+  // TODO allows colwise/rowwise for array
+  VERIFY_IS_APPROX(((m1.abs() + 1) > RealScalar(0.1)).colwise().count(),
+                   ArrayOfIndices::Constant(cols, rows).transpose());
+  VERIFY_IS_APPROX(((m1.abs() + 1) > RealScalar(0.1)).rowwise().count(), ArrayOfIndices::Constant(rows, cols));
+
+  // simple data type that does not permit implicit conversions
+  struct scalar_wrapper {
+    Scalar m_data;
+    scalar_wrapper() : m_data(0) {}
+    explicit scalar_wrapper(Scalar data) : m_data(data) {}
+    bool operator==(scalar_wrapper other) const { return m_data == other.m_data; }
+  };
+
+  // test bug2966: select did not support some scalar types that forbade implicit conversions from bool
+  ArrayX<scalar_wrapper> m5(10);
+  m5 = (m5 == scalar_wrapper(0)).select(m5, m5);
+}
+
+template <typename ArrayType>
+void array_real(const ArrayType& m) {
+  using numext::abs;
+  using std::sqrt;
+  typedef typename ArrayType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  ArrayType m1 = ArrayType::Random(rows, cols), m2 = ArrayType::Random(rows, cols), m3(rows, cols), m4 = m1;
+
+  // avoid denormalized values so verification doesn't fail on platforms that don't support them
+  // denormalized behavior is tested elsewhere (unary_op_test, binary_ops_test)
+  const Scalar min = (std::numeric_limits<Scalar>::min)();
+  m1 = (m1.abs() < min).select(Scalar(0), m1);
+  m2 = (m2.abs() < min).select(Scalar(0), m2);
+  m4 = (m4.abs() < min).select(Scalar(1), m4);
+
+  Scalar s1 = internal::random<Scalar>();
+
+  // these tests are mostly to check possible compilation issues with free-functions.
+  VERIFY_IS_APPROX(m1.sin(), sin(m1));
+  VERIFY_IS_APPROX(m1.cos(), cos(m1));
+  VERIFY_IS_APPROX(m1.tan(), tan(m1));
+  VERIFY_IS_APPROX(m1.asin(), asin(m1));
+  VERIFY_IS_APPROX(m1.acos(), acos(m1));
+  VERIFY_IS_APPROX(m1.atan(), atan(m1));
+  VERIFY_IS_APPROX(m1.sinh(), sinh(m1));
+  VERIFY_IS_APPROX(m1.cosh(), cosh(m1));
+  VERIFY_IS_APPROX(m1.tanh(), tanh(m1));
+  VERIFY_IS_APPROX(m1.atan2(m2), atan2(m1, m2));
+
+  VERIFY_IS_APPROX(m1.tanh().atanh(), atanh(tanh(m1)));
+  VERIFY_IS_APPROX(m1.sinh().asinh(), asinh(sinh(m1)));
+  VERIFY_IS_APPROX(m1.cosh().acosh(), acosh(cosh(m1)));
+  VERIFY_IS_APPROX(m1.tanh().atanh(), atanh(tanh(m1)));
+  VERIFY_IS_APPROX(m1.logistic(), logistic(m1));
+
+  VERIFY_IS_APPROX(m1.arg(), arg(m1));
+  VERIFY_IS_APPROX(m1.round(), round(m1));
+  VERIFY_IS_APPROX(m1.rint(), rint(m1));
+  VERIFY_IS_APPROX(m1.floor(), floor(m1));
+  VERIFY_IS_APPROX(m1.ceil(), ceil(m1));
+  VERIFY_IS_APPROX(m1.trunc(), trunc(m1));
+  VERIFY((m1.isNaN() == (Eigen::isnan)(m1)).all());
+  VERIFY((m1.isInf() == (Eigen::isinf)(m1)).all());
+  VERIFY((m1.isFinite() == (Eigen::isfinite)(m1)).all());
+  VERIFY_IS_APPROX(m4.inverse(), inverse(m4));
+  VERIFY_IS_APPROX(m1.abs(), abs(m1));
+  VERIFY_IS_APPROX(m1.abs2(), abs2(m1));
+  VERIFY_IS_APPROX(m1.square(), square(m1));
+  VERIFY_IS_APPROX(m1.cube(), cube(m1));
+  VERIFY_IS_APPROX(cos(m1 + RealScalar(3) * m2), cos((m1 + RealScalar(3) * m2).eval()));
+  VERIFY_IS_APPROX(m1.sign(), sign(m1));
+  VERIFY((m1.sqrt().sign().isNaN() == (Eigen::isnan)(sign(sqrt(m1)))).all());
+
+  // avoid inf and NaNs so verification doesn't fail
+  m3 = m4.abs();
+
+  VERIFY_IS_APPROX(m3.sqrt(), sqrt(abs(m3)));
+  VERIFY_IS_APPROX(m3.cbrt(), cbrt(m3));
+  VERIFY_IS_APPROX(m3.rsqrt(), Scalar(1) / sqrt(abs(m3)));
+  VERIFY_IS_APPROX(rsqrt(m3), Scalar(1) / sqrt(abs(m3)));
+  VERIFY_IS_APPROX(m3.log(), log(m3));
+  VERIFY_IS_APPROX(m3.log1p(), log1p(m3));
+  VERIFY_IS_APPROX(m3.log10(), log10(m3));
+  VERIFY_IS_APPROX(m3.log2(), log2(m3));
+
+  VERIFY((!(m1 > m2) == (m1 <= m2)).all());
+
+  VERIFY_IS_APPROX(sin(m1.asin()), m1);
+  VERIFY_IS_APPROX(cos(m1.acos()), m1);
+  VERIFY_IS_APPROX(tan(m1.atan()), m1);
+  VERIFY_IS_APPROX(sinh(m1), Scalar(0.5) * (exp(m1) - exp(-m1)));
+  VERIFY_IS_APPROX(cosh(m1), Scalar(0.5) * (exp(m1) + exp(-m1)));
+  VERIFY_IS_APPROX(tanh(m1), (Scalar(0.5) * (exp(m1) - exp(-m1))) / (Scalar(0.5) * (exp(m1) + exp(-m1))));
+  VERIFY_IS_APPROX(logistic(m1), (Scalar(1) / (Scalar(1) + exp(-m1))));
+  VERIFY_IS_APPROX(arg(m1), ((m1 < Scalar(0)).template cast<Scalar>()) * Scalar(std::acos(Scalar(-1))));
+  VERIFY((round(m1) <= ceil(m1) && round(m1) >= floor(m1)).all());
+  VERIFY((rint(m1) <= ceil(m1) && rint(m1) >= floor(m1)).all());
+  VERIFY(((ceil(m1) - round(m1)) <= Scalar(0.5) || (round(m1) - floor(m1)) <= Scalar(0.5)).all());
+  VERIFY(((ceil(m1) - round(m1)) <= Scalar(1.0) && (round(m1) - floor(m1)) <= Scalar(1.0)).all());
+  VERIFY(((ceil(m1) - rint(m1)) <= Scalar(0.5) || (rint(m1) - floor(m1)) <= Scalar(0.5)).all());
+  VERIFY(((ceil(m1) - rint(m1)) <= Scalar(1.0) && (rint(m1) - floor(m1)) <= Scalar(1.0)).all());
+  VERIFY((Eigen::isnan)((m1 * Scalar(0)) / Scalar(0)).all());
+  VERIFY((Eigen::isinf)(m4 / Scalar(0)).all());
+  VERIFY(((Eigen::isfinite)(m1) && (!(Eigen::isfinite)(m1 * Scalar(0) / Scalar(0))) &&
+          (!(Eigen::isfinite)(m4 / Scalar(0))))
+             .all());
+  VERIFY_IS_APPROX(inverse(inverse(m4)), m4);
+  VERIFY((abs(m1) == m1 || abs(m1) == -m1).all());
+  VERIFY_IS_APPROX(m3, sqrt(abs2(m3)));
+  VERIFY_IS_APPROX(m1.absolute_difference(m2), (m1 > m2).select(m1 - m2, m2 - m1));
+  VERIFY_IS_APPROX(m1.sign(), -(-m1).sign());
+  VERIFY_IS_APPROX(m1 * m1.sign(), m1.abs());
+  VERIFY_IS_APPROX(m1.sign() * m1.abs(), m1);
+
+  ArrayType tmp = m1.atan2(m2);
+  for (Index i = 0; i < tmp.size(); ++i) {
+    Scalar actual = tmp.array()(i);
+    Scalar expected = Scalar(std::atan2(m1.array()(i), m2.array()(i)));
+    VERIFY_IS_APPROX(actual, expected);
+  }
+
+  VERIFY_IS_APPROX(numext::abs2(numext::real(m1)) + numext::abs2(numext::imag(m1)), numext::abs2(m1));
+  VERIFY_IS_APPROX(numext::abs2(Eigen::real(m1)) + numext::abs2(Eigen::imag(m1)), numext::abs2(m1));
+  if (!NumTraits<Scalar>::IsComplex) VERIFY_IS_APPROX(numext::real(m1), m1);
+
+  // shift argument of logarithm so that it is not zero
+  Scalar smallNumber = NumTraits<Scalar>::dummy_precision();
+  VERIFY_IS_APPROX((m3 + smallNumber).log(), log(abs(m3) + smallNumber));
+  VERIFY_IS_APPROX((m3 + smallNumber + Scalar(1)).log(), log1p(abs(m3) + smallNumber));
+
+  VERIFY_IS_APPROX(m1.exp() * m2.exp(), exp(m1 + m2));
+  VERIFY_IS_APPROX(m1.exp(), exp(m1));
+  VERIFY_IS_APPROX(m1.exp() / m2.exp(), (m1 - m2).exp());
+
+  VERIFY_IS_APPROX(m1.expm1(), expm1(m1));
+  VERIFY_IS_APPROX((m3 + smallNumber).exp() - Scalar(1), expm1(abs(m3) + smallNumber));
+
+  VERIFY_IS_APPROX(m3.pow(RealScalar(0.5)), m3.sqrt());
+  VERIFY_IS_APPROX(pow(m3, RealScalar(0.5)), m3.sqrt());
+  VERIFY_IS_APPROX(m3.pow(RealScalar(1.0 / 3.0)), m3.cbrt());
+  VERIFY_IS_APPROX(pow(m3, RealScalar(1.0 / 3.0)), m3.cbrt());
+
+  VERIFY_IS_APPROX(m3.pow(RealScalar(-0.5)), m3.rsqrt());
+  VERIFY_IS_APPROX(pow(m3, RealScalar(-0.5)), m3.rsqrt());
+
+  // Avoid inf and NaN.
+  m3 = (m1.square() < NumTraits<Scalar>::epsilon()).select(Scalar(1), m3);
+  VERIFY_IS_APPROX(m3.pow(RealScalar(-2)), m3.square().inverse());
+
+  // Test pow and atan2 on special IEEE values.
+  unary_ops_test<Scalar>();
+  binary_ops_test<Scalar>();
+
+  VERIFY_IS_APPROX(log10(m3), log(m3) / numext::log(Scalar(10)));
+  VERIFY_IS_APPROX(log2(m3), log(m3) / numext::log(Scalar(2)));
+
+  // scalar by array division
+  const RealScalar tiny = sqrt(std::numeric_limits<RealScalar>::epsilon());
+  s1 += Scalar(tiny);
+  m1 += ArrayType::Constant(rows, cols, Scalar(tiny));
+  VERIFY_IS_CWISE_APPROX(s1 / m1, s1 * m1.inverse());
+
+  // check inplace transpose
+  m3 = m1;
+  m3.transposeInPlace();
+  VERIFY_IS_APPROX(m3, m1.transpose());
+  m3.transposeInPlace();
+  VERIFY_IS_APPROX(m3, m1);
+}
+
+template <typename ArrayType>
+void array_complex(const ArrayType& m) {
+  typedef typename ArrayType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  ArrayType m1 = ArrayType::Random(rows, cols), m2(rows, cols), m4 = m1;
+
+  m4.real() = (m4.real().abs() == RealScalar(0)).select(RealScalar(1), m4.real());
+  m4.imag() = (m4.imag().abs() == RealScalar(0)).select(RealScalar(1), m4.imag());
+
+  Array<RealScalar, -1, -1> m3(rows, cols);
+
+  for (Index i = 0; i < m.rows(); ++i)
+    for (Index j = 0; j < m.cols(); ++j) m2(i, j) = sqrt(m1(i, j));
+
+  // these tests are mostly to check possible compilation issues with free-functions.
+  VERIFY_IS_APPROX(m1.sin(), sin(m1));
+  VERIFY_IS_APPROX(m1.cos(), cos(m1));
+  VERIFY_IS_APPROX(m1.tan(), tan(m1));
+  VERIFY_IS_APPROX(m1.sinh(), sinh(m1));
+  VERIFY_IS_APPROX(m1.cosh(), cosh(m1));
+  VERIFY_IS_APPROX(m1.tanh(), tanh(m1));
+  VERIFY_IS_APPROX(m1.logistic(), logistic(m1));
+  VERIFY_IS_APPROX(m1.arg(), arg(m1));
+  VERIFY_IS_APPROX(m1.carg(), carg(m1));
+  VERIFY_IS_APPROX(arg(m1), carg(m1));
+  VERIFY((m1.isNaN() == (Eigen::isnan)(m1)).all());
+  VERIFY((m1.isInf() == (Eigen::isinf)(m1)).all());
+  VERIFY((m1.isFinite() == (Eigen::isfinite)(m1)).all());
+  VERIFY_IS_APPROX(m4.inverse(), inverse(m4));
+  VERIFY_IS_APPROX(m1.log(), log(m1));
+  VERIFY_IS_APPROX(m1.log10(), log10(m1));
+  VERIFY_IS_APPROX(m1.log2(), log2(m1));
+  VERIFY_IS_APPROX(m1.abs(), abs(m1));
+  VERIFY_IS_APPROX(m1.abs2(), abs2(m1));
+  VERIFY_IS_APPROX(m1.sqrt(), sqrt(m1));
+  VERIFY_IS_APPROX(m1.square(), square(m1));
+  VERIFY_IS_APPROX(m1.cube(), cube(m1));
+  VERIFY_IS_APPROX(cos(m1 + RealScalar(3) * m2), cos((m1 + RealScalar(3) * m2).eval()));
+  VERIFY_IS_APPROX(m1.sign(), sign(m1));
+
+  VERIFY_IS_APPROX(m1.exp() * m2.exp(), exp(m1 + m2));
+  VERIFY_IS_APPROX(m1.exp(), exp(m1));
+  VERIFY_IS_APPROX(m1.exp() / m2.exp(), (m1 - m2).exp());
+
+  VERIFY_IS_APPROX(m1.expm1(), expm1(m1));
+  VERIFY_IS_APPROX(expm1(m1), exp(m1) - 1.);
+  // Check for larger magnitude complex numbers that expm1 matches exp - 1.
+  VERIFY_IS_APPROX(expm1(10. * m1), exp(10. * m1) - 1.);
+
+  VERIFY_IS_APPROX(sinh(m1), 0.5 * (exp(m1) - exp(-m1)));
+  VERIFY_IS_APPROX(cosh(m1), 0.5 * (exp(m1) + exp(-m1)));
+  VERIFY_IS_APPROX(tanh(m1), (0.5 * (exp(m1) - exp(-m1))) / (0.5 * (exp(m1) + exp(-m1))));
+  VERIFY_IS_APPROX(logistic(m1), (1.0 / (1.0 + exp(-m1))));
+  if (m1.size() > 0) {
+    // Complex exponential overflow edge-case.
+    Scalar old_m1_val = m1(0, 0);
+    m1(0, 0) = std::complex<RealScalar>(1000.0, 1000.0);
+    VERIFY_IS_APPROX(logistic(m1), (1.0 / (1.0 + exp(-m1))));
+    m1(0, 0) = old_m1_val;  // Restore value for future tests.
+  }
+
+  for (Index i = 0; i < m.rows(); ++i)
+    for (Index j = 0; j < m.cols(); ++j) m3(i, j) = std::atan2(m1(i, j).imag(), m1(i, j).real());
+  VERIFY_IS_APPROX(arg(m1), m3);
+  VERIFY_IS_APPROX(carg(m1), m3);
+
+  std::complex<RealScalar> zero(0.0, 0.0);
+  VERIFY((Eigen::isnan)(m1 * zero / zero).all());
+#if EIGEN_COMP_MSVC
+  // msvc complex division is not robust
+  VERIFY((Eigen::isinf)(m4 / RealScalar(0)).all());
+#else
+#if EIGEN_COMP_CLANG
+  // clang's complex division is notoriously broken too
+  if ((numext::isinf)(m4(0, 0) / RealScalar(0))) {
+#endif
+    VERIFY((Eigen::isinf)(m4 / zero).all());
+#if EIGEN_COMP_CLANG
+  } else {
+    VERIFY((Eigen::isinf)(m4.real() / zero.real()).all());
+  }
+#endif
+#endif  // MSVC
+
+  VERIFY(((Eigen::isfinite)(m1) && (!(Eigen::isfinite)(m1 * zero / zero)) && (!(Eigen::isfinite)(m1 / zero))).all());
+
+  VERIFY_IS_APPROX(inverse(inverse(m4)), m4);
+  VERIFY_IS_APPROX(conj(m1.conjugate()), m1);
+  VERIFY_IS_APPROX(abs(m1), sqrt(square(m1.real()) + square(m1.imag())));
+  VERIFY_IS_APPROX(abs(m1), sqrt(abs2(m1)));
+  VERIFY_IS_APPROX(log10(m1), log(m1) / log(10));
+  VERIFY_IS_APPROX(log2(m1), log(m1) / log(2));
+
+  VERIFY_IS_APPROX(m1.sign(), -(-m1).sign());
+  VERIFY_IS_APPROX(m1.sign() * m1.abs(), m1);
+
+  // scalar by array division
+  Scalar s1 = internal::random<Scalar>();
+  const RealScalar tiny = std::sqrt(std::numeric_limits<RealScalar>::epsilon());
+  s1 += Scalar(tiny);
+  m1 += ArrayType::Constant(rows, cols, Scalar(tiny));
+  VERIFY_IS_APPROX(s1 / m1, s1 * m1.inverse());
+
+  // check inplace transpose
+  m2 = m1;
+  m2.transposeInPlace();
+  VERIFY_IS_APPROX(m2, m1.transpose());
+  m2.transposeInPlace();
+  VERIFY_IS_APPROX(m2, m1);
+  // Check vectorized inplace transpose.
+  ArrayType m5 = ArrayType::Random(131, 131);
+  ArrayType m6 = m5;
+  m6.transposeInPlace();
+  VERIFY_IS_APPROX(m6, m5.transpose());
+}
+
+template <typename ArrayType>
+void min_max(const ArrayType& m) {
+  typedef typename ArrayType::Scalar Scalar;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  ArrayType m1 = ArrayType::Random(rows, cols);
+
+  // min/max with array
+  Scalar maxM1 = m1.maxCoeff();
+  Scalar minM1 = m1.minCoeff();
+
+  VERIFY_IS_APPROX(ArrayType::Constant(rows, cols, minM1), (m1.min)(ArrayType::Constant(rows, cols, minM1)));
+  VERIFY_IS_APPROX(m1, (m1.min)(ArrayType::Constant(rows, cols, maxM1)));
+
+  VERIFY_IS_APPROX(ArrayType::Constant(rows, cols, maxM1), (m1.max)(ArrayType::Constant(rows, cols, maxM1)));
+  VERIFY_IS_APPROX(m1, (m1.max)(ArrayType::Constant(rows, cols, minM1)));
+
+  // min/max with scalar input
+  VERIFY_IS_APPROX(ArrayType::Constant(rows, cols, minM1), (m1.min)(minM1));
+  VERIFY_IS_APPROX(m1, (m1.min)(maxM1));
+
+  VERIFY_IS_APPROX(ArrayType::Constant(rows, cols, maxM1), (m1.max)(maxM1));
+  VERIFY_IS_APPROX(m1, (m1.max)(minM1));
+
+  // min/max with various NaN propagation options.
+  if (m1.size() > 1 && !NumTraits<Scalar>::IsInteger) {
+    m1(0, 0) = NumTraits<Scalar>::quiet_NaN();
+    maxM1 = m1.template maxCoeff<PropagateNaN>();
+    minM1 = m1.template minCoeff<PropagateNaN>();
+    VERIFY((numext::isnan)(maxM1));
+    VERIFY((numext::isnan)(minM1));
+
+    maxM1 = m1.template maxCoeff<PropagateNumbers>();
+    minM1 = m1.template minCoeff<PropagateNumbers>();
+    VERIFY(!(numext::isnan)(maxM1));
+    VERIFY(!(numext::isnan)(minM1));
+  }
+}
+
+template <typename Scalar>
+struct shift_imm_traits {
+  enum { Cost = 1, PacketAccess = internal::packet_traits<Scalar>::HasShift };
+};
+
+template <int N, typename Scalar>
+struct logical_left_shift_op {
+  Scalar operator()(const Scalar& v) const { return numext::logical_shift_left(v, N); }
+  template <typename Packet>
+  Packet packetOp(const Packet& v) const {
+    return internal::plogical_shift_left<N>(v);
+  }
+};
+template <int N, typename Scalar>
+struct logical_right_shift_op {
+  Scalar operator()(const Scalar& v) const { return numext::logical_shift_right(v, N); }
+  template <typename Packet>
+  Packet packetOp(const Packet& v) const {
+    return internal::plogical_shift_right<N>(v);
+  }
+};
+template <int N, typename Scalar>
+struct arithmetic_right_shift_op {
+  Scalar operator()(const Scalar& v) const { return numext::arithmetic_shift_right(v, N); }
+  template <typename Packet>
+  Packet packetOp(const Packet& v) const {
+    return internal::parithmetic_shift_right<N>(v);
+  }
+};
+
+namespace Eigen {
+namespace internal {
+template <int N, typename Scalar>
+struct functor_traits<logical_left_shift_op<N, Scalar>> : shift_imm_traits<Scalar> {};
+template <int N, typename Scalar>
+struct functor_traits<logical_right_shift_op<N, Scalar>> : shift_imm_traits<Scalar> {};
+template <int N, typename Scalar>
+struct functor_traits<arithmetic_right_shift_op<N, Scalar>> : shift_imm_traits<Scalar> {};
+}  // namespace internal
+}  // namespace Eigen
+
+template <typename ArrayType>
+struct shift_test_impl {
+  typedef typename ArrayType::Scalar Scalar;
+  static constexpr size_t Size = sizeof(Scalar);
+  static constexpr size_t MaxShift = (CHAR_BIT * Size) - 1;
+
+  template <size_t N = 1>
+  static inline std::enable_if_t<(N > MaxShift), void> run(const ArrayType&) {}
+  template <size_t N = 1>
+  static inline std::enable_if_t<(N <= MaxShift), void> run(const ArrayType& m) {
+    const Index rows = m.rows();
+    const Index cols = m.cols();
+
+    ArrayType m1 = ArrayType::Random(rows, cols), m2(rows, cols), m3(rows, cols);
+
+    m2 = m1.unaryExpr([](const Scalar& v) { return numext::logical_shift_left(v, N); });
+    m3 = m1.unaryExpr(logical_left_shift_op<N, Scalar>());
+    VERIFY_IS_CWISE_EQUAL(m2, m3);
+
+    m2 = m1.unaryExpr([](const Scalar& v) { return numext::logical_shift_right(v, N); });
+    m3 = m1.unaryExpr(logical_right_shift_op<N, Scalar>());
+    VERIFY_IS_CWISE_EQUAL(m2, m3);
+
+    m2 = m1.unaryExpr([](const Scalar& v) { return numext::arithmetic_shift_right(v, N); });
+    m3 = m1.unaryExpr(arithmetic_right_shift_op<N, Scalar>());
+    VERIFY_IS_CWISE_EQUAL(m2, m3);
+
+    run<N + 1>(m);
+  }
+};
+template <typename ArrayType>
+void shift_test(const ArrayType& m) {
+  shift_test_impl<ArrayType>::run(m);
+}
+
+template <typename ArrayType>
+struct typed_logicals_test_impl {
+  using Scalar = typename ArrayType::Scalar;
+
+  static bool scalar_to_bool(const Scalar& x) { return x != Scalar(0); }
+  static Scalar bool_to_scalar(bool x) { return x ? Scalar(1) : Scalar(0); }
+
+  static Scalar eval_bool_and(const Scalar& x, const Scalar& y) {
+    return bool_to_scalar(scalar_to_bool(x) && scalar_to_bool(y));
+  }
+  static Scalar eval_bool_or(const Scalar& x, const Scalar& y) {
+    return bool_to_scalar(scalar_to_bool(x) || scalar_to_bool(y));
+  }
+  static Scalar eval_bool_xor(const Scalar& x, const Scalar& y) {
+    return bool_to_scalar(scalar_to_bool(x) != scalar_to_bool(y));
+  }
+  static Scalar eval_bool_not(const Scalar& x) { return bool_to_scalar(!scalar_to_bool(x)); }
+
+  static void run(const ArrayType& m) {
+    Index rows = m.rows();
+    Index cols = m.cols();
+
+    ArrayType m1(rows, cols), m2(rows, cols), m3(rows, cols), m4(rows, cols);
+
+    m1.setRandom();
+    m2.setRandom();
+    m1 *= ArrayX<bool>::Random(rows, cols).cast<Scalar>();
+    m2 *= ArrayX<bool>::Random(rows, cols).cast<Scalar>();
+
+    // test boolean and
+    m3 = m1 && m2;
+    m4 = m1.binaryExpr(m2, [](const Scalar& x, const Scalar& y) { return eval_bool_and(x, y); });
+    VERIFY_IS_CWISE_EQUAL(m3, m4);
+    for (const Scalar& val : m3) VERIFY(val == Scalar(0) || val == Scalar(1));
+
+    // test boolean or
+    m3 = m1 || m2;
+    m4 = m1.binaryExpr(m2, [](const Scalar& x, const Scalar& y) { return eval_bool_or(x, y); });
+    VERIFY_IS_CWISE_EQUAL(m3, m4);
+    for (const Scalar& val : m3) VERIFY(val == Scalar(0) || val == Scalar(1));
+
+    // test boolean xor
+    m3 = m1.binaryExpr(m2, internal::scalar_boolean_xor_op<Scalar>());
+    m4 = m1.binaryExpr(m2, [](const Scalar& x, const Scalar& y) { return eval_bool_xor(x, y); });
+    VERIFY_IS_CWISE_EQUAL(m3, m4);
+    for (const Scalar& val : m3) VERIFY(val == Scalar(0) || val == Scalar(1));
+
+    // test boolean not
+    m3 = !m1;
+    m4 = m1.unaryExpr([](const Scalar& x) { return eval_bool_not(x); });
+    VERIFY_IS_CWISE_EQUAL(m3, m4);
+    for (const Scalar& val : m3) VERIFY(val == Scalar(0) || val == Scalar(1));
+
+    // test something more complicated
+    m3 = m1 && m2;
+    m4 = !(!m1 || !m2);
+    VERIFY_IS_CWISE_EQUAL(m3, m4);
+
+    m3 = m1.binaryExpr(m2, internal::scalar_boolean_xor_op<Scalar>());
+    m4 = (!m1).binaryExpr((!m2), internal::scalar_boolean_xor_op<Scalar>());
+    VERIFY_IS_CWISE_EQUAL(m3, m4);
+
+    const size_t bytes = size_t(rows) * size_t(cols) * sizeof(Scalar);
+
+    std::vector<uint8_t> m1_buffer(bytes), m2_buffer(bytes), m3_buffer(bytes), m4_buffer(bytes);
+
+    std::memcpy(m1_buffer.data(), m1.data(), bytes);
+    std::memcpy(m2_buffer.data(), m2.data(), bytes);
+
+    // test bitwise and
+    m3 = m1 & m2;
+    std::memcpy(m3_buffer.data(), m3.data(), bytes);
+    for (size_t i = 0; i < bytes; i++) VERIFY_IS_EQUAL(m3_buffer[i], uint8_t(m1_buffer[i] & m2_buffer[i]));
+
+    // test bitwise or
+    m3 = m1 | m2;
+    std::memcpy(m3_buffer.data(), m3.data(), bytes);
+    for (size_t i = 0; i < bytes; i++) VERIFY_IS_EQUAL(m3_buffer[i], uint8_t(m1_buffer[i] | m2_buffer[i]));
+
+    // test bitwise xor
+    m3 = m1 ^ m2;
+    std::memcpy(m3_buffer.data(), m3.data(), bytes);
+    for (size_t i = 0; i < bytes; i++) VERIFY_IS_EQUAL(m3_buffer[i], uint8_t(m1_buffer[i] ^ m2_buffer[i]));
+
+    // test bitwise not
+    m3 = ~m1;
+    std::memcpy(m3_buffer.data(), m3.data(), bytes);
+    for (size_t i = 0; i < bytes; i++) VERIFY_IS_EQUAL(m3_buffer[i], uint8_t(~m1_buffer[i]));
+
+    // test something more complicated
+    m3 = m1 & m2;
+    m4 = ~(~m1 | ~m2);
+    std::memcpy(m3_buffer.data(), m3.data(), bytes);
+    std::memcpy(m4_buffer.data(), m4.data(), bytes);
+    for (size_t i = 0; i < bytes; i++) VERIFY_IS_EQUAL(m3_buffer[i], m4_buffer[i]);
+
+    m3 = m1 ^ m2;
+    m4 = (~m1) ^ (~m2);
+    std::memcpy(m3_buffer.data(), m3.data(), bytes);
+    std::memcpy(m4_buffer.data(), m4.data(), bytes);
+    for (size_t i = 0; i < bytes; i++) VERIFY_IS_EQUAL(m3_buffer[i], m4_buffer[i]);
+  }
+};
+template <typename ArrayType>
+void typed_logicals_test(const ArrayType& m) {
+  typed_logicals_test_impl<ArrayType>::run(m);
+}
+
+template <typename SrcType, typename DstType, int RowsAtCompileTime, int ColsAtCompileTime>
+struct cast_test_impl {
+  using SrcArray = Array<SrcType, RowsAtCompileTime, ColsAtCompileTime>;
+  using DstArray = Array<DstType, RowsAtCompileTime, ColsAtCompileTime>;
+  struct RandomOp {
+    inline SrcType operator()(const SrcType&) const {
+      return internal::random_without_cast_overflow<SrcType, DstType>::value();
+    }
+  };
+
+  static constexpr int SrcPacketSize = internal::packet_traits<SrcType>::size;
+  static constexpr int DstPacketSize = internal::packet_traits<DstType>::size;
+  static constexpr int MaxPacketSize = internal::plain_enum_max(SrcPacketSize, DstPacketSize);
+
+  static void run() {
+    const Index testRows = RowsAtCompileTime == Dynamic ? ((10 * MaxPacketSize) + 1) : RowsAtCompileTime;
+    const Index testCols = ColsAtCompileTime == Dynamic ? ((10 * MaxPacketSize) + 1) : ColsAtCompileTime;
+    const Index testSize = testRows * testCols;
+    const Index minTestSize = 100;
+    const Index repeats = numext::div_ceil(minTestSize, testSize);
+
+    SrcArray src(testRows, testCols);
+    DstArray dst(testRows, testCols);
+
+    for (Index repeat = 0; repeat < repeats; repeat++) {
+      src = src.unaryExpr(RandomOp());
+      dst = src.template cast<DstType>();
+
+      for (Index j = 0; j < testCols; j++)
+        for (Index i = 0; i < testRows; i++) {
+          SrcType srcVal = src(i, j);
+          DstType refVal = internal::cast_impl<SrcType, DstType>::run(srcVal);
+          DstType dstVal = dst(i, j);
+          bool isApprox = verifyIsApprox(dstVal, refVal);
+          if (!isApprox)
+            std::cout << type_name(srcVal) << ": [" << +srcVal << "] to " << type_name(dstVal) << ": [" << +dstVal
+                      << "] != [" << +refVal << "]\n";
+          VERIFY(isApprox);
+        }
+    }
+  }
+};
+
+template <int RowsAtCompileTime, int ColsAtCompileTime, typename... ScalarTypes>
+struct cast_tests_impl {
+  using ScalarTuple = std::tuple<ScalarTypes...>;
+  static constexpr size_t ScalarTupleSize = std::tuple_size<ScalarTuple>::value;
+
+  template <size_t i = 0, size_t j = i + 1, bool Done = (i >= ScalarTupleSize - 1) || (j >= ScalarTupleSize)>
+  static std::enable_if_t<Done> run() {}
+
+  template <size_t i = 0, size_t j = i + 1, bool Done = (i >= ScalarTupleSize - 1) || (j >= ScalarTupleSize)>
+  static std::enable_if_t<!Done> run() {
+    using Type1 = typename std::tuple_element<i, ScalarTuple>::type;
+    using Type2 = typename std::tuple_element<j, ScalarTuple>::type;
+    cast_test_impl<Type1, Type2, RowsAtCompileTime, ColsAtCompileTime>::run();
+    cast_test_impl<Type2, Type1, RowsAtCompileTime, ColsAtCompileTime>::run();
+    static constexpr size_t next_i = (j == ScalarTupleSize - 1) ? (i + 1) : (i + 0);
+    static constexpr size_t next_j = (j == ScalarTupleSize - 1) ? (i + 2) : (j + 1);
+    run<next_i, next_j>();
+  }
+};
+
+// for now, remove all references to 'long double' until test passes on all platforms
+template <int RowsAtCompileTime, int ColsAtCompileTime>
+void cast_test() {
+  cast_tests_impl<RowsAtCompileTime, ColsAtCompileTime, bool, int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t,
+                  uint32_t, uint64_t, float, double, /*long double, */ half, bfloat16>::run();
+}
+
+EIGEN_DECLARE_TEST(array_cwise) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(array_generic(Array<float, 1, 1>()));
+    CALL_SUBTEST_2(array_generic(Array22f()));
+    CALL_SUBTEST_3(array_generic(Array44d()));
+    CALL_SUBTEST_4(array_generic(
+        ArrayXXcf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_5(array_generic(
+        ArrayXXf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_8(array_generic(
+        ArrayXXi(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_7(array_generic(Array<Index, Dynamic, Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
+                                                                internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_8(shift_test(
+        ArrayXXi(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_9(shift_test(Array<Index, Dynamic, Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
+                                                             internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_10(array_generic(Array<uint32_t, Dynamic, Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
+                                                                    internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_11(array_generic(Array<uint64_t, Dynamic, Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
+                                                                    internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+  }
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(comparisons(Array<float, 1, 1>()));
+    CALL_SUBTEST_2(comparisons(Array22f()));
+    CALL_SUBTEST_3(comparisons(Array44d()));
+    CALL_SUBTEST_7(comparisons(
+        ArrayXXf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_8(comparisons(
+        ArrayXXi(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+  }
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_6(min_max(Array<float, 1, 1>()));
+    CALL_SUBTEST_7(min_max(Array22f()));
+    CALL_SUBTEST_8(min_max(Array44d()));
+    CALL_SUBTEST_9(min_max(
+        ArrayXXf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_10(min_max(
+        ArrayXXi(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+  }
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_11(array_real(Array<float, 1, 1>()));
+    CALL_SUBTEST_12(array_real(Array22f()));
+    CALL_SUBTEST_13(array_real(Array44d()));
+    CALL_SUBTEST_14(array_real(
+        ArrayXXf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_15(array_real(Array<Eigen::half, 32, 32>()));
+    CALL_SUBTEST_16(array_real(Array<Eigen::bfloat16, 32, 32>()));
+  }
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_17(array_complex(
+        ArrayXXcf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_18(array_complex(
+        ArrayXXcd(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+  }
+
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_19(float_pow_test());
+    CALL_SUBTEST_20(int_pow_test());
+    CALL_SUBTEST_21(mixed_pow_test());
+    CALL_SUBTEST_22(signbit_tests());
+  }
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_23(typed_logicals_test(ArrayX<int>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_24(typed_logicals_test(ArrayX<float>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_25(typed_logicals_test(ArrayX<double>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_26(typed_logicals_test(ArrayX<std::complex<float>>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_27(typed_logicals_test(ArrayX<std::complex<double>>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+  }
+
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_28((cast_test<1, 1>()));
+    CALL_SUBTEST_29((cast_test<3, 1>()));
+    CALL_SUBTEST_30((cast_test<5, 1>()));
+    CALL_SUBTEST_31((cast_test<9, 1>()));
+    CALL_SUBTEST_32((cast_test<17, 1>()));
+    CALL_SUBTEST_33((cast_test<Dynamic, 1>()));
+  }
+
+  VERIFY((internal::is_same<internal::global_math_functions_filtering_base<int>::type, int>::value));
+  VERIFY((internal::is_same<internal::global_math_functions_filtering_base<float>::type, float>::value));
+  VERIFY((internal::is_same<internal::global_math_functions_filtering_base<Array2i>::type, ArrayBase<Array2i>>::value));
+  typedef CwiseUnaryOp<internal::scalar_abs_op<double>, ArrayXd> Xpr;
+  VERIFY((internal::is_same<internal::global_math_functions_filtering_base<Xpr>::type, ArrayBase<Xpr>>::value));
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/array_for_matrix.cpp

@@ -0,0 +1,349 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include "main.h"
+
+template <typename MatrixType>
+void array_for_matrix(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> ColVectorType;
+  typedef Matrix<Scalar, 1, MatrixType::ColsAtCompileTime> RowVectorType;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  MatrixType m1 = MatrixType::Random(rows, cols), m2 = MatrixType::Random(rows, cols), m3(rows, cols);
+  ColVectorType cv1 = ColVectorType::Random(rows);
+  RowVectorType rv1 = RowVectorType::Random(cols);
+
+  Scalar s1 = internal::random<Scalar>(), s2 = internal::random<Scalar>();
+
+  // Prevent overflows for integer types.
+  if (Eigen::NumTraits<Scalar>::IsInteger) {
+    Scalar kMaxVal = Scalar(1000);
+    m1.array() = m1.array() - kMaxVal * (m1.array() / kMaxVal);
+    m2.array() = m2.array() - kMaxVal * (m2.array() / kMaxVal);
+  }
+
+  // scalar addition
+  VERIFY_IS_APPROX(m1.array() + s1, s1 + m1.array());
+  VERIFY_IS_APPROX((m1.array() + s1).matrix(), MatrixType::Constant(rows, cols, s1) + m1);
+  VERIFY_IS_APPROX(((m1 * Scalar(2)).array() - s2).matrix(), (m1 + m1) - MatrixType::Constant(rows, cols, s2));
+  m3 = m1;
+  m3.array() += s2;
+  VERIFY_IS_APPROX(m3, (m1.array() + s2).matrix());
+  m3 = m1;
+  m3.array() -= s1;
+  VERIFY_IS_APPROX(m3, (m1.array() - s1).matrix());
+
+  // reductions
+  VERIFY_IS_MUCH_SMALLER_THAN(m1.colwise().sum().sum() - m1.sum(), m1.squaredNorm());
+  VERIFY_IS_MUCH_SMALLER_THAN(m1.rowwise().sum().sum() - m1.sum(), m1.squaredNorm());
+  VERIFY_IS_MUCH_SMALLER_THAN(m1.colwise().sum() + m2.colwise().sum() - (m1 + m2).colwise().sum(),
+                              (m1 + m2).squaredNorm());
+  VERIFY_IS_MUCH_SMALLER_THAN(m1.rowwise().sum() - m2.rowwise().sum() - (m1 - m2).rowwise().sum(),
+                              (m1 - m2).squaredNorm());
+  VERIFY_IS_APPROX(m1.colwise().sum(), m1.colwise().redux(internal::scalar_sum_op<Scalar, Scalar>()));
+
+  // vector-wise ops
+  m3 = m1;
+  VERIFY_IS_APPROX(m3.colwise() += cv1, m1.colwise() + cv1);
+  m3 = m1;
+  VERIFY_IS_APPROX(m3.colwise() -= cv1, m1.colwise() - cv1);
+  m3 = m1;
+  VERIFY_IS_APPROX(m3.rowwise() += rv1, m1.rowwise() + rv1);
+  m3 = m1;
+  VERIFY_IS_APPROX(m3.rowwise() -= rv1, m1.rowwise() - rv1);
+
+  // empty objects
+  VERIFY_IS_EQUAL((m1.template block<0, Dynamic>(0, 0, 0, cols).colwise().sum()), RowVectorType::Zero(cols));
+  VERIFY_IS_EQUAL((m1.template block<Dynamic, 0>(0, 0, rows, 0).rowwise().sum()), ColVectorType::Zero(rows));
+  VERIFY_IS_EQUAL((m1.template block<0, Dynamic>(0, 0, 0, cols).colwise().prod()), RowVectorType::Ones(cols));
+  VERIFY_IS_EQUAL((m1.template block<Dynamic, 0>(0, 0, rows, 0).rowwise().prod()), ColVectorType::Ones(rows));
+
+  VERIFY_IS_EQUAL(m1.block(0, 0, 0, cols).colwise().sum(), RowVectorType::Zero(cols));
+  VERIFY_IS_EQUAL(m1.block(0, 0, rows, 0).rowwise().sum(), ColVectorType::Zero(rows));
+  VERIFY_IS_EQUAL(m1.block(0, 0, 0, cols).colwise().prod(), RowVectorType::Ones(cols));
+  VERIFY_IS_EQUAL(m1.block(0, 0, rows, 0).rowwise().prod(), ColVectorType::Ones(rows));
+
+  // verify the const accessors exist
+  const Scalar& ref_m1 = m.matrix().array().coeffRef(0);
+  const Scalar& ref_m2 = m.matrix().array().coeffRef(0, 0);
+  const Scalar& ref_a1 = m.array().matrix().coeffRef(0);
+  const Scalar& ref_a2 = m.array().matrix().coeffRef(0, 0);
+  VERIFY(&ref_a1 == &ref_m1);
+  VERIFY(&ref_a2 == &ref_m2);
+
+  // Check write accessors:
+  m1.array().coeffRef(0, 0) = 1;
+  VERIFY_IS_APPROX(m1(0, 0), Scalar(1));
+  m1.array()(0, 0) = 2;
+  VERIFY_IS_APPROX(m1(0, 0), Scalar(2));
+  m1.array().matrix().coeffRef(0, 0) = 3;
+  VERIFY_IS_APPROX(m1(0, 0), Scalar(3));
+  m1.array().matrix()(0, 0) = 4;
+  VERIFY_IS_APPROX(m1(0, 0), Scalar(4));
+}
+
+template <typename MatrixType>
+void comparisons(const MatrixType& m) {
+  using std::abs;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  Index r = internal::random<Index>(0, rows - 1), c = internal::random<Index>(0, cols - 1);
+
+  MatrixType m1 = MatrixType::Random(rows, cols), m2 = MatrixType::Random(rows, cols), m3(rows, cols);
+
+  VERIFY(((m1.array() + Scalar(1)) > m1.array()).all());
+  VERIFY(((m1.array() - Scalar(1)) < m1.array()).all());
+  if (rows * cols > 1) {
+    m3 = m1;
+    m3(r, c) += 1;
+    VERIFY(!(m1.array() < m3.array()).all());
+    VERIFY(!(m1.array() > m3.array()).all());
+  }
+
+  // comparisons to scalar
+  VERIFY((m1.array() != (m1(r, c) + 1)).any());
+  VERIFY((m1.array() > (m1(r, c) - 1)).any());
+  VERIFY((m1.array() < (m1(r, c) + 1)).any());
+  VERIFY((m1.array() == m1(r, c)).any());
+  VERIFY(m1.cwiseEqual(m1(r, c)).any());
+
+  // test select
+  VERIFY_IS_APPROX((m1.array() < m2.array()).select(m1, m2), m1.cwiseMin(m2));
+  VERIFY_IS_APPROX((m1.array() > m2.array()).select(m1, m2), m1.cwiseMax(m2));
+  Scalar mid = m1.cwiseAbs().minCoeff() / Scalar(2) + m1.cwiseAbs().maxCoeff() / Scalar(2);
+  for (int j = 0; j < cols; ++j)
+    for (int i = 0; i < rows; ++i) m3(i, j) = abs(m1(i, j)) < mid ? 0 : m1(i, j);
+  VERIFY_IS_APPROX(
+      (m1.array().abs() < MatrixType::Constant(rows, cols, mid).array()).select(MatrixType::Zero(rows, cols), m1), m3);
+  // shorter versions:
+  VERIFY_IS_APPROX((m1.array().abs() < MatrixType::Constant(rows, cols, mid).array()).select(0, m1), m3);
+  VERIFY_IS_APPROX((m1.array().abs() >= MatrixType::Constant(rows, cols, mid).array()).select(m1, 0), m3);
+  // even shorter version:
+  VERIFY_IS_APPROX((m1.array().abs() < mid).select(0, m1), m3);
+
+  // count
+  VERIFY(((m1.array().abs() + 1) > RealScalar(0.1)).count() == rows * cols);
+
+  // and/or
+  VERIFY(((m1.array() < RealScalar(0)).matrix() && (m1.array() > RealScalar(0)).matrix()).count() == 0);
+  VERIFY(((m1.array() < RealScalar(0)).matrix() || (m1.array() >= RealScalar(0)).matrix()).count() == rows * cols);
+  VERIFY(((m1.array() < -mid).matrix() || (m1.array() > mid).matrix()).count() ==
+         (m1.cwiseAbs().array() > mid).count());
+
+  typedef Matrix<Index, Dynamic, 1> VectorOfIndices;
+
+  // TODO allows colwise/rowwise for array
+  VERIFY_IS_APPROX(((m1.array().abs() + 1) > RealScalar(0.1)).matrix().colwise().count(),
+                   VectorOfIndices::Constant(cols, rows).transpose());
+  VERIFY_IS_APPROX(((m1.array().abs() + 1) > RealScalar(0.1)).matrix().rowwise().count(),
+                   VectorOfIndices::Constant(rows, cols));
+}
+
+template <typename VectorType>
+void lpNorm(const VectorType& v) {
+  using std::sqrt;
+  typedef typename VectorType::RealScalar RealScalar;
+  VectorType u = VectorType::Random(v.size());
+
+  if (v.size() == 0) {
+    VERIFY_IS_APPROX(u.template lpNorm<Infinity>(), RealScalar(0));
+    VERIFY_IS_APPROX(u.template lpNorm<1>(), RealScalar(0));
+    VERIFY_IS_APPROX(u.template lpNorm<2>(), RealScalar(0));
+    VERIFY_IS_APPROX(u.template lpNorm<5>(), RealScalar(0));
+  } else {
+    VERIFY_IS_APPROX(u.template lpNorm<Infinity>(), u.cwiseAbs().maxCoeff());
+  }
+
+  VERIFY_IS_APPROX(u.template lpNorm<1>(), u.cwiseAbs().sum());
+  VERIFY_IS_APPROX(u.template lpNorm<2>(), sqrt(u.array().abs().square().sum()));
+  VERIFY_IS_APPROX(numext::pow(u.template lpNorm<5>(), typename VectorType::RealScalar(5)),
+                   u.array().abs().pow(5).sum());
+}
+
+template <typename MatrixType>
+void cwise_min_max(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  MatrixType m1 = MatrixType::Random(rows, cols);
+
+  // min/max with array
+  Scalar maxM1 = m1.maxCoeff();
+  Scalar minM1 = m1.minCoeff();
+
+  VERIFY_IS_APPROX(MatrixType::Constant(rows, cols, minM1), m1.cwiseMin(MatrixType::Constant(rows, cols, minM1)));
+  VERIFY_IS_APPROX(m1, m1.cwiseMin(MatrixType::Constant(rows, cols, maxM1)));
+
+  VERIFY_IS_APPROX(MatrixType::Constant(rows, cols, maxM1), m1.cwiseMax(MatrixType::Constant(rows, cols, maxM1)));
+  VERIFY_IS_APPROX(m1, m1.cwiseMax(MatrixType::Constant(rows, cols, minM1)));
+
+  // min/max with scalar input
+  VERIFY_IS_APPROX(MatrixType::Constant(rows, cols, minM1), m1.cwiseMin(minM1));
+  VERIFY_IS_APPROX(m1, m1.cwiseMin(maxM1));
+  VERIFY_IS_APPROX(-m1, (-m1).cwiseMin(-minM1));
+  VERIFY_IS_APPROX(-m1.array(), ((-m1).array().min)(-minM1));
+
+  VERIFY_IS_APPROX(MatrixType::Constant(rows, cols, maxM1), m1.cwiseMax(maxM1));
+  VERIFY_IS_APPROX(m1, m1.cwiseMax(minM1));
+  VERIFY_IS_APPROX(-m1, (-m1).cwiseMax(-maxM1));
+  VERIFY_IS_APPROX(-m1.array(), ((-m1).array().max)(-maxM1));
+
+  VERIFY_IS_APPROX(MatrixType::Constant(rows, cols, minM1).array(), (m1.array().min)(minM1));
+  VERIFY_IS_APPROX(m1.array(), (m1.array().min)(maxM1));
+
+  VERIFY_IS_APPROX(MatrixType::Constant(rows, cols, maxM1).array(), (m1.array().max)(maxM1));
+  VERIFY_IS_APPROX(m1.array(), (m1.array().max)(minM1));
+
+  // Test NaN propagation for min/max.
+  if (!NumTraits<Scalar>::IsInteger) {
+    m1(0, 0) = NumTraits<Scalar>::quiet_NaN();
+    // Elementwise.
+    VERIFY((numext::isnan)(m1.template cwiseMax<PropagateNaN>(MatrixType::Constant(rows, cols, Scalar(1)))(0, 0)));
+    VERIFY((numext::isnan)(m1.template cwiseMin<PropagateNaN>(MatrixType::Constant(rows, cols, Scalar(1)))(0, 0)));
+    VERIFY(!(numext::isnan)(m1.template cwiseMax<PropagateNumbers>(MatrixType::Constant(rows, cols, Scalar(1)))(0, 0)));
+    VERIFY(!(numext::isnan)(m1.template cwiseMin<PropagateNumbers>(MatrixType::Constant(rows, cols, Scalar(1)))(0, 0)));
+    VERIFY((numext::isnan)(m1.template cwiseMax<PropagateNaN>(Scalar(1))(0, 0)));
+    VERIFY((numext::isnan)(m1.template cwiseMin<PropagateNaN>(Scalar(1))(0, 0)));
+    VERIFY(!(numext::isnan)(m1.template cwiseMax<PropagateNumbers>(Scalar(1))(0, 0)));
+    VERIFY(!(numext::isnan)(m1.template cwiseMin<PropagateNumbers>(Scalar(1))(0, 0)));
+
+    VERIFY((numext::isnan)(
+        m1.array().template max<PropagateNaN>(MatrixType::Constant(rows, cols, Scalar(1)).array())(0, 0)));
+    VERIFY((numext::isnan)(
+        m1.array().template min<PropagateNaN>(MatrixType::Constant(rows, cols, Scalar(1)).array())(0, 0)));
+    VERIFY(!(numext::isnan)(
+        m1.array().template max<PropagateNumbers>(MatrixType::Constant(rows, cols, Scalar(1)).array())(0, 0)));
+    VERIFY(!(numext::isnan)(
+        m1.array().template min<PropagateNumbers>(MatrixType::Constant(rows, cols, Scalar(1)).array())(0, 0)));
+    VERIFY((numext::isnan)(m1.array().template max<PropagateNaN>(Scalar(1))(0, 0)));
+    VERIFY((numext::isnan)(m1.array().template min<PropagateNaN>(Scalar(1))(0, 0)));
+    VERIFY(!(numext::isnan)(m1.array().template max<PropagateNumbers>(Scalar(1))(0, 0)));
+    VERIFY(!(numext::isnan)(m1.array().template min<PropagateNumbers>(Scalar(1))(0, 0)));
+
+    // Reductions.
+    VERIFY((numext::isnan)(m1.template maxCoeff<PropagateNaN>()));
+    VERIFY((numext::isnan)(m1.template minCoeff<PropagateNaN>()));
+    if (m1.size() > 1) {
+      VERIFY(!(numext::isnan)(m1.template maxCoeff<PropagateNumbers>()));
+      VERIFY(!(numext::isnan)(m1.template minCoeff<PropagateNumbers>()));
+    } else {
+      VERIFY((numext::isnan)(m1.template maxCoeff<PropagateNumbers>()));
+      VERIFY((numext::isnan)(m1.template minCoeff<PropagateNumbers>()));
+    }
+  }
+}
+
+template <typename MatrixTraits>
+void resize(const MatrixTraits& t) {
+  typedef typename MatrixTraits::Scalar Scalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+  typedef Array<Scalar, Dynamic, Dynamic> Array2DType;
+  typedef Matrix<Scalar, Dynamic, 1> VectorType;
+  typedef Array<Scalar, Dynamic, 1> Array1DType;
+
+  Index rows = t.rows(), cols = t.cols();
+
+  MatrixType m(rows, cols);
+  VectorType v(rows);
+  Array2DType a2(rows, cols);
+  Array1DType a1(rows);
+
+  m.array().resize(rows + 1, cols + 1);
+  VERIFY(m.rows() == rows + 1 && m.cols() == cols + 1);
+  a2.matrix().resize(rows + 1, cols + 1);
+  VERIFY(a2.rows() == rows + 1 && a2.cols() == cols + 1);
+  v.array().resize(cols);
+  VERIFY(v.size() == cols);
+  a1.matrix().resize(cols);
+  VERIFY(a1.size() == cols);
+}
+
+template <int>
+void regression_bug_654() {
+  ArrayXf a = RowVectorXf(3);
+  VectorXf v = Array<float, 1, Dynamic>(3);
+}
+
+// Check propagation of LvalueBit through Array/Matrix-Wrapper
+template <int>
+void regrrssion_bug_1410() {
+  const Matrix4i M;
+  const Array4i A;
+  ArrayWrapper<const Matrix4i> MA = M.array();
+  MA.row(0);
+  MatrixWrapper<const Array4i> AM = A.matrix();
+  AM.row(0);
+
+  VERIFY((internal::traits<ArrayWrapper<const Matrix4i> >::Flags & LvalueBit) == 0);
+  VERIFY((internal::traits<MatrixWrapper<const Array4i> >::Flags & LvalueBit) == 0);
+
+  VERIFY((internal::traits<ArrayWrapper<Matrix4i> >::Flags & LvalueBit) == LvalueBit);
+  VERIFY((internal::traits<MatrixWrapper<Array4i> >::Flags & LvalueBit) == LvalueBit);
+}
+
+EIGEN_DECLARE_TEST(array_for_matrix) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(array_for_matrix(Matrix<float, 1, 1>()));
+    CALL_SUBTEST_2(array_for_matrix(Matrix2f()));
+    CALL_SUBTEST_3(array_for_matrix(Matrix4d()));
+    CALL_SUBTEST_4(array_for_matrix(
+        MatrixXcf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_5(array_for_matrix(
+        MatrixXf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_6(array_for_matrix(
+        MatrixXi(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+  }
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(comparisons(Matrix<float, 1, 1>()));
+    CALL_SUBTEST_2(comparisons(Matrix2f()));
+    CALL_SUBTEST_3(comparisons(Matrix4d()));
+    CALL_SUBTEST_5(comparisons(
+        MatrixXf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_6(comparisons(
+        MatrixXi(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+  }
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(cwise_min_max(Matrix<float, 1, 1>()));
+    CALL_SUBTEST_2(cwise_min_max(Matrix2f()));
+    CALL_SUBTEST_3(cwise_min_max(Matrix4d()));
+    CALL_SUBTEST_5(cwise_min_max(
+        MatrixXf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_6(cwise_min_max(
+        MatrixXi(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+  }
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(lpNorm(Matrix<float, 1, 1>()));
+    CALL_SUBTEST_2(lpNorm(Vector2f()));
+    CALL_SUBTEST_7(lpNorm(Vector3d()));
+    CALL_SUBTEST_8(lpNorm(Vector4f()));
+    CALL_SUBTEST_5(lpNorm(VectorXf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_4(lpNorm(VectorXcf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+  }
+  CALL_SUBTEST_5(lpNorm(VectorXf(0)));
+  CALL_SUBTEST_4(lpNorm(VectorXcf(0)));
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_4(resize(
+        MatrixXcf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_5(
+        resize(MatrixXf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_6(
+        resize(MatrixXi(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+  }
+  CALL_SUBTEST_6(regression_bug_654<0>());
+  CALL_SUBTEST_6(regrrssion_bug_1410<0>());
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/array_of_string.cpp

@@ -0,0 +1,31 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 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/.
+
+#include "main.h"
+
+EIGEN_DECLARE_TEST(array_of_string) {
+  typedef Array<std::string, 1, Dynamic> ArrayXs;
+  ArrayXs a1(3), a2(3), a3(3), a3ref(3);
+  a1 << "one", "two", "three";
+  a2 << "1", "2", "3";
+  a3ref << "one (1)", "two (2)", "three (3)";
+  std::stringstream s1;
+  s1 << a1;
+  VERIFY_IS_EQUAL(s1.str(), std::string("  one    two  three"));
+  a3 = a1 + std::string(" (") + a2 + std::string(")");
+  VERIFY((a3 == a3ref).all());
+
+  a3 = a1;
+  a3 += std::string(" (") + a2 + std::string(")");
+  VERIFY((a3 == a3ref).all());
+
+  a1.swap(a3);
+  VERIFY((a1 == a3ref).all());
+  VERIFY((a3 != a3ref).all());
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/array_replicate.cpp

@@ -0,0 +1,73 @@
+// 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/.
+
+#include "main.h"
+
+template <typename MatrixType>
+void replicate(const MatrixType& m) {
+  /* this test covers the following files:
+     Replicate.cpp
+  */
+  typedef typename MatrixType::Scalar Scalar;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
+  typedef Matrix<Scalar, Dynamic, 1> VectorX;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  MatrixType m1 = MatrixType::Random(rows, cols), m2 = MatrixType::Random(rows, cols);
+
+  VectorType v1 = VectorType::Random(rows);
+
+  MatrixX x1, x2;
+  VectorX vx1;
+
+  int f1 = internal::random<int>(1, 10), f2 = internal::random<int>(1, 10);
+
+  x1.resize(rows * f1, cols * f2);
+  for (int j = 0; j < f2; j++)
+    for (int i = 0; i < f1; i++) x1.block(i * rows, j * cols, rows, cols) = m1;
+  VERIFY_IS_APPROX(x1, m1.replicate(f1, f2));
+
+  x2.resize(2 * rows, 3 * cols);
+  x2 << m2, m2, m2, m2, m2, m2;
+  VERIFY_IS_APPROX(x2, (m2.template replicate<2, 3>()));
+
+  x2.resize(rows, 3 * cols);
+  x2 << m2, m2, m2;
+  VERIFY_IS_APPROX(x2, (m2.template replicate<1, 3>()));
+
+  vx1.resize(3 * rows, cols);
+  vx1 << m2, m2, m2;
+  VERIFY_IS_APPROX(vx1 + vx1, vx1 + (m2.template replicate<3, 1>()));
+
+  vx1 = m2 + (m2.colwise().replicate(1));
+
+  if (m2.cols() == 1) VERIFY_IS_APPROX(m2.coeff(0), (m2.template replicate<3, 1>().coeff(m2.rows())));
+
+  x2.resize(rows, f1);
+  for (int j = 0; j < f1; ++j) x2.col(j) = v1;
+  VERIFY_IS_APPROX(x2, v1.rowwise().replicate(f1));
+
+  vx1.resize(rows * f2);
+  for (int j = 0; j < f2; ++j) vx1.segment(j * rows, rows) = v1;
+  VERIFY_IS_APPROX(vx1, v1.colwise().replicate(f2));
+}
+
+EIGEN_DECLARE_TEST(array_replicate) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(replicate(Matrix<float, 1, 1>()));
+    CALL_SUBTEST_2(replicate(Vector2f()));
+    CALL_SUBTEST_3(replicate(Vector3d()));
+    CALL_SUBTEST_4(replicate(Vector4f()));
+    CALL_SUBTEST_5(replicate(VectorXf(16)));
+    CALL_SUBTEST_6(replicate(VectorXcd(10)));
+  }
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/array_reverse.cpp

@@ -0,0 +1,199 @@
+// 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>
+// Copyright (C) 2009 Ricard Marxer <email@ricardmarxer.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 <iostream>
+
+using namespace std;
+
+template <typename MatrixType>
+void reverse(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
+
+  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;
+  VectorType v1 = VectorType::Random(rows);
+
+  MatrixType m1_r = m1.reverse();
+  // Verify that MatrixBase::reverse() works
+  for (int i = 0; i < rows; i++) {
+    for (int j = 0; j < cols; j++) {
+      VERIFY_IS_APPROX(m1_r(i, j), m1(rows - 1 - i, cols - 1 - j));
+    }
+  }
+
+  Reverse<MatrixType> m1_rd(m1);
+  // Verify that a Reverse default (in both directions) of an expression works
+  for (int i = 0; i < rows; i++) {
+    for (int j = 0; j < cols; j++) {
+      VERIFY_IS_APPROX(m1_rd(i, j), m1(rows - 1 - i, cols - 1 - j));
+    }
+  }
+
+  Reverse<MatrixType, BothDirections> m1_rb(m1);
+  // Verify that a Reverse in both directions of an expression works
+  for (int i = 0; i < rows; i++) {
+    for (int j = 0; j < cols; j++) {
+      VERIFY_IS_APPROX(m1_rb(i, j), m1(rows - 1 - i, cols - 1 - j));
+    }
+  }
+
+  Reverse<MatrixType, Vertical> m1_rv(m1);
+  // Verify that a Reverse in the vertical directions of an expression works
+  for (int i = 0; i < rows; i++) {
+    for (int j = 0; j < cols; j++) {
+      VERIFY_IS_APPROX(m1_rv(i, j), m1(rows - 1 - i, j));
+    }
+  }
+
+  Reverse<MatrixType, Horizontal> m1_rh(m1);
+  // Verify that a Reverse in the horizontal directions of an expression works
+  for (int i = 0; i < rows; i++) {
+    for (int j = 0; j < cols; j++) {
+      VERIFY_IS_APPROX(m1_rh(i, j), m1(i, cols - 1 - j));
+    }
+  }
+
+  VectorType v1_r = v1.reverse();
+  // Verify that a VectorType::reverse() of an expression works
+  for (int i = 0; i < rows; i++) {
+    VERIFY_IS_APPROX(v1_r(i), v1(rows - 1 - i));
+  }
+
+  MatrixType m1_cr = m1.colwise().reverse();
+  // Verify that PartialRedux::reverse() works (for colwise())
+  for (int i = 0; i < rows; i++) {
+    for (int j = 0; j < cols; j++) {
+      VERIFY_IS_APPROX(m1_cr(i, j), m1(rows - 1 - i, j));
+    }
+  }
+
+  MatrixType m1_rr = m1.rowwise().reverse();
+  // Verify that PartialRedux::reverse() works (for rowwise())
+  for (int i = 0; i < rows; i++) {
+    for (int j = 0; j < cols; j++) {
+      VERIFY_IS_APPROX(m1_rr(i, j), m1(i, cols - 1 - j));
+    }
+  }
+
+  Scalar x = internal::random<Scalar>();
+
+  Index r = internal::random<Index>(0, rows - 1), c = internal::random<Index>(0, cols - 1);
+
+  m1.reverse()(r, c) = x;
+  VERIFY_IS_APPROX(x, m1(rows - 1 - r, cols - 1 - c));
+
+  m2 = m1;
+  m2.reverseInPlace();
+  VERIFY_IS_APPROX(m2, m1.reverse().eval());
+
+  m2 = m1;
+  m2.col(0).reverseInPlace();
+  VERIFY_IS_APPROX(m2.col(0), m1.col(0).reverse().eval());
+
+  m2 = m1;
+  m2.row(0).reverseInPlace();
+  VERIFY_IS_APPROX(m2.row(0), m1.row(0).reverse().eval());
+
+  m2 = m1;
+  m2.rowwise().reverseInPlace();
+  VERIFY_IS_APPROX(m2, m1.rowwise().reverse().eval());
+
+  m2 = m1;
+  m2.colwise().reverseInPlace();
+  VERIFY_IS_APPROX(m2, m1.colwise().reverse().eval());
+
+  m1.colwise().reverse()(r, c) = x;
+  VERIFY_IS_APPROX(x, m1(rows - 1 - r, c));
+
+  m1.rowwise().reverse()(r, c) = x;
+  VERIFY_IS_APPROX(x, m1(r, cols - 1 - c));
+}
+
+template <int>
+void array_reverse_extra() {
+  Vector4f x;
+  x << 1, 2, 3, 4;
+  Vector4f y;
+  y << 4, 3, 2, 1;
+  VERIFY(x.reverse()[1] == 3);
+  VERIFY(x.reverse() == y);
+}
+
+// Simpler version of reverseInPlace leveraging a bug
+// in clang 6/7 with -O2 and AVX or AVX512 enabled.
+// This simpler version ensure that the clang bug is not simply hidden
+// through mis-inlining of reverseInPlace or other minor changes.
+template <typename MatrixType>
+EIGEN_DONT_INLINE void bug1684_job1(MatrixType& m1, MatrixType& m2) {
+  m2 = m1;
+  m2.col(0).swap(m2.col(3));
+  m2.col(1).swap(m2.col(2));
+}
+
+template <typename MatrixType>
+EIGEN_DONT_INLINE void bug1684_job2(MatrixType& m1, MatrixType& m2) {
+  m2 = m1;                // load m1/m2 in AVX registers
+  m1.col(0) = m2.col(3);  // perform 128 bits moves
+  m1.col(1) = m2.col(2);
+  m1.col(2) = m2.col(1);
+  m1.col(3) = m2.col(0);
+}
+
+template <typename MatrixType>
+EIGEN_DONT_INLINE void bug1684_job3(MatrixType& m1, MatrixType& m2) {
+  m2 = m1;
+  Vector4f tmp;
+  tmp = m2.col(0);
+  m2.col(0) = m2.col(3);
+  m2.col(3) = tmp;
+  tmp = m2.col(1);
+  m2.col(1) = m2.col(2);
+  m2.col(2) = tmp;
+}
+
+template <int>
+void bug1684() {
+  Matrix4f m1 = Matrix4f::Random();
+  Matrix4f m2 = Matrix4f::Random();
+  bug1684_job1(m1, m2);
+  VERIFY_IS_APPROX(m2, m1.rowwise().reverse().eval());
+  bug1684_job2(m1, m2);
+  VERIFY_IS_APPROX(m2, m1.rowwise().reverse().eval());
+  // This one still fail after our swap's workaround,
+  // but I expect users not to implement their own swap.
+  // bug1684_job3(m1,m2);
+  // VERIFY_IS_APPROX(m2, m1.rowwise().reverse().eval());
+}
+
+EIGEN_DECLARE_TEST(array_reverse) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(reverse(Matrix<float, 1, 1>()));
+    CALL_SUBTEST_2(reverse(Matrix2f()));
+    CALL_SUBTEST_3(reverse(Matrix4f()));
+    CALL_SUBTEST_4(reverse(Matrix4d()));
+    CALL_SUBTEST_5(reverse(
+        MatrixXcf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_6(reverse(
+        MatrixXi(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_7(reverse(
+        MatrixXcd(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_8(reverse(Matrix<float, 100, 100>()));
+    CALL_SUBTEST_9(reverse(Matrix<float, Dynamic, Dynamic, RowMajor>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
+                                                                     internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_3(bug1684<0>());
+  }
+  CALL_SUBTEST_3(array_reverse_extra<0>());
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/assignment_threaded.cpp

@@ -0,0 +1,84 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2023 Charlie Schlosser <cs.schlosser@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/.
+
+#define EIGEN_USE_THREADS 1
+
+#include "main.h"
+#include <Eigen/ThreadPool>
+
+namespace Eigen {
+namespace internal {
+// conveniently control vectorization logic
+template <typename Scalar, bool Vectorize>
+struct scalar_dummy_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a) const { return a; }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const {
+    return a;
+  }
+};
+template <typename Scalar, bool Vectorize>
+struct functor_traits<scalar_dummy_op<Scalar, Vectorize> > {
+  enum { Cost = 1'000'000, PacketAccess = Vectorize && packet_traits<Scalar>::Vectorizable };
+};
+}  // namespace internal
+}  // namespace Eigen
+
+template <typename PlainObject>
+void test_threaded_assignment(const PlainObject&, Index rows = PlainObject::RowsAtCompileTime,
+                              Index cols = PlainObject::ColsAtCompileTime) {
+  using Scalar = typename PlainObject::Scalar;
+  using VectorizationOff = internal::scalar_dummy_op<Scalar, false>;
+  using VectorizationOn = internal::scalar_dummy_op<Scalar, true>;
+
+  int threads = 4;
+  ThreadPool pool(threads);
+  CoreThreadPoolDevice threadPoolDevice(pool);
+
+  PlainObject dst(rows, cols), ref(rows, cols), rhs(rows, cols);
+  rhs.setRandom();
+  const auto rhs_xpr = rhs.cwiseAbs2();
+
+  // linear access
+  dst.setRandom();
+  ref.setRandom();
+  ref = rhs_xpr.unaryExpr(VectorizationOff());
+  dst.device(threadPoolDevice) = rhs_xpr.unaryExpr(VectorizationOff());
+  VERIFY_IS_CWISE_EQUAL(ref, dst);
+
+  ref = rhs_xpr.unaryExpr(VectorizationOn());
+  dst.device(threadPoolDevice) = rhs_xpr.unaryExpr(VectorizationOn());
+  VERIFY_IS_CWISE_EQUAL(ref, dst);
+
+  // outer-inner access
+  Index blockRows = numext::maxi(Index(1), rows - 1);
+  Index blockCols = numext::maxi(Index(1), cols - 1);
+  dst.setRandom();
+  ref.setRandom();
+  ref.bottomRightCorner(blockRows, blockCols) =
+      rhs_xpr.bottomRightCorner(blockRows, blockCols).unaryExpr(VectorizationOff());
+  dst.bottomRightCorner(blockRows, blockCols).device(threadPoolDevice) =
+      rhs_xpr.bottomRightCorner(blockRows, blockCols).unaryExpr(VectorizationOff());
+  VERIFY_IS_CWISE_EQUAL(ref.bottomRightCorner(blockRows, blockCols), dst.bottomRightCorner(blockRows, blockCols));
+
+  ref.setZero();
+  dst.setZero();
+  ref.bottomRightCorner(blockRows, blockCols) =
+      rhs_xpr.bottomRightCorner(blockRows, blockCols).unaryExpr(VectorizationOn());
+  dst.bottomRightCorner(blockRows, blockCols).device(threadPoolDevice) =
+      rhs_xpr.bottomRightCorner(blockRows, blockCols).unaryExpr(VectorizationOn());
+  VERIFY_IS_CWISE_EQUAL(ref.bottomRightCorner(blockRows, blockCols), dst.bottomRightCorner(blockRows, blockCols));
+}
+
+EIGEN_DECLARE_TEST(test) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST(test_threaded_assignment(MatrixXd(), 123, 123));
+    CALL_SUBTEST(test_threaded_assignment(Matrix<float, 16, 16>()));
+  }
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/bandmatrix.cpp

@@ -0,0 +1,66 @@
+// This file is triangularView of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include "main.h"
+
+template <typename MatrixType>
+void bandmatrix(const MatrixType& _m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic> DenseMatrixType;
+
+  Index rows = _m.rows();
+  Index cols = _m.cols();
+  Index supers = _m.supers();
+  Index subs = _m.subs();
+
+  MatrixType m(rows, cols, supers, subs);
+
+  DenseMatrixType dm1(rows, cols);
+  dm1.setZero();
+
+  m.diagonal().setConstant(123);
+  dm1.diagonal().setConstant(123);
+  for (int i = 1; i <= m.supers(); ++i) {
+    m.diagonal(i).setConstant(static_cast<RealScalar>(i));
+    dm1.diagonal(i).setConstant(static_cast<RealScalar>(i));
+  }
+  for (int i = 1; i <= m.subs(); ++i) {
+    m.diagonal(-i).setConstant(-static_cast<RealScalar>(i));
+    dm1.diagonal(-i).setConstant(-static_cast<RealScalar>(i));
+  }
+  // std::cerr << m.m_data << "\n\n" << m.toDense() << "\n\n" << dm1 << "\n\n\n\n";
+  VERIFY_IS_APPROX(dm1, m.toDenseMatrix());
+
+  for (int i = 0; i < cols; ++i) {
+    m.col(i).setConstant(static_cast<RealScalar>(i + 1));
+    dm1.col(i).setConstant(static_cast<RealScalar>(i + 1));
+  }
+  Index d = (std::min)(rows, cols);
+  Index a = std::max<Index>(0, cols - d - supers);
+  Index b = std::max<Index>(0, rows - d - subs);
+  if (a > 0) dm1.block(0, d + supers, rows, a).setZero();
+  dm1.block(0, supers + 1, cols - supers - 1 - a, cols - supers - 1 - a).template triangularView<Upper>().setZero();
+  dm1.block(subs + 1, 0, rows - subs - 1 - b, rows - subs - 1 - b).template triangularView<Lower>().setZero();
+  if (b > 0) dm1.block(d + subs, 0, b, cols).setZero();
+  // std::cerr << m.m_data << "\n\n" << m.toDense() << "\n\n" << dm1 << "\n\n";
+  VERIFY_IS_APPROX(dm1, m.toDenseMatrix());
+}
+
+using Eigen::internal::BandMatrix;
+
+EIGEN_DECLARE_TEST(bandmatrix) {
+  for (int i = 0; i < 10 * g_repeat; i++) {
+    Index rows = internal::random<Index>(1, 10);
+    Index cols = internal::random<Index>(1, 10);
+    Index sups = internal::random<Index>(0, cols - 1);
+    Index subs = internal::random<Index>(0, rows - 1);
+    CALL_SUBTEST(bandmatrix(BandMatrix<float>(rows, cols, sups, subs)));
+  }
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/basicstuff.cpp

@@ -0,0 +1,352 @@
+// 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 "random_without_cast_overflow.h"
+
+template <typename MatrixType>
+std::enable_if_t<(MatrixType::RowsAtCompileTime == 1 || MatrixType::ColsAtCompileTime == 1), void> check_index(
+    const MatrixType& m) {
+  VERIFY_RAISES_ASSERT(m[0]);
+  VERIFY_RAISES_ASSERT((m + m)[0]);
+}
+
+template <typename MatrixType>
+std::enable_if_t<!(MatrixType::RowsAtCompileTime == 1 || MatrixType::ColsAtCompileTime == 1), void> check_index(
+    const MatrixType& /*unused*/) {}
+
+template <typename MatrixType>
+void basicStuff(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> SquareMatrixType;
+
+  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),
+             mzero = MatrixType::Zero(rows, cols),
+             square = Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime>::Random(rows, rows);
+  VectorType v1 = VectorType::Random(rows), vzero = VectorType::Zero(rows);
+  SquareMatrixType sm1 = SquareMatrixType::Random(rows, rows), sm2(rows, rows);
+
+  Scalar x = 0;
+  while (x == Scalar(0)) x = internal::random<Scalar>();
+
+  Index r = internal::random<Index>(0, rows - 1), c = internal::random<Index>(0, cols - 1);
+
+  m1.coeffRef(r, c) = x;
+  VERIFY_IS_APPROX(x, m1.coeff(r, c));
+  m1(r, c) = x;
+  VERIFY_IS_APPROX(x, m1(r, c));
+  v1.coeffRef(r) = x;
+  VERIFY_IS_APPROX(x, v1.coeff(r));
+  v1(r) = x;
+  VERIFY_IS_APPROX(x, v1(r));
+  v1[r] = x;
+  VERIFY_IS_APPROX(x, v1[r]);
+
+  // test fetching with various index types.
+  Index r1 = internal::random<Index>(0, numext::mini(Index(127), rows - 1));
+  x = v1(static_cast<char>(r1));
+  x = v1(static_cast<signed char>(r1));
+  x = v1(static_cast<unsigned char>(r1));
+  x = v1(static_cast<signed short>(r1));
+  x = v1(static_cast<unsigned short>(r1));
+  x = v1(static_cast<signed int>(r1));
+  x = v1(static_cast<unsigned int>(r1));
+  x = v1(static_cast<signed long>(r1));
+  x = v1(static_cast<unsigned long>(r1));
+  if (sizeof(Index) >= sizeof(long long int)) x = v1(static_cast<long long int>(r1));
+  if (sizeof(Index) >= sizeof(unsigned long long int)) x = v1(static_cast<unsigned long long int>(r1));
+
+  VERIFY_IS_APPROX(v1, v1);
+  VERIFY_IS_NOT_APPROX(v1, 2 * v1);
+  VERIFY_IS_MUCH_SMALLER_THAN(vzero, v1);
+  VERIFY_IS_MUCH_SMALLER_THAN(vzero, v1.squaredNorm());
+  VERIFY_IS_NOT_MUCH_SMALLER_THAN(v1, v1);
+  VERIFY_IS_APPROX(vzero, v1 - v1);
+  VERIFY_IS_APPROX(m1, m1);
+  VERIFY_IS_NOT_APPROX(m1, 2 * m1);
+  VERIFY_IS_MUCH_SMALLER_THAN(mzero, m1);
+  VERIFY_IS_NOT_MUCH_SMALLER_THAN(m1, m1);
+  VERIFY_IS_APPROX(mzero, m1 - m1);
+
+  // always test operator() on each read-only expression class,
+  // in order to check const-qualifiers.
+  // indeed, if an expression class (here Zero) is meant to be read-only,
+  // hence has no _write() method, the corresponding MatrixBase method (here zero())
+  // should return a const-qualified object so that it is the const-qualified
+  // operator() that gets called, which in turn calls _read().
+  VERIFY_IS_MUCH_SMALLER_THAN(MatrixType::Zero(rows, cols)(r, c), static_cast<Scalar>(1));
+
+  // now test copying a row-vector into a (column-)vector and conversely.
+  square.col(r) = square.row(r).eval();
+  Matrix<Scalar, 1, MatrixType::RowsAtCompileTime> rv(rows);
+  Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> cv(rows);
+  rv = square.row(r);
+  cv = square.col(r);
+
+  VERIFY_IS_APPROX(rv, cv.transpose());
+
+  if (cols != 1 && rows != 1 && MatrixType::SizeAtCompileTime != Dynamic) {
+    VERIFY_RAISES_ASSERT(m1 = (m2.block(0, 0, rows - 1, cols - 1)));
+  }
+
+  if (cols != 1 && rows != 1) {
+    check_index(m1);
+  }
+
+  VERIFY_IS_APPROX(m3 = m1, m1);
+  MatrixType m4;
+  VERIFY_IS_APPROX(m4 = m1, m1);
+
+  m3.real() = m1.real();
+  VERIFY_IS_APPROX(static_cast<const MatrixType&>(m3).real(), static_cast<const MatrixType&>(m1).real());
+  VERIFY_IS_APPROX(static_cast<const MatrixType&>(m3).real(), m1.real());
+
+  // check == / != operators
+  VERIFY(m1 == m1);
+  VERIFY(m1 != m2);
+  VERIFY(!(m1 == m2));
+  VERIFY(!(m1 != m1));
+  m1 = m2;
+  VERIFY(m1 == m2);
+  VERIFY(!(m1 != m2));
+
+  // check automatic transposition
+  sm2.setZero();
+  for (Index i = 0; i < rows; ++i) sm2.col(i) = sm1.row(i);
+  VERIFY_IS_APPROX(sm2, sm1.transpose());
+
+  sm2.setZero();
+  for (Index i = 0; i < rows; ++i) sm2.col(i).noalias() = sm1.row(i);
+  VERIFY_IS_APPROX(sm2, sm1.transpose());
+
+  sm2.setZero();
+  for (Index i = 0; i < rows; ++i) sm2.col(i).noalias() += sm1.row(i);
+  VERIFY_IS_APPROX(sm2, sm1.transpose());
+
+  sm2.setZero();
+  for (Index i = 0; i < rows; ++i) sm2.col(i).noalias() -= sm1.row(i);
+  VERIFY_IS_APPROX(sm2, -sm1.transpose());
+
+  // check ternary usage
+  {
+    bool b = internal::random<int>(0, 10) > 5;
+    m3 = b ? m1 : m2;
+    if (b)
+      VERIFY_IS_APPROX(m3, m1);
+    else
+      VERIFY_IS_APPROX(m3, m2);
+    m3 = b ? -m1 : m2;
+    if (b)
+      VERIFY_IS_APPROX(m3, -m1);
+    else
+      VERIFY_IS_APPROX(m3, m2);
+    m3 = b ? m1 : -m2;
+    if (b)
+      VERIFY_IS_APPROX(m3, m1);
+    else
+      VERIFY_IS_APPROX(m3, -m2);
+  }
+}
+
+template <typename MatrixType>
+void basicStuffComplex(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<RealScalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime> RealMatrixType;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  Scalar s1 = internal::random<Scalar>(), s2 = internal::random<Scalar>();
+
+  VERIFY(numext::real(s1) == numext::real_ref(s1));
+  VERIFY(numext::imag(s1) == numext::imag_ref(s1));
+  numext::real_ref(s1) = numext::real(s2);
+  numext::imag_ref(s1) = numext::imag(s2);
+  VERIFY(internal::isApprox(s1, s2, NumTraits<RealScalar>::epsilon()));
+  // extended precision in Intel FPUs means that s1 == s2 in the line above is not guaranteed.
+
+  RealMatrixType rm1 = RealMatrixType::Random(rows, cols), rm2 = RealMatrixType::Random(rows, cols);
+  MatrixType cm(rows, cols);
+  cm.real() = rm1;
+  cm.imag() = rm2;
+  VERIFY_IS_APPROX(static_cast<const MatrixType&>(cm).real(), rm1);
+  VERIFY_IS_APPROX(static_cast<const MatrixType&>(cm).imag(), rm2);
+  rm1.setZero();
+  rm2.setZero();
+  rm1 = cm.real();
+  rm2 = cm.imag();
+  VERIFY_IS_APPROX(static_cast<const MatrixType&>(cm).real(), rm1);
+  VERIFY_IS_APPROX(static_cast<const MatrixType&>(cm).imag(), rm2);
+  cm.real().setZero();
+  VERIFY(static_cast<const MatrixType&>(cm).real().isZero());
+  VERIFY(!static_cast<const MatrixType&>(cm).imag().isZero());
+}
+
+template <typename SrcScalar, typename TgtScalar>
+struct casting_test {
+  static void run() {
+    Matrix<SrcScalar, 4, 4> m;
+    for (int i = 0; i < m.rows(); ++i) {
+      for (int j = 0; j < m.cols(); ++j) {
+        m(i, j) = internal::random_without_cast_overflow<SrcScalar, TgtScalar>::value();
+      }
+    }
+    Matrix<TgtScalar, 4, 4> n = m.template cast<TgtScalar>();
+    for (int i = 0; i < m.rows(); ++i) {
+      for (int j = 0; j < m.cols(); ++j) {
+        VERIFY_IS_APPROX(n(i, j), (internal::cast<SrcScalar, TgtScalar>(m(i, j))));
+      }
+    }
+  }
+};
+
+template <typename SrcScalar, typename EnableIf = void>
+struct casting_test_runner {
+  static void run() {
+    casting_test<SrcScalar, bool>::run();
+    casting_test<SrcScalar, int8_t>::run();
+    casting_test<SrcScalar, uint8_t>::run();
+    casting_test<SrcScalar, int16_t>::run();
+    casting_test<SrcScalar, uint16_t>::run();
+    casting_test<SrcScalar, int32_t>::run();
+    casting_test<SrcScalar, uint32_t>::run();
+    casting_test<SrcScalar, int64_t>::run();
+    casting_test<SrcScalar, uint64_t>::run();
+    casting_test<SrcScalar, half>::run();
+    casting_test<SrcScalar, bfloat16>::run();
+    casting_test<SrcScalar, float>::run();
+    casting_test<SrcScalar, double>::run();
+    casting_test<SrcScalar, std::complex<float>>::run();
+    casting_test<SrcScalar, std::complex<double>>::run();
+  }
+};
+
+template <typename SrcScalar>
+struct casting_test_runner<SrcScalar, std::enable_if_t<(NumTraits<SrcScalar>::IsComplex)>> {
+  static void run() {
+    // Only a few casts from std::complex<T> are defined.
+    casting_test<SrcScalar, half>::run();
+    casting_test<SrcScalar, bfloat16>::run();
+    casting_test<SrcScalar, std::complex<float>>::run();
+    casting_test<SrcScalar, std::complex<double>>::run();
+  }
+};
+
+void casting_all() {
+  casting_test_runner<bool>::run();
+  casting_test_runner<int8_t>::run();
+  casting_test_runner<uint8_t>::run();
+  casting_test_runner<int16_t>::run();
+  casting_test_runner<uint16_t>::run();
+  casting_test_runner<int32_t>::run();
+  casting_test_runner<uint32_t>::run();
+  casting_test_runner<int64_t>::run();
+  casting_test_runner<uint64_t>::run();
+  casting_test_runner<half>::run();
+  casting_test_runner<bfloat16>::run();
+  casting_test_runner<float>::run();
+  casting_test_runner<double>::run();
+  casting_test_runner<std::complex<float>>::run();
+  casting_test_runner<std::complex<double>>::run();
+}
+
+template <typename Scalar>
+void fixedSizeMatrixConstruction() {
+  Scalar raw[4];
+  for (int k = 0; k < 4; ++k) raw[k] = internal::random<Scalar>();
+
+  {
+    Matrix<Scalar, 4, 1> m(raw);
+    Array<Scalar, 4, 1> a(raw);
+    for (int k = 0; k < 4; ++k) VERIFY(m(k) == raw[k]);
+    for (int k = 0; k < 4; ++k) VERIFY(a(k) == raw[k]);
+    VERIFY_IS_EQUAL(m, (Matrix<Scalar, 4, 1>(raw[0], raw[1], raw[2], raw[3])));
+    VERIFY((a == (Array<Scalar, 4, 1>(raw[0], raw[1], raw[2], raw[3]))).all());
+  }
+  {
+    Matrix<Scalar, 3, 1> m(raw);
+    Array<Scalar, 3, 1> a(raw);
+    for (int k = 0; k < 3; ++k) VERIFY(m(k) == raw[k]);
+    for (int k = 0; k < 3; ++k) VERIFY(a(k) == raw[k]);
+    VERIFY_IS_EQUAL(m, (Matrix<Scalar, 3, 1>(raw[0], raw[1], raw[2])));
+    VERIFY((a == Array<Scalar, 3, 1>(raw[0], raw[1], raw[2])).all());
+  }
+  {
+    Matrix<Scalar, 2, 1> m(raw), m2((DenseIndex(raw[0])), (DenseIndex(raw[1])));
+    Array<Scalar, 2, 1> a(raw), a2((DenseIndex(raw[0])), (DenseIndex(raw[1])));
+    for (int k = 0; k < 2; ++k) VERIFY(m(k) == raw[k]);
+    for (int k = 0; k < 2; ++k) VERIFY(a(k) == raw[k]);
+    VERIFY_IS_EQUAL(m, (Matrix<Scalar, 2, 1>(raw[0], raw[1])));
+    VERIFY((a == Array<Scalar, 2, 1>(raw[0], raw[1])).all());
+    for (int k = 0; k < 2; ++k) VERIFY(m2(k) == DenseIndex(raw[k]));
+    for (int k = 0; k < 2; ++k) VERIFY(a2(k) == DenseIndex(raw[k]));
+  }
+  {
+    Matrix<Scalar, 1, 2> m(raw), m2((DenseIndex(raw[0])), (DenseIndex(raw[1]))), m3((int(raw[0])), (int(raw[1]))),
+        m4((float(raw[0])), (float(raw[1])));
+    Array<Scalar, 1, 2> a(raw), a2((DenseIndex(raw[0])), (DenseIndex(raw[1])));
+    for (int k = 0; k < 2; ++k) VERIFY(m(k) == raw[k]);
+    for (int k = 0; k < 2; ++k) VERIFY(a(k) == raw[k]);
+    VERIFY_IS_EQUAL(m, (Matrix<Scalar, 1, 2>(raw[0], raw[1])));
+    VERIFY((a == Array<Scalar, 1, 2>(raw[0], raw[1])).all());
+    for (int k = 0; k < 2; ++k) VERIFY(m2(k) == DenseIndex(raw[k]));
+    for (int k = 0; k < 2; ++k) VERIFY(a2(k) == DenseIndex(raw[k]));
+    for (int k = 0; k < 2; ++k) VERIFY(m3(k) == int(raw[k]));
+    for (int k = 0; k < 2; ++k) VERIFY((m4(k)) == Scalar(float(raw[k])));
+  }
+  {
+    Matrix<Scalar, 1, 1> m(raw), m1(raw[0]), m2((DenseIndex(raw[0]))), m3((int(raw[0])));
+    Array<Scalar, 1, 1> a(raw), a1(raw[0]), a2((DenseIndex(raw[0])));
+    VERIFY(m(0) == raw[0]);
+    VERIFY(a(0) == raw[0]);
+    VERIFY(m1(0) == raw[0]);
+    VERIFY(a1(0) == raw[0]);
+    VERIFY(m2(0) == DenseIndex(raw[0]));
+    VERIFY(a2(0) == DenseIndex(raw[0]));
+    VERIFY(m3(0) == int(raw[0]));
+    VERIFY_IS_EQUAL(m, (Matrix<Scalar, 1, 1>(raw[0])));
+    VERIFY((a == Array<Scalar, 1, 1>(raw[0])).all());
+  }
+}
+
+EIGEN_DECLARE_TEST(basicstuff) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(basicStuff(Matrix<float, 1, 1>()));
+    CALL_SUBTEST_2(basicStuff(Matrix4d()));
+    CALL_SUBTEST_3(basicStuff(
+        MatrixXcf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_4(basicStuff(
+        MatrixXi(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_5(basicStuff(
+        MatrixXcd(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_6(basicStuff(Matrix<float, 100, 100>()));
+    CALL_SUBTEST_7(basicStuff(Matrix<long double, Dynamic, Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
+                                                                    internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_8(casting_all());
+
+    CALL_SUBTEST_3(basicStuffComplex(
+        MatrixXcf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_5(basicStuffComplex(
+        MatrixXcd(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+  }
+
+  CALL_SUBTEST_1(fixedSizeMatrixConstruction<unsigned char>());
+  CALL_SUBTEST_1(fixedSizeMatrixConstruction<float>());
+  CALL_SUBTEST_1(fixedSizeMatrixConstruction<double>());
+  CALL_SUBTEST_1(fixedSizeMatrixConstruction<int>());
+  CALL_SUBTEST_1(fixedSizeMatrixConstruction<long int>());
+  CALL_SUBTEST_1(fixedSizeMatrixConstruction<std::ptrdiff_t>());
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/bdcsvd.cpp

@@ -0,0 +1,177 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2013 Gauthier Brun <brun.gauthier@gmail.com>
+// Copyright (C) 2013 Nicolas Carre <nicolas.carre@ensimag.fr>
+// Copyright (C) 2013 Jean Ceccato <jean.ceccato@ensimag.fr>
+// Copyright (C) 2013 Pierre Zoppitelli <pierre.zoppitelli@ensimag.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/
+
+// discard stack allocation as that too bypasses malloc
+#define EIGEN_STACK_ALLOCATION_LIMIT 0
+#define EIGEN_RUNTIME_NO_MALLOC
+
+#include "main.h"
+#include <Eigen/SVD>
+
+#define SVD_DEFAULT(M) BDCSVD<M>
+#define SVD_FOR_MIN_NORM(M) BDCSVD<M>
+#define SVD_STATIC_OPTIONS(M, O) BDCSVD<M, O>
+#include "svd_common.h"
+
+template <typename MatrixType>
+void bdcsvd_method() {
+  enum { Size = MatrixType::RowsAtCompileTime };
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef Matrix<RealScalar, Size, 1> RealVecType;
+  MatrixType m = MatrixType::Identity();
+  VERIFY_IS_APPROX(m.bdcSvd().singularValues(), RealVecType::Ones());
+  VERIFY_RAISES_ASSERT(m.bdcSvd().matrixU());
+  VERIFY_RAISES_ASSERT(m.bdcSvd().matrixV());
+}
+
+// compare the Singular values returned with Jacobi and Bdc
+template <typename MatrixType>
+void compare_bdc_jacobi(const MatrixType& a = MatrixType(), int algoswap = 16, bool random = true) {
+  MatrixType m = random ? MatrixType::Random(a.rows(), a.cols()) : a;
+
+  BDCSVD<MatrixType> bdc_svd(m.rows(), m.cols());
+  bdc_svd.setSwitchSize(algoswap);
+  bdc_svd.compute(m);
+
+  JacobiSVD<MatrixType> jacobi_svd(m);
+  VERIFY_IS_APPROX(bdc_svd.singularValues(), jacobi_svd.singularValues());
+}
+
+// Verifies total deflation is **not** triggered.
+void compare_bdc_jacobi_instance(bool structure_as_m, int algoswap = 16) {
+  MatrixXd m(4, 3);
+  if (structure_as_m) {
+    // The first 3 rows are the reduced form of Matrix 1 as shown below, and it
+    // has nonzero elements in the first column and diagonals only.
+    m << 1.056293, 0, 0, -0.336468, 0.907359, 0, -1.566245, 0, 0.149150, -0.1, 0, 0;
+  } else {
+    // Matrix 1.
+    m << 0.882336, 18.3914, -26.7921, -5.58135, 17.1931, -24.0892, -20.794, 8.68496, -4.83103, -8.4981, -10.5451,
+        23.9072;
+  }
+  compare_bdc_jacobi(m, algoswap, false);
+}
+
+template <typename MatrixType>
+void bdcsvd_thin_options(const MatrixType& input = MatrixType()) {
+  svd_thin_option_checks<MatrixType, 0>(input);
+}
+
+template <typename MatrixType>
+void bdcsvd_full_options(const MatrixType& input = MatrixType()) {
+  svd_option_checks_full_only<MatrixType, 0>(input);
+}
+
+template <typename MatrixType>
+void bdcsvd_verify_assert(const MatrixType& input = MatrixType()) {
+  svd_verify_assert<MatrixType>(input);
+  svd_verify_constructor_options_assert<BDCSVD<MatrixType>>(input);
+}
+
+template <typename MatrixType>
+void bdcsvd_check_convergence(const MatrixType& input) {
+  BDCSVD<MatrixType, Eigen::ComputeThinU | Eigen::ComputeThinV> svd(input);
+  VERIFY(svd.info() == Eigen::Success);
+  MatrixType D = svd.matrixU() * svd.singularValues().asDiagonal() * svd.matrixV().transpose();
+  VERIFY_IS_APPROX(input, D);
+}
+
+EIGEN_DECLARE_TEST(bdcsvd) {
+  CALL_SUBTEST_1((bdcsvd_verify_assert<Matrix3f>()));
+  CALL_SUBTEST_2((bdcsvd_verify_assert<Matrix4d>()));
+  CALL_SUBTEST_3((bdcsvd_verify_assert<Matrix<float, 10, 7>>()));
+  CALL_SUBTEST_4((bdcsvd_verify_assert<Matrix<float, 7, 10>>()));
+  CALL_SUBTEST_5((bdcsvd_verify_assert<Matrix<std::complex<double>, 6, 9>>()));
+
+  CALL_SUBTEST_6((svd_all_trivial_2x2(bdcsvd_thin_options<Matrix2cd>)));
+  CALL_SUBTEST_7((svd_all_trivial_2x2(bdcsvd_full_options<Matrix2cd>)));
+  CALL_SUBTEST_8((svd_all_trivial_2x2(bdcsvd_thin_options<Matrix2d>)));
+  CALL_SUBTEST_9((svd_all_trivial_2x2(bdcsvd_full_options<Matrix2d>)));
+
+  for (int i = 0; i < g_repeat; i++) {
+    int r = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2), c = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2);
+
+    TEST_SET_BUT_UNUSED_VARIABLE(r)
+    TEST_SET_BUT_UNUSED_VARIABLE(c)
+
+    CALL_SUBTEST_10((compare_bdc_jacobi<MatrixXf>(MatrixXf(r, c))));
+    CALL_SUBTEST_11((compare_bdc_jacobi<MatrixXd>(MatrixXd(r, c))));
+    CALL_SUBTEST_12((compare_bdc_jacobi<MatrixXcd>(MatrixXcd(r, c))));
+    // Test on inf/nan matrix
+    CALL_SUBTEST_13((svd_inf_nan<MatrixXf>()));
+    CALL_SUBTEST_14((svd_inf_nan<MatrixXd>()));
+
+    // Verify some computations using all combinations of the Options template parameter.
+    CALL_SUBTEST_15((bdcsvd_thin_options<Matrix3f>()));
+    CALL_SUBTEST_16((bdcsvd_full_options<Matrix3f>()));
+    CALL_SUBTEST_17((bdcsvd_thin_options<Matrix<float, 2, 3>>()));
+    CALL_SUBTEST_18((bdcsvd_full_options<Matrix<float, 2, 3>>()));
+    CALL_SUBTEST_19((bdcsvd_thin_options<MatrixXd>(MatrixXd(20, 17))));
+    CALL_SUBTEST_20((bdcsvd_full_options<MatrixXd>(MatrixXd(20, 17))));
+    CALL_SUBTEST_21((bdcsvd_thin_options<MatrixXd>(MatrixXd(17, 20))));
+    CALL_SUBTEST_22((bdcsvd_full_options<MatrixXd>(MatrixXd(17, 20))));
+    CALL_SUBTEST_23((bdcsvd_thin_options<Matrix<double, Dynamic, 15>>(Matrix<double, Dynamic, 15>(r, 15))));
+    CALL_SUBTEST_24((bdcsvd_full_options<Matrix<double, Dynamic, 15>>(Matrix<double, Dynamic, 15>(r, 15))));
+    CALL_SUBTEST_25((bdcsvd_thin_options<Matrix<double, 13, Dynamic>>(Matrix<double, 13, Dynamic>(13, c))));
+    CALL_SUBTEST_26((bdcsvd_full_options<Matrix<double, 13, Dynamic>>(Matrix<double, 13, Dynamic>(13, c))));
+    CALL_SUBTEST_27((bdcsvd_thin_options<MatrixXf>(MatrixXf(r, c))));
+    CALL_SUBTEST_28((bdcsvd_full_options<MatrixXf>(MatrixXf(r, c))));
+    CALL_SUBTEST_29((bdcsvd_thin_options<MatrixXcd>(MatrixXcd(r, c))));
+    CALL_SUBTEST_30((bdcsvd_full_options<MatrixXcd>(MatrixXcd(r, c))));
+    CALL_SUBTEST_31((bdcsvd_thin_options<MatrixXd>(MatrixXd(r, c))));
+    CALL_SUBTEST_32((bdcsvd_full_options<MatrixXd>(MatrixXd(r, c))));
+    CALL_SUBTEST_33((bdcsvd_thin_options<Matrix<double, Dynamic, Dynamic, RowMajor>>(
+        Matrix<double, Dynamic, Dynamic, RowMajor>(20, 27))));
+    CALL_SUBTEST_34((bdcsvd_full_options<Matrix<double, Dynamic, Dynamic, RowMajor>>(
+        Matrix<double, Dynamic, Dynamic, RowMajor>(20, 27))));
+    CALL_SUBTEST_35((bdcsvd_thin_options<Matrix<double, Dynamic, Dynamic, RowMajor>>(
+        Matrix<double, Dynamic, Dynamic, RowMajor>(27, 20))));
+    CALL_SUBTEST_36((bdcsvd_full_options<Matrix<double, Dynamic, Dynamic, RowMajor>>(
+        Matrix<double, Dynamic, Dynamic, RowMajor>(27, 20))));
+    CALL_SUBTEST_37((
+        svd_check_max_size_matrix<Matrix<float, Dynamic, Dynamic, ColMajor, 20, 35>, ColPivHouseholderQRPreconditioner>(
+            r, c)));
+    CALL_SUBTEST_38(
+        (svd_check_max_size_matrix<Matrix<float, Dynamic, Dynamic, ColMajor, 35, 20>, HouseholderQRPreconditioner>(r,
+                                                                                                                   c)));
+    CALL_SUBTEST_39((
+        svd_check_max_size_matrix<Matrix<float, Dynamic, Dynamic, RowMajor, 20, 35>, ColPivHouseholderQRPreconditioner>(
+            r, c)));
+    CALL_SUBTEST_40(
+        (svd_check_max_size_matrix<Matrix<float, Dynamic, Dynamic, RowMajor, 35, 20>, HouseholderQRPreconditioner>(r,
+                                                                                                                   c)));
+  }
+
+  // test matrixbase method
+  CALL_SUBTEST_41((bdcsvd_method<Matrix2cd>()));
+  CALL_SUBTEST_42((bdcsvd_method<Matrix3f>()));
+
+  // Test problem size constructors
+  CALL_SUBTEST_43(BDCSVD<MatrixXf>(10, 10));
+
+  // Check that preallocation avoids subsequent mallocs
+  // Disabled because not supported by BDCSVD
+  // CALL_SUBTEST_9( svd_preallocate<void>() );
+
+  CALL_SUBTEST_44(svd_underoverflow<void>());
+
+  // Without total deflation issues.
+  CALL_SUBTEST_45((compare_bdc_jacobi_instance(true)));
+  CALL_SUBTEST_46((compare_bdc_jacobi_instance(false)));
+
+  // With total deflation issues before, when it shouldn't be triggered.
+  CALL_SUBTEST_47((compare_bdc_jacobi_instance(true, 3)));
+  CALL_SUBTEST_48((compare_bdc_jacobi_instance(false, 3)));
+
+  // Convergence for large constant matrix (https://gitlab.com/libeigen/eigen/-/issues/2491)
+  CALL_SUBTEST_49(bdcsvd_check_convergence<MatrixXf>(MatrixXf::Constant(500, 500, 1)));
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/bfloat16_float.cpp

@@ -0,0 +1,402 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// 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 <sstream>
+#include <memory>
+#include <math.h>
+
+#include "main.h"
+
+#define VERIFY_BFLOAT16_BITS_EQUAL(h, bits) \
+  VERIFY_IS_EQUAL((numext::bit_cast<numext::uint16_t>(h)), (static_cast<numext::uint16_t>(bits)))
+
+// Make sure it's possible to forward declare Eigen::bfloat16
+namespace Eigen {
+struct bfloat16;
+}
+
+using Eigen::bfloat16;
+
+float BinaryToFloat(uint32_t sign, uint32_t exponent, uint32_t high_mantissa, uint32_t low_mantissa) {
+  float dest;
+  uint32_t src = (sign << 31) + (exponent << 23) + (high_mantissa << 16) + low_mantissa;
+  memcpy(static_cast<void*>(&dest), static_cast<const void*>(&src), sizeof(dest));
+  return dest;
+}
+
+template <typename T>
+void test_roundtrip() {
+  // Representable T round trip via bfloat16
+  VERIFY_IS_EQUAL((internal::cast<bfloat16, T>(internal::cast<T, bfloat16>(-std::numeric_limits<T>::infinity()))),
+                  -std::numeric_limits<T>::infinity());
+  VERIFY_IS_EQUAL((internal::cast<bfloat16, T>(internal::cast<T, bfloat16>(std::numeric_limits<T>::infinity()))),
+                  std::numeric_limits<T>::infinity());
+  VERIFY_IS_EQUAL((internal::cast<bfloat16, T>(internal::cast<T, bfloat16>(T(-1.0)))), T(-1.0));
+  VERIFY_IS_EQUAL((internal::cast<bfloat16, T>(internal::cast<T, bfloat16>(T(-0.5)))), T(-0.5));
+  VERIFY_IS_EQUAL((internal::cast<bfloat16, T>(internal::cast<T, bfloat16>(T(-0.0)))), T(-0.0));
+  VERIFY_IS_EQUAL((internal::cast<bfloat16, T>(internal::cast<T, bfloat16>(T(1.0)))), T(1.0));
+  VERIFY_IS_EQUAL((internal::cast<bfloat16, T>(internal::cast<T, bfloat16>(T(0.5)))), T(0.5));
+  VERIFY_IS_EQUAL((internal::cast<bfloat16, T>(internal::cast<T, bfloat16>(T(0.0)))), T(0.0));
+}
+
+void test_conversion() {
+  using Eigen::bfloat16_impl::__bfloat16_raw;
+
+  // Round-trip casts
+  VERIFY_IS_EQUAL(numext::bit_cast<bfloat16>(numext::bit_cast<numext::uint16_t>(bfloat16(1.0f))), bfloat16(1.0f));
+  VERIFY_IS_EQUAL(numext::bit_cast<bfloat16>(numext::bit_cast<numext::uint16_t>(bfloat16(0.5f))), bfloat16(0.5f));
+  VERIFY_IS_EQUAL(numext::bit_cast<bfloat16>(numext::bit_cast<numext::uint16_t>(bfloat16(-0.33333f))),
+                  bfloat16(-0.33333f));
+  VERIFY_IS_EQUAL(numext::bit_cast<bfloat16>(numext::bit_cast<numext::uint16_t>(bfloat16(0.0f))), bfloat16(0.0f));
+
+  // Conversion from float.
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(1.0f), 0x3f80);
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(0.5f), 0x3f00);
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(0.33333f), 0x3eab);
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(3.38e38f), 0x7f7e);
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(3.40e38f), 0x7f80);  // Becomes infinity.
+
+  // Verify round-to-nearest-even behavior.
+  float val1 = static_cast<float>(bfloat16(__bfloat16_raw(0x3c00)));
+  float val2 = static_cast<float>(bfloat16(__bfloat16_raw(0x3c01)));
+  float val3 = static_cast<float>(bfloat16(__bfloat16_raw(0x3c02)));
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(0.5f * (val1 + val2)), 0x3c00);
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(0.5f * (val2 + val3)), 0x3c02);
+
+  // Conversion from int.
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(-1), 0xbf80);
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(0), 0x0000);
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(1), 0x3f80);
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(2), 0x4000);
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(3), 0x4040);
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(12), 0x4140);
+
+  // Conversion from bool.
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(false), 0x0000);
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(true), 0x3f80);
+
+  // Conversion to bool
+  VERIFY_IS_EQUAL(static_cast<bool>(bfloat16(3)), true);
+  VERIFY_IS_EQUAL(static_cast<bool>(bfloat16(0.33333f)), true);
+  VERIFY_IS_EQUAL(static_cast<bool>(bfloat16(-0.0)), false);
+  VERIFY_IS_EQUAL(static_cast<bool>(bfloat16(0.0)), false);
+
+  // Explicit conversion to float.
+  VERIFY_IS_EQUAL(static_cast<float>(bfloat16(__bfloat16_raw(0x0000))), 0.0f);
+  VERIFY_IS_EQUAL(static_cast<float>(bfloat16(__bfloat16_raw(0x3f80))), 1.0f);
+
+  // Implicit conversion to float
+  VERIFY_IS_EQUAL(bfloat16(__bfloat16_raw(0x0000)), 0.0f);
+  VERIFY_IS_EQUAL(bfloat16(__bfloat16_raw(0x3f80)), 1.0f);
+
+  // Zero representations
+  VERIFY_IS_EQUAL(bfloat16(0.0f), bfloat16(0.0f));
+  VERIFY_IS_EQUAL(bfloat16(-0.0f), bfloat16(0.0f));
+  VERIFY_IS_EQUAL(bfloat16(-0.0f), bfloat16(-0.0f));
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(0.0f), 0x0000);
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(-0.0f), 0x8000);
+
+  // Default is zero
+  VERIFY_IS_EQUAL(static_cast<float>(bfloat16()), 0.0f);
+
+  // Representable floats round trip via bfloat16
+  test_roundtrip<float>();
+  test_roundtrip<double>();
+  test_roundtrip<std::complex<float> >();
+  test_roundtrip<std::complex<double> >();
+
+  // Conversion
+  Array<float, 1, 100> a;
+  for (int i = 0; i < 100; i++) a(i) = i + 1.25;
+  Array<bfloat16, 1, 100> b = a.cast<bfloat16>();
+  Array<float, 1, 100> c = b.cast<float>();
+  for (int i = 0; i < 100; ++i) {
+    VERIFY_LE(numext::abs(c(i) - a(i)), a(i) / 128);
+  }
+
+  // Epsilon
+  VERIFY_LE(1.0f, static_cast<float>((std::numeric_limits<bfloat16>::epsilon)() + bfloat16(1.0f)));
+  VERIFY_IS_EQUAL(1.0f,
+                  static_cast<float>((std::numeric_limits<bfloat16>::epsilon)() / bfloat16(2.0f) + bfloat16(1.0f)));
+
+  // Negate
+  VERIFY_IS_EQUAL(static_cast<float>(-bfloat16(3.0f)), -3.0f);
+  VERIFY_IS_EQUAL(static_cast<float>(-bfloat16(-4.5f)), 4.5f);
+
+#if !EIGEN_COMP_MSVC
+  // Visual Studio errors out on divisions by 0
+  VERIFY((numext::isnan)(static_cast<float>(bfloat16(0.0 / 0.0))));
+  VERIFY((numext::isinf)(static_cast<float>(bfloat16(1.0 / 0.0))));
+  VERIFY((numext::isinf)(static_cast<float>(bfloat16(-1.0 / 0.0))));
+
+  // Visual Studio errors out on divisions by 0
+  VERIFY((numext::isnan)(bfloat16(0.0 / 0.0)));
+  VERIFY((numext::isinf)(bfloat16(1.0 / 0.0)));
+  VERIFY((numext::isinf)(bfloat16(-1.0 / 0.0)));
+#endif
+
+  // NaNs and infinities.
+  VERIFY(!(numext::isinf)(static_cast<float>(bfloat16(3.38e38f))));  // Largest finite number.
+  VERIFY(!(numext::isnan)(static_cast<float>(bfloat16(0.0f))));
+  VERIFY((numext::isinf)(static_cast<float>(bfloat16(__bfloat16_raw(0xff80)))));
+  VERIFY((numext::isnan)(static_cast<float>(bfloat16(__bfloat16_raw(0xffc0)))));
+  VERIFY((numext::isinf)(static_cast<float>(bfloat16(__bfloat16_raw(0x7f80)))));
+  VERIFY((numext::isnan)(static_cast<float>(bfloat16(__bfloat16_raw(0x7fc0)))));
+
+  // Exactly same checks as above, just directly on the bfloat16 representation.
+  VERIFY(!(numext::isinf)(bfloat16(__bfloat16_raw(0x7bff))));
+  VERIFY(!(numext::isnan)(bfloat16(__bfloat16_raw(0x0000))));
+  VERIFY((numext::isinf)(bfloat16(__bfloat16_raw(0xff80))));
+  VERIFY((numext::isnan)(bfloat16(__bfloat16_raw(0xffc0))));
+  VERIFY((numext::isinf)(bfloat16(__bfloat16_raw(0x7f80))));
+  VERIFY((numext::isnan)(bfloat16(__bfloat16_raw(0x7fc0))));
+
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(BinaryToFloat(0x0, 0xff, 0x40, 0x0)), 0x7fc0);
+  VERIFY_BFLOAT16_BITS_EQUAL(bfloat16(BinaryToFloat(0x1, 0xff, 0x40, 0x0)), 0xffc0);
+}
+
+void test_numtraits() {
+  std::cout << "epsilon       = " << NumTraits<bfloat16>::epsilon() << "  (0x" << std::hex
+            << numext::bit_cast<numext::uint16_t>(NumTraits<bfloat16>::epsilon()) << ")" << std::endl;
+  std::cout << "highest       = " << NumTraits<bfloat16>::highest() << "  (0x" << std::hex
+            << numext::bit_cast<numext::uint16_t>(NumTraits<bfloat16>::highest()) << ")" << std::endl;
+  std::cout << "lowest        = " << NumTraits<bfloat16>::lowest() << "  (0x" << std::hex
+            << numext::bit_cast<numext::uint16_t>(NumTraits<bfloat16>::lowest()) << ")" << std::endl;
+  std::cout << "min           = " << (std::numeric_limits<bfloat16>::min)() << "  (0x" << std::hex
+            << numext::bit_cast<numext::uint16_t>((std::numeric_limits<bfloat16>::min)()) << ")" << std::endl;
+  std::cout << "denorm min    = " << (std::numeric_limits<bfloat16>::denorm_min)() << "  (0x" << std::hex
+            << numext::bit_cast<numext::uint16_t>((std::numeric_limits<bfloat16>::denorm_min)()) << ")" << std::endl;
+  std::cout << "infinity      = " << NumTraits<bfloat16>::infinity() << "  (0x" << std::hex
+            << numext::bit_cast<numext::uint16_t>(NumTraits<bfloat16>::infinity()) << ")" << std::endl;
+  std::cout << "quiet nan     = " << NumTraits<bfloat16>::quiet_NaN() << "  (0x" << std::hex
+            << numext::bit_cast<numext::uint16_t>(NumTraits<bfloat16>::quiet_NaN()) << ")" << std::endl;
+  std::cout << "signaling nan = " << std::numeric_limits<bfloat16>::signaling_NaN() << "  (0x" << std::hex
+            << numext::bit_cast<numext::uint16_t>(std::numeric_limits<bfloat16>::signaling_NaN()) << ")" << std::endl;
+
+  VERIFY(NumTraits<bfloat16>::IsSigned);
+
+  VERIFY_IS_EQUAL(numext::bit_cast<numext::uint16_t>(std::numeric_limits<bfloat16>::infinity()),
+                  numext::bit_cast<numext::uint16_t>(bfloat16(std::numeric_limits<float>::infinity())));
+  // There is no guarantee that casting a 32-bit NaN to bfloat16 has a precise
+  // bit pattern.  We test that it is in fact a NaN, then test the signaling
+  // bit (msb of significand is 1 for quiet, 0 for signaling).
+  const numext::uint16_t BFLOAT16_QUIET_BIT = 0x0040;
+  VERIFY((numext::isnan)(std::numeric_limits<bfloat16>::quiet_NaN()) &&
+         (numext::isnan)(bfloat16(std::numeric_limits<float>::quiet_NaN())) &&
+         ((numext::bit_cast<numext::uint16_t>(std::numeric_limits<bfloat16>::quiet_NaN()) & BFLOAT16_QUIET_BIT) > 0) &&
+         ((numext::bit_cast<numext::uint16_t>(bfloat16(std::numeric_limits<float>::quiet_NaN())) & BFLOAT16_QUIET_BIT) >
+          0));
+  // After a cast to bfloat16, a signaling NaN may become non-signaling. Thus,
+  // we check that both are NaN, and that only the `numeric_limits` version is
+  // signaling.
+  VERIFY(
+      (numext::isnan)(std::numeric_limits<bfloat16>::signaling_NaN()) &&
+      (numext::isnan)(bfloat16(std::numeric_limits<float>::signaling_NaN())) &&
+      ((numext::bit_cast<numext::uint16_t>(std::numeric_limits<bfloat16>::signaling_NaN()) & BFLOAT16_QUIET_BIT) == 0));
+
+  VERIFY((std::numeric_limits<bfloat16>::min)() > bfloat16(0.f));
+  VERIFY((std::numeric_limits<bfloat16>::denorm_min)() > bfloat16(0.f));
+  VERIFY_IS_EQUAL((std::numeric_limits<bfloat16>::denorm_min)() / bfloat16(2), bfloat16(0.f));
+}
+
+void test_arithmetic() {
+  VERIFY_IS_EQUAL(static_cast<float>(bfloat16(2) + bfloat16(2)), 4.f);
+  VERIFY_IS_EQUAL(static_cast<float>(bfloat16(2) + bfloat16(-2)), 0.f);
+  VERIFY_IS_APPROX(static_cast<float>(bfloat16(0.33333f) + bfloat16(0.66667f)), 1.0f);
+  VERIFY_IS_EQUAL(static_cast<float>(bfloat16(2.0f) * bfloat16(-5.5f)), -11.0f);
+  VERIFY_IS_APPROX(static_cast<float>(bfloat16(1.0f) / bfloat16(3.0f)), 0.3339f);
+  VERIFY_IS_EQUAL(static_cast<float>(-bfloat16(4096.0f)), -4096.0f);
+  VERIFY_IS_EQUAL(static_cast<float>(-bfloat16(-4096.0f)), 4096.0f);
+}
+
+void test_comparison() {
+  VERIFY(bfloat16(1.0f) > bfloat16(0.5f));
+  VERIFY(bfloat16(0.5f) < bfloat16(1.0f));
+  VERIFY(!(bfloat16(1.0f) < bfloat16(0.5f)));
+  VERIFY(!(bfloat16(0.5f) > bfloat16(1.0f)));
+
+  VERIFY(!(bfloat16(4.0f) > bfloat16(4.0f)));
+  VERIFY(!(bfloat16(4.0f) < bfloat16(4.0f)));
+
+  VERIFY(!(bfloat16(0.0f) < bfloat16(-0.0f)));
+  VERIFY(!(bfloat16(-0.0f) < bfloat16(0.0f)));
+  VERIFY(!(bfloat16(0.0f) > bfloat16(-0.0f)));
+  VERIFY(!(bfloat16(-0.0f) > bfloat16(0.0f)));
+
+  VERIFY(bfloat16(0.2f) > bfloat16(-1.0f));
+  VERIFY(bfloat16(-1.0f) < bfloat16(0.2f));
+  VERIFY(bfloat16(-16.0f) < bfloat16(-15.0f));
+
+  VERIFY(bfloat16(1.0f) == bfloat16(1.0f));
+  VERIFY(bfloat16(1.0f) != bfloat16(2.0f));
+
+  // Comparisons with NaNs and infinities.
+#if !EIGEN_COMP_MSVC
+  // Visual Studio errors out on divisions by 0
+  VERIFY(!(bfloat16(0.0 / 0.0) == bfloat16(0.0 / 0.0)));
+  VERIFY(bfloat16(0.0 / 0.0) != bfloat16(0.0 / 0.0));
+
+  VERIFY(!(bfloat16(1.0) == bfloat16(0.0 / 0.0)));
+  VERIFY(!(bfloat16(1.0) < bfloat16(0.0 / 0.0)));
+  VERIFY(!(bfloat16(1.0) > bfloat16(0.0 / 0.0)));
+  VERIFY(bfloat16(1.0) != bfloat16(0.0 / 0.0));
+
+  VERIFY(bfloat16(1.0) < bfloat16(1.0 / 0.0));
+  VERIFY(bfloat16(1.0) > bfloat16(-1.0 / 0.0));
+#endif
+}
+
+void test_basic_functions() {
+  VERIFY_IS_EQUAL(static_cast<float>(numext::abs(bfloat16(3.5f))), 3.5f);
+  VERIFY_IS_EQUAL(static_cast<float>(abs(bfloat16(3.5f))), 3.5f);
+  VERIFY_IS_EQUAL(static_cast<float>(numext::abs(bfloat16(-3.5f))), 3.5f);
+  VERIFY_IS_EQUAL(static_cast<float>(abs(bfloat16(-3.5f))), 3.5f);
+
+  VERIFY_IS_EQUAL(static_cast<float>(numext::floor(bfloat16(3.5f))), 3.0f);
+  VERIFY_IS_EQUAL(static_cast<float>(floor(bfloat16(3.5f))), 3.0f);
+  VERIFY_IS_EQUAL(static_cast<float>(numext::floor(bfloat16(-3.5f))), -4.0f);
+  VERIFY_IS_EQUAL(static_cast<float>(floor(bfloat16(-3.5f))), -4.0f);
+
+  VERIFY_IS_EQUAL(static_cast<float>(numext::ceil(bfloat16(3.5f))), 4.0f);
+  VERIFY_IS_EQUAL(static_cast<float>(ceil(bfloat16(3.5f))), 4.0f);
+  VERIFY_IS_EQUAL(static_cast<float>(numext::ceil(bfloat16(-3.5f))), -3.0f);
+  VERIFY_IS_EQUAL(static_cast<float>(ceil(bfloat16(-3.5f))), -3.0f);
+
+  VERIFY_IS_APPROX(static_cast<float>(numext::sqrt(bfloat16(0.0f))), 0.0f);
+  VERIFY_IS_APPROX(static_cast<float>(sqrt(bfloat16(0.0f))), 0.0f);
+  VERIFY_IS_APPROX(static_cast<float>(numext::sqrt(bfloat16(4.0f))), 2.0f);
+  VERIFY_IS_APPROX(static_cast<float>(sqrt(bfloat16(4.0f))), 2.0f);
+
+  VERIFY_IS_APPROX(static_cast<float>(numext::pow(bfloat16(0.0f), bfloat16(1.0f))), 0.0f);
+  VERIFY_IS_APPROX(static_cast<float>(pow(bfloat16(0.0f), bfloat16(1.0f))), 0.0f);
+  VERIFY_IS_APPROX(static_cast<float>(numext::pow(bfloat16(2.0f), bfloat16(2.0f))), 4.0f);
+  VERIFY_IS_APPROX(static_cast<float>(pow(bfloat16(2.0f), bfloat16(2.0f))), 4.0f);
+
+  VERIFY_IS_EQUAL(static_cast<float>(numext::exp(bfloat16(0.0f))), 1.0f);
+  VERIFY_IS_EQUAL(static_cast<float>(exp(bfloat16(0.0f))), 1.0f);
+  VERIFY_IS_APPROX(static_cast<float>(numext::exp(bfloat16(EIGEN_PI))), 20.f + static_cast<float>(EIGEN_PI));
+  VERIFY_IS_APPROX(static_cast<float>(exp(bfloat16(EIGEN_PI))), 20.f + static_cast<float>(EIGEN_PI));
+
+  VERIFY_IS_EQUAL(static_cast<float>(numext::expm1(bfloat16(0.0f))), 0.0f);
+  VERIFY_IS_EQUAL(static_cast<float>(expm1(bfloat16(0.0f))), 0.0f);
+  VERIFY_IS_APPROX(static_cast<float>(numext::expm1(bfloat16(2.0f))), 6.375f);
+  VERIFY_IS_APPROX(static_cast<float>(expm1(bfloat16(2.0f))), 6.375f);
+
+  VERIFY_IS_EQUAL(static_cast<float>(numext::log(bfloat16(1.0f))), 0.0f);
+  VERIFY_IS_EQUAL(static_cast<float>(log(bfloat16(1.0f))), 0.0f);
+  VERIFY_IS_APPROX(static_cast<float>(numext::log(bfloat16(10.0f))), 2.296875f);
+  VERIFY_IS_APPROX(static_cast<float>(log(bfloat16(10.0f))), 2.296875f);
+
+  VERIFY_IS_EQUAL(static_cast<float>(numext::log1p(bfloat16(0.0f))), 0.0f);
+  VERIFY_IS_EQUAL(static_cast<float>(log1p(bfloat16(0.0f))), 0.0f);
+  VERIFY_IS_APPROX(static_cast<float>(numext::log1p(bfloat16(10.0f))), 2.390625f);
+  VERIFY_IS_APPROX(static_cast<float>(log1p(bfloat16(10.0f))), 2.390625f);
+}
+
+void test_trigonometric_functions() {
+  VERIFY_IS_APPROX(numext::cos(bfloat16(0.0f)), bfloat16(cosf(0.0f)));
+  VERIFY_IS_APPROX(cos(bfloat16(0.0f)), bfloat16(cosf(0.0f)));
+  VERIFY_IS_APPROX(numext::cos(bfloat16(EIGEN_PI)), bfloat16(cosf(EIGEN_PI)));
+  // VERIFY_IS_APPROX(numext::cos(bfloat16(EIGEN_PI/2)), bfloat16(cosf(EIGEN_PI/2)));
+  // VERIFY_IS_APPROX(numext::cos(bfloat16(3*EIGEN_PI/2)), bfloat16(cosf(3*EIGEN_PI/2)));
+  VERIFY_IS_APPROX(numext::cos(bfloat16(3.5f)), bfloat16(cosf(3.5f)));
+
+  VERIFY_IS_APPROX(numext::sin(bfloat16(0.0f)), bfloat16(sinf(0.0f)));
+  VERIFY_IS_APPROX(sin(bfloat16(0.0f)), bfloat16(sinf(0.0f)));
+  // VERIFY_IS_APPROX(numext::sin(bfloat16(EIGEN_PI)), bfloat16(sinf(EIGEN_PI)));
+  VERIFY_IS_APPROX(numext::sin(bfloat16(EIGEN_PI / 2)), bfloat16(sinf(EIGEN_PI / 2)));
+  VERIFY_IS_APPROX(numext::sin(bfloat16(3 * EIGEN_PI / 2)), bfloat16(sinf(3 * EIGEN_PI / 2)));
+  VERIFY_IS_APPROX(numext::sin(bfloat16(3.5f)), bfloat16(sinf(3.5f)));
+
+  VERIFY_IS_APPROX(numext::tan(bfloat16(0.0f)), bfloat16(tanf(0.0f)));
+  VERIFY_IS_APPROX(tan(bfloat16(0.0f)), bfloat16(tanf(0.0f)));
+  // VERIFY_IS_APPROX(numext::tan(bfloat16(EIGEN_PI)), bfloat16(tanf(EIGEN_PI)));
+  // VERIFY_IS_APPROX(numext::tan(bfloat16(EIGEN_PI/2)), bfloat16(tanf(EIGEN_PI/2)));
+  // VERIFY_IS_APPROX(numext::tan(bfloat16(3*EIGEN_PI/2)), bfloat16(tanf(3*EIGEN_PI/2)));
+  VERIFY_IS_APPROX(numext::tan(bfloat16(3.5f)), bfloat16(tanf(3.5f)));
+}
+
+void test_array() {
+  typedef Array<bfloat16, 1, Dynamic> ArrayXh;
+  Index size = internal::random<Index>(1, 10);
+  Index i = internal::random<Index>(0, size - 1);
+  ArrayXh a1 = ArrayXh::Random(size), a2 = ArrayXh::Random(size);
+  VERIFY_IS_APPROX(a1 + a1, bfloat16(2) * a1);
+  VERIFY((a1.abs() >= bfloat16(0)).all());
+  VERIFY_IS_APPROX((a1 * a1).sqrt(), a1.abs());
+
+  VERIFY(((a1.min)(a2) <= (a1.max)(a2)).all());
+  a1(i) = bfloat16(-10.);
+  VERIFY_IS_EQUAL(a1.minCoeff(), bfloat16(-10.));
+  a1(i) = bfloat16(10.);
+  VERIFY_IS_EQUAL(a1.maxCoeff(), bfloat16(10.));
+
+  std::stringstream ss;
+  ss << a1;
+}
+
+void test_product() {
+  typedef Matrix<bfloat16, Dynamic, Dynamic> MatrixXh;
+  Index rows = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
+  Index cols = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
+  Index depth = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
+  MatrixXh Ah = MatrixXh::Random(rows, depth);
+  MatrixXh Bh = MatrixXh::Random(depth, cols);
+  MatrixXh Ch = MatrixXh::Random(rows, cols);
+  MatrixXf Af = Ah.cast<float>();
+  MatrixXf Bf = Bh.cast<float>();
+  MatrixXf Cf = Ch.cast<float>();
+  VERIFY_IS_APPROX(Ch.noalias() += Ah * Bh, (Cf.noalias() += Af * Bf).cast<bfloat16>());
+}
+
+void test_nextafter() {
+  VERIFY((numext::isnan)(numext::nextafter(std::numeric_limits<bfloat16>::quiet_NaN(), bfloat16(1.0f))));
+  VERIFY((numext::isnan)(numext::nextafter(bfloat16(1.0f), std::numeric_limits<bfloat16>::quiet_NaN())));
+  VERIFY(numext::nextafter(bfloat16(0.0f), bfloat16(0.0f)) == bfloat16(0.0f));
+  VERIFY(numext::nextafter(bfloat16(1.0f), bfloat16(1.0f)) == bfloat16(1.0f));
+  VERIFY(numext::nextafter(bfloat16(-1.0f), bfloat16(-1.0f)) == bfloat16(-1.0f));
+  VERIFY(numext::nextafter(std::numeric_limits<bfloat16>::infinity(), std::numeric_limits<bfloat16>::infinity()) ==
+         std::numeric_limits<bfloat16>::infinity());
+  VERIFY(numext::nextafter(std::numeric_limits<bfloat16>::infinity(), bfloat16(0.0f)) ==
+         (std::numeric_limits<bfloat16>::max)());
+  VERIFY(numext::nextafter(-std::numeric_limits<bfloat16>::infinity(), bfloat16(0.0f)) ==
+         -(std::numeric_limits<bfloat16>::max)());
+  VERIFY(numext::nextafter(bfloat16(1.0f), std::numeric_limits<bfloat16>::infinity()) ==
+         bfloat16(1.0f) + std::numeric_limits<bfloat16>::epsilon());
+  VERIFY(numext::nextafter(bfloat16(1.0f), -std::numeric_limits<bfloat16>::infinity()) ==
+         bfloat16(1.0f) - std::numeric_limits<bfloat16>::epsilon() / bfloat16(2.0f));
+  VERIFY(numext::nextafter(bfloat16(-1.0f), -std::numeric_limits<bfloat16>::infinity()) ==
+         bfloat16(-1.0f) - std::numeric_limits<bfloat16>::epsilon());
+  VERIFY(numext::nextafter(bfloat16(-1.0f), std::numeric_limits<bfloat16>::infinity()) ==
+         bfloat16(-1.0f) + std::numeric_limits<bfloat16>::epsilon() / bfloat16(2.0f));
+  VERIFY(numext::nextafter((std::numeric_limits<bfloat16>::max)(), std::numeric_limits<bfloat16>::infinity()) ==
+         std::numeric_limits<bfloat16>::infinity());
+  VERIFY(numext::nextafter(-(std::numeric_limits<bfloat16>::max)(), -std::numeric_limits<bfloat16>::infinity()) ==
+         -std::numeric_limits<bfloat16>::infinity());
+  VERIFY_BFLOAT16_BITS_EQUAL(numext::nextafter(bfloat16(0.0f), bfloat16(1.0f)), 0x0001);
+  VERIFY_BFLOAT16_BITS_EQUAL(numext::nextafter(bfloat16(-0.0f), bfloat16(1.0f)), 0x0000);
+  VERIFY_BFLOAT16_BITS_EQUAL(numext::nextafter(bfloat16(0.0f), bfloat16(-1.0f)), 0x8000);
+  VERIFY_BFLOAT16_BITS_EQUAL(numext::nextafter(bfloat16(-0.0f), bfloat16(-1.0f)), 0x8001);
+  VERIFY_BFLOAT16_BITS_EQUAL(numext::nextafter(bfloat16(0.0f), bfloat16(-0.0f)), 0x8000);
+  VERIFY_BFLOAT16_BITS_EQUAL(numext::nextafter(bfloat16(-0.0f), bfloat16(0.0f)), 0x0000);
+  VERIFY_BFLOAT16_BITS_EQUAL(numext::nextafter(bfloat16(0.0f), bfloat16(0.0f)), 0x0000);
+  VERIFY_BFLOAT16_BITS_EQUAL(numext::nextafter(bfloat16(-0.0f), bfloat16(-0.0f)), 0x8000);
+}
+
+EIGEN_DECLARE_TEST(bfloat16_float) {
+  CALL_SUBTEST(test_numtraits());
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST(test_conversion());
+    CALL_SUBTEST(test_arithmetic());
+    CALL_SUBTEST(test_comparison());
+    CALL_SUBTEST(test_basic_functions());
+    CALL_SUBTEST(test_trigonometric_functions());
+    CALL_SUBTEST(test_array());
+    CALL_SUBTEST(test_product());
+    CALL_SUBTEST(test_nextafter());
+  }
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/bicgstab.cpp

@@ -0,0 +1,88 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Gael Guennebaud <g.gael@free.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/.
+
+#include "sparse_solver.h"
+#include <Eigen/IterativeLinearSolvers>
+
+template <typename T, typename I_>
+void test_bicgstab_T() {
+  BiCGSTAB<SparseMatrix<T, 0, I_>, DiagonalPreconditioner<T> > bicgstab_colmajor_diag;
+  BiCGSTAB<SparseMatrix<T, 0, I_>, IdentityPreconditioner> bicgstab_colmajor_I;
+  BiCGSTAB<SparseMatrix<T, 0, I_>, IncompleteLUT<T, I_> > bicgstab_colmajor_ilut;
+  // BiCGSTAB<SparseMatrix<T>, SSORPreconditioner<T> >     bicgstab_colmajor_ssor;
+
+  bicgstab_colmajor_diag.setTolerance(NumTraits<T>::epsilon() * 4);
+  bicgstab_colmajor_ilut.setTolerance(NumTraits<T>::epsilon() * 4);
+
+  CALL_SUBTEST(check_sparse_square_solving(bicgstab_colmajor_diag));
+  //   CALL_SUBTEST( check_sparse_square_solving(bicgstab_colmajor_I)     );
+  CALL_SUBTEST(check_sparse_square_solving(bicgstab_colmajor_ilut));
+  // CALL_SUBTEST( check_sparse_square_solving(bicgstab_colmajor_ssor)     );
+}
+
+// https://gitlab.com/libeigen/eigen/-/issues/2856
+void test_2856() {
+  Eigen::MatrixXd D = Eigen::MatrixXd::Identity(14, 14);
+  D(6, 13) = 1;
+  D(13, 12) = 1;
+  using CSRMatrix = Eigen::SparseMatrix<double, Eigen::RowMajor>;
+  CSRMatrix A = D.sparseView();
+
+  Eigen::VectorXd b = Eigen::VectorXd::Zero(14);
+  b(12) = -1001;
+
+  Eigen::BiCGSTAB<CSRMatrix> solver;
+  solver.compute(A);
+  Eigen::VectorXd x = solver.solve(b);
+  Eigen::VectorXd expected = Eigen::VectorXd::Zero(14);
+  expected(6) = -1001;
+  expected(12) = -1001;
+  expected(13) = 1001;
+  VERIFY_IS_EQUAL(x, expected);
+
+  Eigen::VectorXd residual = b - A * x;
+  VERIFY(residual.isZero());
+}
+
+// https://gitlab.com/libeigen/eigen/-/issues/2899
+void test_2899() {
+  Eigen::MatrixXd A = Eigen::MatrixXd::Zero(4, 4);
+  A(0, 0) = 1;
+  A(1, 0) = -1.0 / 6;
+  A(1, 1) = 2.0 / 3;
+  A(1, 2) = -1.0 / 6;
+  A(1, 3) = -1.0 / 3;
+  A(2, 1) = -1.0 / 3;
+  A(2, 2) = 1;
+  A(2, 3) = -2.0 / 3;
+  A(3, 1) = -1.0 / 3;
+  A(3, 2) = -1.0 / 3;
+  A(3, 3) = 2.0 / 3;
+  Eigen::VectorXd b = Eigen::VectorXd::Zero(4);
+  b(0) = 0;
+  b(1) = 1;
+  b(2) = 1;
+  b(3) = 1;
+  Eigen::BiCGSTAB<Eigen::MatrixXd> solver;
+  solver.compute(A);
+  Eigen::VectorXd x = solver.solve(b);
+  Eigen::VectorXd expected(4);
+  expected << 0, 15, 18, 18;
+  VERIFY_IS_APPROX(x, expected);
+  Eigen::VectorXd residual = b - A * x;
+  VERIFY(residual.isZero());
+}
+
+EIGEN_DECLARE_TEST(bicgstab) {
+  CALL_SUBTEST_1((test_bicgstab_T<double, int>()));
+  CALL_SUBTEST_2((test_bicgstab_T<std::complex<double>, int>()));
+  CALL_SUBTEST_3((test_bicgstab_T<double, long int>()));
+  CALL_SUBTEST_4(test_2856());
+  CALL_SUBTEST_5(test_2899());
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/blasutil.cpp

@@ -0,0 +1,178 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2020 Everton Constantino <everton.constantino@ibm.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"
+
+// Disable "ignoring attributes on template argument"
+// for packet_traits<Packet*>
+// => The only workaround would be to wrap _m128 and the likes
+//    within wrappers.
+#if EIGEN_GNUC_STRICT_AT_LEAST(6, 0, 0)
+#pragma GCC diagnostic ignored "-Wignored-attributes"
+#endif
+
+#define GET(i, j) (StorageOrder == RowMajor ? (i) * stride + (j) : (i) + (j) * stride)
+#define SCATTER(i, j, k) (StorageOrder == RowMajor ? ((i) + (k)) * stride + (j) : (i) + ((j) + (k)) * stride)
+
+template <typename Scalar, typename Packet>
+void compare(const Packet& a, const Packet& b) {
+  int pktsz = internal::packet_traits<Scalar>::size;
+  Scalar* buffA = new Scalar[pktsz];
+  Scalar* buffB = new Scalar[pktsz];
+
+  internal::pstoreu<Scalar, Packet>(buffA, a);
+  internal::pstoreu<Scalar, Packet>(buffB, b);
+
+  for (int i = 0; i < pktsz; i++) {
+    VERIFY_IS_EQUAL(buffA[i], buffB[i]);
+  }
+
+  delete[] buffA;
+  delete[] buffB;
+}
+
+template <typename Scalar, int StorageOrder, int n>
+struct PacketBlockSet {
+  typedef typename internal::packet_traits<Scalar>::type Packet;
+
+  void setPacketBlock(internal::PacketBlock<Packet, n>& block, Scalar value) {
+    for (int idx = 0; idx < n; idx++) {
+      block.packet[idx] = internal::pset1<Packet>(value);
+    }
+  }
+
+  void comparePacketBlock(Scalar* data, int i, int j, int stride, internal::PacketBlock<Packet, n>& block) {
+    for (int idx = 0; idx < n; idx++) {
+      Packet line = internal::ploadu<Packet>(data + SCATTER(i, j, idx));
+      compare<Scalar, Packet>(block.packet[idx], line);
+    }
+  }
+};
+
+template <typename Scalar, int StorageOrder, int BlockSize>
+void run_bdmp_spec_1() {
+  typedef internal::blas_data_mapper<Scalar, int, StorageOrder> BlasDataMapper;
+  int packetSize = internal::packet_traits<Scalar>::size;
+  int minSize = std::max<int>(packetSize, BlockSize);
+  typedef typename internal::packet_traits<Scalar>::type Packet;
+
+  int szm = internal::random<int>(minSize, 500), szn = internal::random<int>(minSize, 500);
+  int stride = StorageOrder == RowMajor ? szn : szm;
+  Scalar* d = new Scalar[szn * szm];
+
+  // Initializing with random entries
+  for (int i = 0; i < szm * szn; i++) {
+    d[i] = internal::random<Scalar>(static_cast<Scalar>(3), static_cast<Scalar>(10));
+  }
+
+  BlasDataMapper bdm(d, stride);
+
+  // Testing operator()
+  for (int i = 0; i < szm; i++) {
+    for (int j = 0; j < szn; j++) {
+      VERIFY_IS_EQUAL(d[GET(i, j)], bdm(i, j));
+    }
+  }
+
+  // Testing getSubMapper and getLinearMapper
+  int i0 = internal::random<int>(0, szm - 2);
+  int j0 = internal::random<int>(0, szn - 2);
+  for (int i = i0; i < szm; i++) {
+    for (int j = j0; j < szn; j++) {
+      const BlasDataMapper& bdmSM = bdm.getSubMapper(i0, j0);
+      const internal::BlasLinearMapper<Scalar, int, 0>& bdmLM = bdm.getLinearMapper(i0, j0);
+
+      Scalar v = bdmSM(i - i0, j - j0);
+      Scalar vd = d[GET(i, j)];
+      VERIFY_IS_EQUAL(vd, v);
+      VERIFY_IS_EQUAL(vd, bdmLM(GET(i - i0, j - j0)));
+    }
+  }
+
+  // Testing loadPacket
+  for (int i = 0; i < szm - minSize; i++) {
+    for (int j = 0; j < szn - minSize; j++) {
+      Packet pktBDM = bdm.template loadPacket<Packet>(i, j);
+      Packet pktD = internal::ploadu<Packet>(d + GET(i, j));
+
+      compare<Scalar, Packet>(pktBDM, pktD);
+    }
+  }
+
+  // Testing gatherPacket
+  Scalar* buff = new Scalar[packetSize];
+  for (int i = 0; i < szm - minSize; i++) {
+    for (int j = 0; j < szn - minSize; j++) {
+      Packet p = bdm.template gatherPacket<Packet>(i, j);
+      internal::pstoreu<Scalar, Packet>(buff, p);
+
+      for (int k = 0; k < packetSize; k++) {
+        VERIFY_IS_EQUAL(d[SCATTER(i, j, k)], buff[k]);
+      }
+    }
+  }
+  delete[] buff;
+
+  // Testing scatterPacket
+  for (int i = 0; i < szm - minSize; i++) {
+    for (int j = 0; j < szn - minSize; j++) {
+      Packet p = internal::pset1<Packet>(static_cast<Scalar>(1));
+      bdm.template scatterPacket<Packet>(i, j, p);
+      for (int k = 0; k < packetSize; k++) {
+        VERIFY_IS_EQUAL(d[SCATTER(i, j, k)], static_cast<Scalar>(1));
+      }
+    }
+  }
+
+  // Testing storePacketBlock
+  internal::PacketBlock<Packet, BlockSize> block;
+
+  PacketBlockSet<Scalar, StorageOrder, BlockSize> pbs;
+  pbs.setPacketBlock(block, static_cast<Scalar>(2));
+
+  for (int i = 0; i < szm - minSize; i++) {
+    for (int j = 0; j < szn - minSize; j++) {
+      bdm.template storePacketBlock<Packet, BlockSize>(i, j, block);
+
+      pbs.comparePacketBlock(d, i, j, stride, block);
+    }
+  }
+
+  delete[] d;
+}
+
+template <typename Scalar>
+void run_test() {
+  run_bdmp_spec_1<Scalar, RowMajor, 1>();
+  run_bdmp_spec_1<Scalar, ColMajor, 1>();
+  run_bdmp_spec_1<Scalar, RowMajor, 2>();
+  run_bdmp_spec_1<Scalar, ColMajor, 2>();
+  run_bdmp_spec_1<Scalar, RowMajor, 4>();
+  run_bdmp_spec_1<Scalar, ColMajor, 4>();
+  run_bdmp_spec_1<Scalar, RowMajor, 8>();
+  run_bdmp_spec_1<Scalar, ColMajor, 8>();
+  run_bdmp_spec_1<Scalar, RowMajor, 16>();
+  run_bdmp_spec_1<Scalar, ColMajor, 16>();
+}
+
+EIGEN_DECLARE_TEST(blasutil) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(run_test<numext::int8_t>());
+    CALL_SUBTEST_2(run_test<numext::int16_t>());
+    CALL_SUBTEST_3(run_test<numext::int32_t>());
+
+    // TODO: Replace this by a call to numext::int64_t as soon as we have a way to
+    // detect the typedef for int64_t on all platforms
+    CALL_SUBTEST_4(run_test<signed long long>());
+    CALL_SUBTEST_5(run_test<float_t>());
+    CALL_SUBTEST_6(run_test<double_t>());
+    CALL_SUBTEST_7(run_test<std::complex<float> >());
+    CALL_SUBTEST_8(run_test<std::complex<double> >());
+  }
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/block.cpp

@@ -0,0 +1,381 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2010 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"
+
+template <typename MatrixType, typename Index, typename Scalar>
+std::enable_if_t<!NumTraits<typename MatrixType::Scalar>::IsComplex, typename MatrixType::Scalar> block_real_only(
+    const MatrixType& m1, Index r1, Index r2, Index c1, Index c2, const Scalar& s1) {
+  // check cwise-Functions:
+  VERIFY_IS_APPROX(m1.row(r1).cwiseMax(s1), m1.cwiseMax(s1).row(r1));
+  VERIFY_IS_APPROX(m1.col(c1).cwiseMin(s1), m1.cwiseMin(s1).col(c1));
+
+  VERIFY_IS_APPROX(m1.block(r1, c1, r2 - r1 + 1, c2 - c1 + 1).cwiseMin(s1),
+                   m1.cwiseMin(s1).block(r1, c1, r2 - r1 + 1, c2 - c1 + 1));
+  VERIFY_IS_APPROX(m1.block(r1, c1, r2 - r1 + 1, c2 - c1 + 1).cwiseMax(s1),
+                   m1.cwiseMax(s1).block(r1, c1, r2 - r1 + 1, c2 - c1 + 1));
+
+  return Scalar(0);
+}
+
+template <typename MatrixType, typename Index, typename Scalar>
+std::enable_if_t<NumTraits<typename MatrixType::Scalar>::IsComplex, typename MatrixType::Scalar> block_real_only(
+    const MatrixType&, Index, Index, Index, Index, const Scalar&) {
+  return Scalar(0);
+}
+
+// Check at compile-time that T1==T2, and at runtime-time that a==b
+template <typename T1, typename T2>
+std::enable_if_t<internal::is_same<T1, T2>::value, bool> is_same_block(const T1& a, const T2& b) {
+  return a.isApprox(b);
+}
+
+template <typename MatrixType>
+std::enable_if_t<((MatrixType::Flags & RowMajorBit) == 0), void> check_left_top(const MatrixType& m, Index r, Index c,
+                                                                                Index rows, Index /*unused*/) {
+  if (c > 0) VERIFY_IS_EQUAL(m.leftCols(c).coeff(r + c * rows), m(r, c));
+}
+
+template <typename MatrixType>
+std::enable_if_t<((MatrixType::Flags & RowMajorBit) != 0), void> check_left_top(const MatrixType& m, Index r, Index c,
+                                                                                Index /*unused*/, Index cols) {
+  if (r > 0) VERIFY_IS_EQUAL(m.topRows(r).coeff(c + r * cols), m(r, c));
+}
+
+template <typename MatrixType>
+void block(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
+  typedef Matrix<Scalar, 1, MatrixType::ColsAtCompileTime> RowVectorType;
+  typedef Matrix<Scalar, Dynamic, Dynamic, MatrixType::IsRowMajor ? RowMajor : ColMajor> DynamicMatrixType;
+  typedef Matrix<Scalar, Dynamic, 1> DynamicVectorType;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  MatrixType m1 = MatrixType::Random(rows, cols), m1_copy = m1, m2 = MatrixType::Random(rows, cols), m3(rows, cols),
+             ones = MatrixType::Ones(rows, cols);
+  VectorType v1 = VectorType::Random(rows);
+
+  Scalar s1 = internal::random<Scalar>();
+
+  Index r1 = internal::random<Index>(0, rows - 1);
+  Index r2 = internal::random<Index>(r1, rows - 1);
+  Index c1 = internal::random<Index>(0, cols - 1);
+  Index c2 = internal::random<Index>(c1, cols - 1);
+
+  block_real_only(m1, r1, r2, c1, c1, s1);
+
+  // test fill logic with innerpanel and non-innerpanel blocks
+  m1.row(r1).setConstant(s1);
+  VERIFY_IS_CWISE_EQUAL(m1.row(r1), DynamicVectorType::Constant(cols, s1).transpose());
+  m1 = m1_copy;
+  m1.col(c1).setConstant(s1);
+  VERIFY_IS_CWISE_EQUAL(m1.col(c1), DynamicVectorType::Constant(rows, s1));
+  m1 = m1_copy;
+  // test setZero logic with innerpanel and non-innerpanel blocks
+  m1.row(r1).setZero();
+  VERIFY_IS_CWISE_EQUAL(m1.row(r1), DynamicVectorType::Zero(cols).transpose());
+  m1 = m1_copy;
+  m1.col(c1).setZero();
+  VERIFY_IS_CWISE_EQUAL(m1.col(c1), DynamicVectorType::Zero(rows));
+  m1 = m1_copy;
+
+  // check row() and col()
+  VERIFY_IS_EQUAL(m1.col(c1).transpose(), m1.transpose().row(c1));
+  // check operator(), both constant and non-constant, on row() and col()
+  m1 = m1_copy;
+  m1.row(r1) += s1 * m1_copy.row(r2);
+  VERIFY_IS_APPROX(m1.row(r1), m1_copy.row(r1) + s1 * m1_copy.row(r2));
+  // check nested block xpr on lhs
+  m1.row(r1).row(0) += s1 * m1_copy.row(r2);
+  VERIFY_IS_APPROX(m1.row(r1), m1_copy.row(r1) + Scalar(2) * s1 * m1_copy.row(r2));
+  m1 = m1_copy;
+  m1.col(c1) += s1 * m1_copy.col(c2);
+  VERIFY_IS_APPROX(m1.col(c1), m1_copy.col(c1) + s1 * m1_copy.col(c2));
+  m1.col(c1).col(0) += s1 * m1_copy.col(c2);
+  VERIFY_IS_APPROX(m1.col(c1), m1_copy.col(c1) + Scalar(2) * s1 * m1_copy.col(c2));
+
+  check_left_top(m1, r1, c1, rows, cols);
+
+  // check block()
+  Matrix<Scalar, Dynamic, Dynamic> b1(1, 1);
+  b1(0, 0) = m1(r1, c1);
+
+  RowVectorType br1(m1.block(r1, 0, 1, cols));
+  VectorType bc1(m1.block(0, c1, rows, 1));
+  VERIFY_IS_EQUAL(b1, m1.block(r1, c1, 1, 1));
+  VERIFY_IS_EQUAL(m1.row(r1), br1);
+  VERIFY_IS_EQUAL(m1.col(c1), bc1);
+  // check operator(), both constant and non-constant, on block()
+  m1.block(r1, c1, r2 - r1 + 1, c2 - c1 + 1) = s1 * m2.block(0, 0, r2 - r1 + 1, c2 - c1 + 1);
+  m1.block(r1, c1, r2 - r1 + 1, c2 - c1 + 1)(r2 - r1, c2 - c1) = m2.block(0, 0, r2 - r1 + 1, c2 - c1 + 1)(0, 0);
+
+  const Index BlockRows = 2;
+  const Index BlockCols = 5;
+
+  if (rows >= 5 && cols >= 8) {
+    // test fixed block() as lvalue
+    m1.template block<BlockRows, BlockCols>(1, 1) *= s1;
+    // test operator() on fixed block() both as constant and non-constant
+    m1.template block<BlockRows, BlockCols>(1, 1)(0, 3) = m1.template block<2, 5>(1, 1)(1, 2);
+    // check that fixed block() and block() agree
+    Matrix<Scalar, Dynamic, Dynamic> b = m1.template block<BlockRows, BlockCols>(3, 3);
+    VERIFY_IS_EQUAL(b, m1.block(3, 3, BlockRows, BlockCols));
+
+    // same tests with mixed fixed/dynamic size
+    m1.template block<BlockRows, Dynamic>(1, 1, BlockRows, BlockCols) *= s1;
+    m1.template block<BlockRows, Dynamic>(1, 1, BlockRows, BlockCols)(0, 3) = m1.template block<2, 5>(1, 1)(1, 2);
+    Matrix<Scalar, Dynamic, Dynamic> b2 = m1.template block<Dynamic, BlockCols>(3, 3, 2, 5);
+    VERIFY_IS_EQUAL(b2, m1.block(3, 3, BlockRows, BlockCols));
+
+    VERIFY(is_same_block(m1.block(3, 3, BlockRows, BlockCols),
+                         m1.block(3, 3, fix<Dynamic>(BlockRows), fix<Dynamic>(BlockCols))));
+    VERIFY(is_same_block(m1.template block<BlockRows, Dynamic>(1, 1, BlockRows, BlockCols),
+                         m1.block(1, 1, fix<BlockRows>, BlockCols)));
+    VERIFY(is_same_block(m1.template block<BlockRows, BlockCols>(1, 1, BlockRows, BlockCols),
+                         m1.block(1, 1, fix<BlockRows>(), fix<BlockCols>)));
+    VERIFY(is_same_block(m1.template block<BlockRows, BlockCols>(1, 1, BlockRows, BlockCols),
+                         m1.block(1, 1, fix<BlockRows>, fix<BlockCols>(BlockCols))));
+  }
+
+  if (rows > 2) {
+    // test sub vectors
+    VERIFY_IS_EQUAL(v1.template head<2>(), v1.block(0, 0, 2, 1));
+    VERIFY_IS_EQUAL(v1.template head<2>(), v1.head(2));
+    VERIFY_IS_EQUAL(v1.template head<2>(), v1.segment(0, 2));
+    VERIFY_IS_EQUAL(v1.template head<2>(), v1.template segment<2>(0));
+    Index i = rows - 2;
+    VERIFY_IS_EQUAL(v1.template tail<2>(), v1.block(i, 0, 2, 1));
+    VERIFY_IS_EQUAL(v1.template tail<2>(), v1.tail(2));
+    VERIFY_IS_EQUAL(v1.template tail<2>(), v1.segment(i, 2));
+    VERIFY_IS_EQUAL(v1.template tail<2>(), v1.template segment<2>(i));
+    i = internal::random<Index>(0, rows - 2);
+    VERIFY_IS_EQUAL(v1.segment(i, 2), v1.template segment<2>(i));
+  }
+
+  // stress some basic stuffs with block matrices
+  VERIFY_IS_EQUAL(numext::real(ones.col(c1).sum()), RealScalar(rows));
+  VERIFY_IS_EQUAL(numext::real(ones.row(r1).sum()), RealScalar(cols));
+
+  VERIFY_IS_EQUAL(numext::real(ones.col(c1).dot(ones.col(c2))), RealScalar(rows));
+  VERIFY_IS_EQUAL(numext::real(ones.row(r1).dot(ones.row(r2))), RealScalar(cols));
+
+  // check that linear accessors works on blocks
+  m1 = m1_copy;
+
+  // now test some block-inside-of-block.
+
+  // expressions with direct access
+  VERIFY_IS_EQUAL((m1.block(r1, c1, rows - r1, cols - c1).block(r2 - r1, c2 - c1, rows - r2, cols - c2)),
+                  (m1.block(r2, c2, rows - r2, cols - c2)));
+  VERIFY_IS_EQUAL((m1.block(r1, c1, r2 - r1 + 1, c2 - c1 + 1).row(0)), (m1.row(r1).segment(c1, c2 - c1 + 1)));
+  VERIFY_IS_EQUAL((m1.block(r1, c1, r2 - r1 + 1, c2 - c1 + 1).col(0)), (m1.col(c1).segment(r1, r2 - r1 + 1)));
+  VERIFY_IS_EQUAL((m1.block(r1, c1, r2 - r1 + 1, c2 - c1 + 1).transpose().col(0)),
+                  (m1.row(r1).segment(c1, c2 - c1 + 1)).transpose());
+  VERIFY_IS_EQUAL((m1.transpose().block(c1, r1, c2 - c1 + 1, r2 - r1 + 1).col(0)),
+                  (m1.row(r1).segment(c1, c2 - c1 + 1)).transpose());
+
+  // expressions without direct access
+  VERIFY_IS_APPROX(((m1 + m2).block(r1, c1, rows - r1, cols - c1).block(r2 - r1, c2 - c1, rows - r2, cols - c2)),
+                   ((m1 + m2).block(r2, c2, rows - r2, cols - c2)));
+  VERIFY_IS_APPROX(((m1 + m2).block(r1, c1, r2 - r1 + 1, c2 - c1 + 1).row(0)),
+                   ((m1 + m2).row(r1).segment(c1, c2 - c1 + 1)));
+  VERIFY_IS_APPROX(((m1 + m2).block(r1, c1, r2 - r1 + 1, c2 - c1 + 1).row(0)),
+                   ((m1 + m2).eval().row(r1).segment(c1, c2 - c1 + 1)));
+  VERIFY_IS_APPROX(((m1 + m2).block(r1, c1, r2 - r1 + 1, c2 - c1 + 1).col(0)),
+                   ((m1 + m2).col(c1).segment(r1, r2 - r1 + 1)));
+  VERIFY_IS_APPROX(((m1 + m2).block(r1, c1, r2 - r1 + 1, c2 - c1 + 1).transpose().col(0)),
+                   ((m1 + m2).row(r1).segment(c1, c2 - c1 + 1)).transpose());
+  VERIFY_IS_APPROX(((m1 + m2).transpose().block(c1, r1, c2 - c1 + 1, r2 - r1 + 1).col(0)),
+                   ((m1 + m2).row(r1).segment(c1, c2 - c1 + 1)).transpose());
+  VERIFY_IS_APPROX(((m1 + m2).template block<Dynamic, 1>(r1, c1, r2 - r1 + 1, 1)),
+                   ((m1 + m2).eval().col(c1).eval().segment(r1, r2 - r1 + 1)));
+  VERIFY_IS_APPROX(((m1 + m2).template block<1, Dynamic>(r1, c1, 1, c2 - c1 + 1)),
+                   ((m1 + m2).eval().row(r1).eval().segment(c1, c2 - c1 + 1)));
+  VERIFY_IS_APPROX(((m1 + m2).transpose().template block<1, Dynamic>(c1, r1, 1, r2 - r1 + 1)),
+                   ((m1 + m2).eval().col(c1).eval().segment(r1, r2 - r1 + 1)).transpose());
+  VERIFY_IS_APPROX((m1 + m2).row(r1).eval(), (m1 + m2).eval().row(r1));
+  VERIFY_IS_APPROX((m1 + m2).adjoint().col(r1).eval(), (m1 + m2).adjoint().eval().col(r1));
+  VERIFY_IS_APPROX((m1 + m2).adjoint().row(c1).eval(), (m1 + m2).adjoint().eval().row(c1));
+  VERIFY_IS_APPROX((m1 * 1).row(r1).segment(c1, c2 - c1 + 1).eval(), m1.row(r1).eval().segment(c1, c2 - c1 + 1).eval());
+  VERIFY_IS_APPROX(m1.col(c1).reverse().segment(r1, r2 - r1 + 1).eval(),
+                   m1.col(c1).reverse().eval().segment(r1, r2 - r1 + 1).eval());
+
+  VERIFY_IS_APPROX((m1 * 1).topRows(r1), m1.topRows(r1));
+  VERIFY_IS_APPROX((m1 * 1).leftCols(c1), m1.leftCols(c1));
+  VERIFY_IS_APPROX((m1 * 1).transpose().topRows(c1), m1.transpose().topRows(c1));
+  VERIFY_IS_APPROX((m1 * 1).transpose().leftCols(r1), m1.transpose().leftCols(r1));
+  VERIFY_IS_APPROX((m1 * 1).transpose().middleRows(c1, c2 - c1 + 1), m1.transpose().middleRows(c1, c2 - c1 + 1));
+  VERIFY_IS_APPROX((m1 * 1).transpose().middleCols(r1, r2 - r1 + 1), m1.transpose().middleCols(r1, r2 - r1 + 1));
+
+  // evaluation into plain matrices from expressions with direct access (stress MapBase)
+  DynamicMatrixType dm;
+  DynamicVectorType dv;
+  dm.setZero();
+  dm = m1.block(r1, c1, rows - r1, cols - c1).block(r2 - r1, c2 - c1, rows - r2, cols - c2);
+  VERIFY_IS_EQUAL(dm, (m1.block(r2, c2, rows - r2, cols - c2)));
+  dm.setZero();
+  dv.setZero();
+  dm = m1.block(r1, c1, r2 - r1 + 1, c2 - c1 + 1).row(0).transpose();
+  dv = m1.row(r1).segment(c1, c2 - c1 + 1);
+  VERIFY_IS_EQUAL(dv, dm);
+  dm.setZero();
+  dv.setZero();
+  dm = m1.col(c1).segment(r1, r2 - r1 + 1);
+  dv = m1.block(r1, c1, r2 - r1 + 1, c2 - c1 + 1).col(0);
+  VERIFY_IS_EQUAL(dv, dm);
+  dm.setZero();
+  dv.setZero();
+  dm = m1.block(r1, c1, r2 - r1 + 1, c2 - c1 + 1).transpose().col(0);
+  dv = m1.row(r1).segment(c1, c2 - c1 + 1);
+  VERIFY_IS_EQUAL(dv, dm);
+  dm.setZero();
+  dv.setZero();
+  dm = m1.row(r1).segment(c1, c2 - c1 + 1).transpose();
+  dv = m1.transpose().block(c1, r1, c2 - c1 + 1, r2 - r1 + 1).col(0);
+  VERIFY_IS_EQUAL(dv, dm);
+
+  VERIFY_IS_EQUAL((m1.template block<Dynamic, 1>(1, 0, 0, 1)), m1.block(1, 0, 0, 1));
+  VERIFY_IS_EQUAL((m1.template block<1, Dynamic>(0, 1, 1, 0)), m1.block(0, 1, 1, 0));
+  VERIFY_IS_EQUAL(((m1 * 1).template block<Dynamic, 1>(1, 0, 0, 1)), m1.block(1, 0, 0, 1));
+  VERIFY_IS_EQUAL(((m1 * 1).template block<1, Dynamic>(0, 1, 1, 0)), m1.block(0, 1, 1, 0));
+
+  VERIFY_IS_EQUAL(m1.template subVector<Horizontal>(r1), m1.row(r1));
+  VERIFY_IS_APPROX((m1 + m1).template subVector<Horizontal>(r1), (m1 + m1).row(r1));
+  VERIFY_IS_EQUAL(m1.template subVector<Vertical>(c1), m1.col(c1));
+  VERIFY_IS_APPROX((m1 + m1).template subVector<Vertical>(c1), (m1 + m1).col(c1));
+  VERIFY_IS_EQUAL(m1.template subVectors<Horizontal>(), m1.rows());
+  VERIFY_IS_EQUAL(m1.template subVectors<Vertical>(), m1.cols());
+
+  if (rows >= 2 || cols >= 2) {
+    VERIFY_IS_EQUAL(int(m1.middleCols(0, 0).IsRowMajor), int(m1.IsRowMajor));
+    VERIFY_IS_EQUAL(m1.middleCols(0, 0).outerSize(), m1.IsRowMajor ? rows : 0);
+    VERIFY_IS_EQUAL(m1.middleCols(0, 0).innerSize(), m1.IsRowMajor ? 0 : rows);
+
+    VERIFY_IS_EQUAL(int(m1.middleRows(0, 0).IsRowMajor), int(m1.IsRowMajor));
+    VERIFY_IS_EQUAL(m1.middleRows(0, 0).outerSize(), m1.IsRowMajor ? 0 : cols);
+    VERIFY_IS_EQUAL(m1.middleRows(0, 0).innerSize(), m1.IsRowMajor ? cols : 0);
+  }
+}
+
+template <typename MatrixType>
+std::enable_if_t<MatrixType::IsVectorAtCompileTime, void> compare_using_data_and_stride(const MatrixType& m) {
+  Index rows = m.rows();
+  Index cols = m.cols();
+  Index size = m.size();
+  Index innerStride = m.innerStride();
+  Index rowStride = m.rowStride();
+  Index colStride = m.colStride();
+  const typename MatrixType::Scalar* data = m.data();
+
+  for (int j = 0; j < cols; ++j)
+    for (int i = 0; i < rows; ++i) VERIFY(m.coeff(i, j) == data[i * rowStride + j * colStride]);
+
+  VERIFY(innerStride == int((&m.coeff(1)) - (&m.coeff(0))));
+  for (int i = 0; i < size; ++i) VERIFY(m.coeff(i) == data[i * innerStride]);
+}
+
+template <typename MatrixType>
+std::enable_if_t<!MatrixType::IsVectorAtCompileTime, void> compare_using_data_and_stride(const MatrixType& m) {
+  Index rows = m.rows();
+  Index cols = m.cols();
+  Index innerStride = m.innerStride();
+  Index outerStride = m.outerStride();
+  Index rowStride = m.rowStride();
+  Index colStride = m.colStride();
+  const typename MatrixType::Scalar* data = m.data();
+
+  for (int j = 0; j < cols; ++j)
+    for (int i = 0; i < rows; ++i) VERIFY(m.coeff(i, j) == data[i * rowStride + j * colStride]);
+
+  for (int j = 0; j < cols; ++j)
+    for (int i = 0; i < rows; ++i)
+      VERIFY(m.coeff(i, j) == data[(MatrixType::Flags & RowMajorBit) ? i * outerStride + j * innerStride
+                                                                     : j * outerStride + i * innerStride]);
+}
+
+template <typename MatrixType>
+void data_and_stride(const MatrixType& m) {
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  Index r1 = internal::random<Index>(0, rows - 1);
+  Index r2 = internal::random<Index>(r1, rows - 1);
+  Index c1 = internal::random<Index>(0, cols - 1);
+  Index c2 = internal::random<Index>(c1, cols - 1);
+
+  MatrixType m1 = MatrixType::Random(rows, cols);
+  compare_using_data_and_stride(m1.block(r1, c1, r2 - r1 + 1, c2 - c1 + 1));
+  compare_using_data_and_stride(m1.transpose().block(c1, r1, c2 - c1 + 1, r2 - r1 + 1));
+  compare_using_data_and_stride(m1.row(r1));
+  compare_using_data_and_stride(m1.col(c1));
+  compare_using_data_and_stride(m1.row(r1).transpose());
+  compare_using_data_and_stride(m1.col(c1).transpose());
+}
+
+template <typename BaseXpr, typename Xpr = BaseXpr, int Depth = 0>
+struct unwind_test_impl {
+  static void run(Xpr& xpr) {
+    Index startRow = internal::random<Index>(0, xpr.rows() / 5);
+    Index startCol = internal::random<Index>(0, xpr.cols() / 6);
+    Index rows = xpr.rows() / 3;
+    Index cols = xpr.cols() / 2;
+    // test equivalence of const expressions
+    const Block<const Xpr> constNestedBlock(xpr, startRow, startCol, rows, cols);
+    const Block<const BaseXpr> constUnwoundBlock = constNestedBlock.unwind();
+    VERIFY_IS_CWISE_EQUAL(constNestedBlock, constUnwoundBlock);
+    // modify a random element in each representation and test equivalence of non-const expressions
+    Block<Xpr> nestedBlock(xpr, startRow, startCol, rows, cols);
+    Block<BaseXpr> unwoundBlock = nestedBlock.unwind();
+    Index r1 = internal::random<Index>(0, rows - 1);
+    Index c1 = internal::random<Index>(0, cols - 1);
+    Index r2 = internal::random<Index>(0, rows - 1);
+    Index c2 = internal::random<Index>(0, cols - 1);
+    nestedBlock.coeffRef(r1, c1) = internal::random<typename DenseBase<Xpr>::Scalar>();
+    unwoundBlock.coeffRef(r2, c2) = internal::random<typename DenseBase<Xpr>::Scalar>();
+    VERIFY_IS_CWISE_EQUAL(nestedBlock, unwoundBlock);
+    unwind_test_impl<BaseXpr, Block<Xpr>, Depth + 1>::run(nestedBlock);
+  }
+};
+
+template <typename BaseXpr, typename Xpr>
+struct unwind_test_impl<BaseXpr, Xpr, 4> {
+  static void run(const Xpr&) {}
+};
+
+template <typename BaseXpr>
+void unwind_test(const BaseXpr&) {
+  BaseXpr xpr = BaseXpr::Random(100, 100);
+  unwind_test_impl<BaseXpr>::run(xpr);
+}
+
+EIGEN_DECLARE_TEST(block) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(block(Matrix<float, 1, 1>()));
+    CALL_SUBTEST_1(block(Matrix<float, 1, Dynamic>(internal::random(2, 50))));
+    CALL_SUBTEST_1(block(Matrix<float, Dynamic, 1>(internal::random(2, 50))));
+    CALL_SUBTEST_2(block(Matrix4d()));
+    CALL_SUBTEST_3(block(MatrixXcf(internal::random(2, 50), internal::random(2, 50))));
+    CALL_SUBTEST_4(block(MatrixXi(internal::random(2, 50), internal::random(2, 50))));
+    CALL_SUBTEST_5(block(MatrixXcd(internal::random(2, 50), internal::random(2, 50))));
+    CALL_SUBTEST_6(block(MatrixXf(internal::random(2, 50), internal::random(2, 50))));
+    CALL_SUBTEST_7(block(Matrix<int, Dynamic, Dynamic, RowMajor>(internal::random(2, 50), internal::random(2, 50))));
+
+    CALL_SUBTEST_8(block(Matrix<float, Dynamic, 4>(3, 4)));
+    CALL_SUBTEST_9(unwind_test(MatrixXf()));
+
+#ifndef EIGEN_DEFAULT_TO_ROW_MAJOR
+    CALL_SUBTEST_6(data_and_stride(MatrixXf(internal::random(5, 50), internal::random(5, 50))));
+    CALL_SUBTEST_7(
+        data_and_stride(Matrix<int, Dynamic, Dynamic, RowMajor>(internal::random(5, 50), internal::random(5, 50))));
+#endif
+  }
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/boostmultiprec.cpp

@@ -0,0 +1,212 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 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/.
+
+#include <sstream>
+
+#ifdef EIGEN_TEST_MAX_SIZE
+#undef EIGEN_TEST_MAX_SIZE
+#endif
+
+#define EIGEN_TEST_MAX_SIZE 50
+
+#ifdef EIGEN_TEST_PART_1
+#include "cholesky.cpp"
+#endif
+
+#ifdef EIGEN_TEST_PART_2
+#include "lu.cpp"
+#endif
+
+#ifdef EIGEN_TEST_PART_3
+#include "qr.cpp"
+#endif
+
+#ifdef EIGEN_TEST_PART_4
+#include "qr_colpivoting.cpp"
+#endif
+
+#ifdef EIGEN_TEST_PART_5
+#include "qr_fullpivoting.cpp"
+#endif
+
+#ifdef EIGEN_TEST_PART_6
+#include "eigensolver_selfadjoint.cpp"
+#endif
+
+#ifdef EIGEN_TEST_PART_7
+#include "eigensolver_generic.cpp"
+#endif
+
+#ifdef EIGEN_TEST_PART_8
+#include "eigensolver_generalized_real.cpp"
+#endif
+
+#ifdef EIGEN_TEST_PART_9
+#include "jacobisvd.cpp"
+#endif
+
+#ifdef EIGEN_TEST_PART_10
+#include "bdcsvd.cpp"
+#endif
+
+#ifdef EIGEN_TEST_PART_11
+#include "simplicial_cholesky.cpp"
+#endif
+
+#include <Eigen/Dense>
+
+#undef min
+#undef max
+#undef isnan
+#undef isinf
+#undef isfinite
+#undef I
+
+#include <boost/serialization/nvp.hpp>
+#include <boost/multiprecision/cpp_dec_float.hpp>
+#include <boost/multiprecision/number.hpp>
+#include <boost/math/special_functions.hpp>
+#include <boost/math/complex.hpp>
+
+typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_on> Real;
+
+namespace Eigen {
+template <>
+struct NumTraits<Real> : GenericNumTraits<Real> {
+  static inline Real dummy_precision() { return 1e-50; }
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+struct NumTraits<boost::multiprecision::detail::expression<T1, T2, T3, T4, T5> > : NumTraits<Real> {};
+
+template <>
+Real test_precision<Real>() {
+  return 1e-50;
+}
+
+// needed in C++93 mode where number does not support explicit cast.
+namespace internal {
+template <typename NewType>
+struct cast_impl<Real, NewType> {
+  static inline NewType run(const Real& x) { return x.template convert_to<NewType>(); }
+};
+
+template <>
+struct cast_impl<Real, std::complex<Real> > {
+  static inline std::complex<Real> run(const Real& x) { return std::complex<Real>(x); }
+};
+}  // namespace internal
+}  // namespace Eigen
+
+namespace boost {
+namespace multiprecision {
+// to make ADL works as expected:
+using boost::math::copysign;
+using boost::math::hypot;
+using boost::math::isfinite;
+using boost::math::isinf;
+using boost::math::isnan;
+
+// The following is needed for std::complex<Real>:
+Real fabs(const Real& a) { return abs EIGEN_NOT_A_MACRO(a); }
+Real fmax(const Real& a, const Real& b) {
+  using std::max;
+  return max(a, b);
+}
+
+// some specialization for the unit tests:
+inline bool test_isMuchSmallerThan(const Real& a, const Real& b) {
+  return internal::isMuchSmallerThan(a, b, test_precision<Real>());
+}
+
+inline bool test_isApprox(const Real& a, const Real& b) { return internal::isApprox(a, b, test_precision<Real>()); }
+
+inline bool test_isApproxOrLessThan(const Real& a, const Real& b) {
+  return internal::isApproxOrLessThan(a, b, test_precision<Real>());
+}
+
+Real get_test_precision(const Real&) { return test_precision<Real>(); }
+
+Real test_relative_error(const Real& a, const Real& b) {
+  using Eigen::numext::abs2;
+  return sqrt(abs2<Real>(a - b) / Eigen::numext::mini<Real>(abs2(a), abs2(b)));
+}
+}  // namespace multiprecision
+}  // namespace boost
+
+namespace Eigen {}
+
+EIGEN_DECLARE_TEST(boostmultiprec) {
+  typedef Matrix<Real, Dynamic, Dynamic> Mat;
+  typedef Matrix<std::complex<Real>, Dynamic, Dynamic> MatC;
+
+  std::cout << "NumTraits<Real>::epsilon()         = " << NumTraits<Real>::epsilon() << std::endl;
+  std::cout << "NumTraits<Real>::dummy_precision() = " << NumTraits<Real>::dummy_precision() << std::endl;
+  std::cout << "NumTraits<Real>::lowest()          = " << NumTraits<Real>::lowest() << std::endl;
+  std::cout << "NumTraits<Real>::highest()         = " << NumTraits<Real>::highest() << std::endl;
+  std::cout << "NumTraits<Real>::digits10()        = " << NumTraits<Real>::digits10() << std::endl;
+  std::cout << "NumTraits<Real>::max_digits10()    = " << NumTraits<Real>::max_digits10() << std::endl;
+
+  // check stream output
+  {
+    Mat A(10, 10);
+    A.setRandom();
+    std::stringstream ss;
+    ss << A;
+  }
+  {
+    MatC A(10, 10);
+    A.setRandom();
+    std::stringstream ss;
+    ss << A;
+  }
+
+  for (int i = 0; i < g_repeat; i++) {
+    int s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE);
+
+    CALL_SUBTEST_1(cholesky(Mat(s, s)));
+
+    CALL_SUBTEST_2(lu_non_invertible<Mat>());
+    CALL_SUBTEST_2(lu_invertible<Mat>());
+    CALL_SUBTEST_2(lu_non_invertible<MatC>());
+    CALL_SUBTEST_2(lu_invertible<MatC>());
+
+    CALL_SUBTEST_3(
+        qr(Mat(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_3(qr_invertible<Mat>());
+
+    CALL_SUBTEST_4(qr<Mat>());
+    CALL_SUBTEST_4(cod<Mat>());
+    CALL_SUBTEST_4(qr_invertible<Mat>());
+
+    CALL_SUBTEST_5(qr<Mat>());
+    CALL_SUBTEST_5(qr_invertible<Mat>());
+
+    CALL_SUBTEST_6(selfadjointeigensolver(Mat(s, s)));
+
+    CALL_SUBTEST_7(eigensolver(Mat(s, s)));
+
+    CALL_SUBTEST_8(generalized_eigensolver_real(Mat(s, s)));
+
+    TEST_SET_BUT_UNUSED_VARIABLE(s)
+  }
+
+  CALL_SUBTEST_9(
+      (jacobisvd_thin_options(Mat(internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE),
+                                  internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE / 2)))));
+  CALL_SUBTEST_9(
+      (jacobisvd_full_options(Mat(internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE),
+                                  internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE / 2)))));
+  CALL_SUBTEST_10((bdcsvd_thin_options(Mat(internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE),
+                                           internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE / 2)))));
+  CALL_SUBTEST_10((bdcsvd_full_options(Mat(internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE),
+                                           internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE / 2)))));
+
+  CALL_SUBTEST_11((test_simplicial_cholesky_T<Real, int, ColMajor>()));
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/bug1213.cpp

@@ -0,0 +1,7 @@
+
+// This anonymous enum is essential to trigger the linking issue
+enum { Foo };
+
+#include "bug1213.h"
+
+bool bug1213_1(const Eigen::Vector3f& x) { return bug1213_2(x); }

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/bug1213.h

@@ -0,0 +1,7 @@
+
+#include <Eigen/Core>
+
+template <typename T, int dim>
+bool bug1213_2(const Eigen::Matrix<T, dim, 1>& x);
+
+bool bug1213_1(const Eigen::Vector3f& x);

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/bug1213_main.cpp

@@ -0,0 +1,13 @@
+
+// This is a regression unit regarding a weird linking issue with gcc.
+
+#include "bug1213.h"
+
+int main() { return 0; }
+
+template <typename T, int dim>
+bool bug1213_2(const Eigen::Matrix<T, dim, 1>&) {
+  return true;
+}
+
+template bool bug1213_2<float, 3>(const Eigen::Vector3f&);

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/cholesky.cpp

@@ -0,0 +1,500 @@
+// 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/.
+
+#define TEST_ENABLE_TEMPORARY_TRACKING
+
+#include "main.h"
+#include <Eigen/Cholesky>
+#include <Eigen/QR>
+#include "solverbase.h"
+
+template <typename MatrixType, int UpLo>
+typename MatrixType::RealScalar matrix_l1_norm(const MatrixType& m) {
+  if (m.cols() == 0) return typename MatrixType::RealScalar(0);
+  MatrixType symm = m.template selfadjointView<UpLo>();
+  return symm.cwiseAbs().colwise().sum().maxCoeff();
+}
+
+template <typename MatrixType, template <typename, int> class CholType>
+void test_chol_update(const MatrixType& symm) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
+
+  MatrixType symmLo = symm.template triangularView<Lower>();
+  MatrixType symmUp = symm.template triangularView<Upper>();
+  MatrixType symmCpy = symm;
+
+  CholType<MatrixType, Lower> chollo(symmLo);
+  CholType<MatrixType, Upper> cholup(symmUp);
+
+  for (int k = 0; k < 10; ++k) {
+    VectorType vec = VectorType::Random(symm.rows());
+    RealScalar sigma = internal::random<RealScalar>();
+    symmCpy += sigma * vec * vec.adjoint();
+
+    // we are doing some downdates, so it might be the case that the matrix is not SPD anymore
+    CholType<MatrixType, Lower> chol(symmCpy);
+    if (chol.info() != Success) break;
+
+    chollo.rankUpdate(vec, sigma);
+    VERIFY_IS_APPROX(symmCpy, chollo.reconstructedMatrix());
+
+    cholup.rankUpdate(vec, sigma);
+    VERIFY_IS_APPROX(symmCpy, cholup.reconstructedMatrix());
+  }
+}
+
+template <typename MatrixType>
+void cholesky(const MatrixType& m) {
+  /* this test covers the following files:
+     LLT.h LDLT.h
+  */
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> SquareMatrixType;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
+
+  MatrixType a0 = MatrixType::Random(rows, cols);
+  VectorType vecB = VectorType::Random(rows), vecX(rows);
+  MatrixType matB = MatrixType::Random(rows, cols), matX(rows, cols);
+  SquareMatrixType symm = a0 * a0.adjoint();
+  // let's make sure the matrix is not singular or near singular
+  for (int k = 0; k < 3; ++k) {
+    MatrixType a1 = MatrixType::Random(rows, cols);
+    symm += a1 * a1.adjoint();
+  }
+
+  {
+    STATIC_CHECK((internal::is_same<typename LLT<MatrixType, Lower>::StorageIndex, int>::value));
+    STATIC_CHECK((internal::is_same<typename LLT<MatrixType, Upper>::StorageIndex, int>::value));
+
+    SquareMatrixType symmUp = symm.template triangularView<Upper>();
+    SquareMatrixType symmLo = symm.template triangularView<Lower>();
+
+    LLT<SquareMatrixType, Lower> chollo(symmLo);
+    VERIFY_IS_APPROX(symm, chollo.reconstructedMatrix());
+
+    check_solverbase<VectorType, VectorType>(symm, chollo, rows, rows, 1);
+    check_solverbase<MatrixType, MatrixType>(symm, chollo, rows, cols, rows);
+
+    const MatrixType symmLo_inverse = chollo.solve(MatrixType::Identity(rows, cols));
+    RealScalar rcond =
+        (RealScalar(1) / matrix_l1_norm<MatrixType, Lower>(symmLo)) / matrix_l1_norm<MatrixType, Lower>(symmLo_inverse);
+    RealScalar rcond_est = chollo.rcond();
+    // Verify that the estimated condition number is within a factor of 10 of the
+    // truth.
+    VERIFY(rcond_est >= rcond / 10 && rcond_est <= rcond * 10);
+
+    // test the upper mode
+    LLT<SquareMatrixType, Upper> cholup(symmUp);
+    VERIFY_IS_APPROX(symm, cholup.reconstructedMatrix());
+    vecX = cholup.solve(vecB);
+    VERIFY_IS_APPROX(symm * vecX, vecB);
+    matX = cholup.solve(matB);
+    VERIFY_IS_APPROX(symm * matX, matB);
+
+    // Verify that the estimated condition number is within a factor of 10 of the
+    // truth.
+    const MatrixType symmUp_inverse = cholup.solve(MatrixType::Identity(rows, cols));
+    rcond =
+        (RealScalar(1) / matrix_l1_norm<MatrixType, Upper>(symmUp)) / matrix_l1_norm<MatrixType, Upper>(symmUp_inverse);
+    rcond_est = cholup.rcond();
+    VERIFY(rcond_est >= rcond / 10 && rcond_est <= rcond * 10);
+
+    MatrixType neg = -symmLo;
+    chollo.compute(neg);
+    VERIFY(neg.size() == 0 || chollo.info() == NumericalIssue);
+
+    VERIFY_IS_APPROX(MatrixType(chollo.matrixL().transpose().conjugate()), MatrixType(chollo.matrixU()));
+    VERIFY_IS_APPROX(MatrixType(chollo.matrixU().transpose().conjugate()), MatrixType(chollo.matrixL()));
+    VERIFY_IS_APPROX(MatrixType(cholup.matrixL().transpose().conjugate()), MatrixType(cholup.matrixU()));
+    VERIFY_IS_APPROX(MatrixType(cholup.matrixU().transpose().conjugate()), MatrixType(cholup.matrixL()));
+
+    // test some special use cases of SelfCwiseBinaryOp:
+    MatrixType m1 = MatrixType::Random(rows, cols), m2(rows, cols);
+    m2 = m1;
+    m2 += symmLo.template selfadjointView<Lower>().llt().solve(matB);
+    VERIFY_IS_APPROX(m2, m1 + symmLo.template selfadjointView<Lower>().llt().solve(matB));
+    m2 = m1;
+    m2 -= symmLo.template selfadjointView<Lower>().llt().solve(matB);
+    VERIFY_IS_APPROX(m2, m1 - symmLo.template selfadjointView<Lower>().llt().solve(matB));
+    m2 = m1;
+    m2.noalias() += symmLo.template selfadjointView<Lower>().llt().solve(matB);
+    VERIFY_IS_APPROX(m2, m1 + symmLo.template selfadjointView<Lower>().llt().solve(matB));
+    m2 = m1;
+    m2.noalias() -= symmLo.template selfadjointView<Lower>().llt().solve(matB);
+    VERIFY_IS_APPROX(m2, m1 - symmLo.template selfadjointView<Lower>().llt().solve(matB));
+  }
+
+  // LDLT
+  {
+    STATIC_CHECK((internal::is_same<typename LDLT<MatrixType, Lower>::StorageIndex, int>::value));
+    STATIC_CHECK((internal::is_same<typename LDLT<MatrixType, Upper>::StorageIndex, int>::value));
+
+    int sign = internal::random<int>() % 2 ? 1 : -1;
+
+    if (sign == -1) {
+      symm = -symm;  // test a negative matrix
+    }
+
+    SquareMatrixType symmUp = symm.template triangularView<Upper>();
+    SquareMatrixType symmLo = symm.template triangularView<Lower>();
+
+    LDLT<SquareMatrixType, Lower> ldltlo(symmLo);
+    VERIFY(ldltlo.info() == Success);
+    VERIFY_IS_APPROX(symm, ldltlo.reconstructedMatrix());
+
+    check_solverbase<VectorType, VectorType>(symm, ldltlo, rows, rows, 1);
+    check_solverbase<MatrixType, MatrixType>(symm, ldltlo, rows, cols, rows);
+
+    const MatrixType symmLo_inverse = ldltlo.solve(MatrixType::Identity(rows, cols));
+    RealScalar rcond =
+        (RealScalar(1) / matrix_l1_norm<MatrixType, Lower>(symmLo)) / matrix_l1_norm<MatrixType, Lower>(symmLo_inverse);
+    RealScalar rcond_est = ldltlo.rcond();
+    // Verify that the estimated condition number is within a factor of 10 of the
+    // truth.
+    VERIFY(rcond_est >= rcond / 10 && rcond_est <= rcond * 10);
+
+    LDLT<SquareMatrixType, Upper> ldltup(symmUp);
+    VERIFY(ldltup.info() == Success);
+    VERIFY_IS_APPROX(symm, ldltup.reconstructedMatrix());
+    vecX = ldltup.solve(vecB);
+    VERIFY_IS_APPROX(symm * vecX, vecB);
+    matX = ldltup.solve(matB);
+    VERIFY_IS_APPROX(symm * matX, matB);
+
+    // Verify that the estimated condition number is within a factor of 10 of the
+    // truth.
+    const MatrixType symmUp_inverse = ldltup.solve(MatrixType::Identity(rows, cols));
+    rcond =
+        (RealScalar(1) / matrix_l1_norm<MatrixType, Upper>(symmUp)) / matrix_l1_norm<MatrixType, Upper>(symmUp_inverse);
+    rcond_est = ldltup.rcond();
+    VERIFY(rcond_est >= rcond / 10 && rcond_est <= rcond * 10);
+
+    VERIFY_IS_APPROX(MatrixType(ldltlo.matrixL().transpose().conjugate()), MatrixType(ldltlo.matrixU()));
+    VERIFY_IS_APPROX(MatrixType(ldltlo.matrixU().transpose().conjugate()), MatrixType(ldltlo.matrixL()));
+    VERIFY_IS_APPROX(MatrixType(ldltup.matrixL().transpose().conjugate()), MatrixType(ldltup.matrixU()));
+    VERIFY_IS_APPROX(MatrixType(ldltup.matrixU().transpose().conjugate()), MatrixType(ldltup.matrixL()));
+
+    if (MatrixType::RowsAtCompileTime == Dynamic) {
+      // note : each inplace permutation requires a small temporary vector (mask)
+
+      // check inplace solve
+      matX = matB;
+      VERIFY_EVALUATION_COUNT(matX = ldltlo.solve(matX), 0);
+      VERIFY_IS_APPROX(matX, ldltlo.solve(matB).eval());
+
+      matX = matB;
+      VERIFY_EVALUATION_COUNT(matX = ldltup.solve(matX), 0);
+      VERIFY_IS_APPROX(matX, ldltup.solve(matB).eval());
+    }
+
+    // restore
+    if (sign == -1) symm = -symm;
+
+    // check matrices coming from linear constraints with Lagrange multipliers
+    if (rows >= 3) {
+      SquareMatrixType A = symm;
+      Index c = internal::random<Index>(0, rows - 2);
+      A.bottomRightCorner(c, c).setZero();
+      // Make sure a solution exists:
+      vecX.setRandom();
+      vecB = A * vecX;
+      vecX.setZero();
+      ldltlo.compute(A);
+      VERIFY_IS_APPROX(A, ldltlo.reconstructedMatrix());
+      vecX = ldltlo.solve(vecB);
+      VERIFY_IS_APPROX(A * vecX, vecB);
+    }
+
+    // check non-full rank matrices
+    if (rows >= 3) {
+      Index r = internal::random<Index>(1, rows - 1);
+      Matrix<Scalar, Dynamic, Dynamic> a = Matrix<Scalar, Dynamic, Dynamic>::Random(rows, r);
+      SquareMatrixType A = a * a.adjoint();
+      // Make sure a solution exists:
+      vecX.setRandom();
+      vecB = A * vecX;
+      vecX.setZero();
+      ldltlo.compute(A);
+      VERIFY_IS_APPROX(A, ldltlo.reconstructedMatrix());
+      vecX = ldltlo.solve(vecB);
+      VERIFY_IS_APPROX(A * vecX, vecB);
+    }
+
+    // check matrices with a wide spectrum
+    if (rows >= 3) {
+      using std::pow;
+      using std::sqrt;
+      RealScalar s = (std::min)(16, std::numeric_limits<RealScalar>::max_exponent10 / 8);
+      Matrix<Scalar, Dynamic, Dynamic> a = Matrix<Scalar, Dynamic, Dynamic>::Random(rows, rows);
+      Matrix<RealScalar, Dynamic, 1> d = Matrix<RealScalar, Dynamic, 1>::Random(rows);
+      for (Index k = 0; k < rows; ++k) d(k) = d(k) * pow(RealScalar(10), internal::random<RealScalar>(-s, s));
+      SquareMatrixType A = a * d.asDiagonal() * a.adjoint();
+      // Make sure a solution exists:
+      vecX.setRandom();
+      vecB = A * vecX;
+      vecX.setZero();
+      ldltlo.compute(A);
+      VERIFY_IS_APPROX(A, ldltlo.reconstructedMatrix());
+      vecX = ldltlo.solve(vecB);
+
+      if (ldltlo.vectorD().real().cwiseAbs().minCoeff() > RealScalar(0)) {
+        VERIFY_IS_APPROX(A * vecX, vecB);
+      } else {
+        RealScalar large_tol = sqrt(test_precision<RealScalar>());
+        VERIFY((A * vecX).isApprox(vecB, large_tol));
+
+        ++g_test_level;
+        VERIFY_IS_APPROX(A * vecX, vecB);
+        --g_test_level;
+      }
+    }
+  }
+
+  // update/downdate
+  CALL_SUBTEST((test_chol_update<SquareMatrixType, LLT>(symm)));
+  CALL_SUBTEST((test_chol_update<SquareMatrixType, LDLT>(symm)));
+}
+
+template <typename MatrixType>
+void cholesky_cplx(const MatrixType& m) {
+  // classic test
+  cholesky(m);
+
+  // test mixing real/scalar types
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<RealScalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> RealMatrixType;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
+
+  RealMatrixType a0 = RealMatrixType::Random(rows, cols);
+  VectorType vecB = VectorType::Random(rows), vecX(rows);
+  MatrixType matB = MatrixType::Random(rows, cols), matX(rows, cols);
+  RealMatrixType symm = a0 * a0.adjoint();
+  // let's make sure the matrix is not singular or near singular
+  for (int k = 0; k < 3; ++k) {
+    RealMatrixType a1 = RealMatrixType::Random(rows, cols);
+    symm += a1 * a1.adjoint();
+  }
+
+  {
+    RealMatrixType symmLo = symm.template triangularView<Lower>();
+
+    LLT<RealMatrixType, Lower> chollo(symmLo);
+    VERIFY_IS_APPROX(symm, chollo.reconstructedMatrix());
+
+    check_solverbase<VectorType, VectorType>(symm, chollo, rows, rows, 1);
+    // check_solverbase<MatrixType, MatrixType>(symm, chollo, rows, cols, rows);
+  }
+
+  // LDLT
+  {
+    int sign = internal::random<int>() % 2 ? 1 : -1;
+
+    if (sign == -1) {
+      symm = -symm;  // test a negative matrix
+    }
+
+    RealMatrixType symmLo = symm.template triangularView<Lower>();
+
+    LDLT<RealMatrixType, Lower> ldltlo(symmLo);
+    VERIFY(ldltlo.info() == Success);
+    VERIFY_IS_APPROX(symm, ldltlo.reconstructedMatrix());
+
+    check_solverbase<VectorType, VectorType>(symm, ldltlo, rows, rows, 1);
+    // check_solverbase<MatrixType, MatrixType>(symm, ldltlo, rows, cols, rows);
+  }
+}
+
+// regression test for bug 241
+template <typename MatrixType>
+void cholesky_bug241(const MatrixType& m) {
+  eigen_assert(m.rows() == 2 && m.cols() == 2);
+
+  typedef typename MatrixType::Scalar Scalar;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
+
+  MatrixType matA;
+  matA << 1, 1, 1, 1;
+  VectorType vecB;
+  vecB << 1, 1;
+  VectorType vecX = matA.ldlt().solve(vecB);
+  VERIFY_IS_APPROX(matA * vecX, vecB);
+}
+
+// LDLT is not guaranteed to work for indefinite matrices, but happens to work fine if matrix is diagonal.
+// This test checks that LDLT reports correctly that matrix is indefinite.
+// See http://forum.kde.org/viewtopic.php?f=74&t=106942 and bug 736
+template <typename MatrixType>
+void cholesky_definiteness(const MatrixType& m) {
+  eigen_assert(m.rows() == 2 && m.cols() == 2);
+  MatrixType mat;
+  LDLT<MatrixType> ldlt(2);
+
+  {
+    mat << 1, 0, 0, -1;
+    ldlt.compute(mat);
+    VERIFY(ldlt.info() == Success);
+    VERIFY(!ldlt.isNegative());
+    VERIFY(!ldlt.isPositive());
+    VERIFY_IS_APPROX(mat, ldlt.reconstructedMatrix());
+  }
+  {
+    mat << 1, 2, 2, 1;
+    ldlt.compute(mat);
+    VERIFY(ldlt.info() == Success);
+    VERIFY(!ldlt.isNegative());
+    VERIFY(!ldlt.isPositive());
+    VERIFY_IS_APPROX(mat, ldlt.reconstructedMatrix());
+  }
+  {
+    mat << 0, 0, 0, 0;
+    ldlt.compute(mat);
+    VERIFY(ldlt.info() == Success);
+    VERIFY(ldlt.isNegative());
+    VERIFY(ldlt.isPositive());
+    VERIFY_IS_APPROX(mat, ldlt.reconstructedMatrix());
+  }
+  {
+    mat << 0, 0, 0, 1;
+    ldlt.compute(mat);
+    VERIFY(ldlt.info() == Success);
+    VERIFY(!ldlt.isNegative());
+    VERIFY(ldlt.isPositive());
+    VERIFY_IS_APPROX(mat, ldlt.reconstructedMatrix());
+  }
+  {
+    mat << -1, 0, 0, 0;
+    ldlt.compute(mat);
+    VERIFY(ldlt.info() == Success);
+    VERIFY(ldlt.isNegative());
+    VERIFY(!ldlt.isPositive());
+    VERIFY_IS_APPROX(mat, ldlt.reconstructedMatrix());
+  }
+}
+
+template <typename>
+void cholesky_faillure_cases() {
+  MatrixXd mat;
+  LDLT<MatrixXd> ldlt;
+
+  {
+    mat.resize(2, 2);
+    mat << 0, 1, 1, 0;
+    ldlt.compute(mat);
+    VERIFY_IS_NOT_APPROX(mat, ldlt.reconstructedMatrix());
+    VERIFY(ldlt.info() == NumericalIssue);
+  }
+#if (!EIGEN_ARCH_i386) || defined(EIGEN_VECTORIZE_SSE2)
+  {
+    mat.resize(3, 3);
+    mat << -1, -3, 3, -3, -8.9999999999999999999, 1, 3, 1, 0;
+    ldlt.compute(mat);
+    VERIFY(ldlt.info() == NumericalIssue);
+    VERIFY_IS_NOT_APPROX(mat, ldlt.reconstructedMatrix());
+  }
+#endif
+  {
+    mat.resize(3, 3);
+    mat << 1, 2, 3, 2, 4, 1, 3, 1, 0;
+    ldlt.compute(mat);
+    VERIFY(ldlt.info() == NumericalIssue);
+    VERIFY_IS_NOT_APPROX(mat, ldlt.reconstructedMatrix());
+  }
+
+  {
+    mat.resize(8, 8);
+    mat << 0.1, 0, -0.1, 0, 0, 0, 1, 0, 0, 4.24667, 0, 2.00333, 0, 0, 0, 0, -0.1, 0, 0.2, 0, -0.1, 0, 0, 0, 0, 2.00333,
+        0, 8.49333, 0, 2.00333, 0, 0, 0, 0, -0.1, 0, 0.1, 0, 0, 1, 0, 0, 0, 2.00333, 0, 4.24667, 0, 0, 1, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 1, 0, 0, 0;
+    ldlt.compute(mat);
+    VERIFY(ldlt.info() == NumericalIssue);
+    VERIFY_IS_NOT_APPROX(mat, ldlt.reconstructedMatrix());
+  }
+
+  // bug 1479
+  {
+    mat.resize(4, 4);
+    mat << 1, 2, 0, 1, 2, 4, 0, 2, 0, 0, 0, 1, 1, 2, 1, 1;
+    ldlt.compute(mat);
+    VERIFY(ldlt.info() == NumericalIssue);
+    VERIFY_IS_NOT_APPROX(mat, ldlt.reconstructedMatrix());
+  }
+}
+
+template <typename MatrixType>
+void cholesky_verify_assert() {
+  MatrixType tmp;
+
+  LLT<MatrixType> llt;
+  VERIFY_RAISES_ASSERT(llt.matrixL())
+  VERIFY_RAISES_ASSERT(llt.matrixU())
+  VERIFY_RAISES_ASSERT(llt.solve(tmp))
+  VERIFY_RAISES_ASSERT(llt.transpose().solve(tmp))
+  VERIFY_RAISES_ASSERT(llt.adjoint().solve(tmp))
+  VERIFY_RAISES_ASSERT(llt.solveInPlace(tmp))
+
+  LDLT<MatrixType> ldlt;
+  VERIFY_RAISES_ASSERT(ldlt.matrixL())
+  VERIFY_RAISES_ASSERT(ldlt.transpositionsP())
+  VERIFY_RAISES_ASSERT(ldlt.vectorD())
+  VERIFY_RAISES_ASSERT(ldlt.isPositive())
+  VERIFY_RAISES_ASSERT(ldlt.isNegative())
+  VERIFY_RAISES_ASSERT(ldlt.solve(tmp))
+  VERIFY_RAISES_ASSERT(ldlt.transpose().solve(tmp))
+  VERIFY_RAISES_ASSERT(ldlt.adjoint().solve(tmp))
+  VERIFY_RAISES_ASSERT(ldlt.solveInPlace(tmp))
+}
+
+EIGEN_DECLARE_TEST(cholesky) {
+  int s = 0;
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(cholesky(Matrix<double, 1, 1>()));
+    CALL_SUBTEST_3(cholesky(Matrix2d()));
+    CALL_SUBTEST_3(cholesky_bug241(Matrix2d()));
+    CALL_SUBTEST_3(cholesky_definiteness(Matrix2d()));
+    CALL_SUBTEST_4(cholesky(Matrix3f()));
+    CALL_SUBTEST_5(cholesky(Matrix4d()));
+
+    s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE);
+    CALL_SUBTEST_2(cholesky(MatrixXd(s, s)));
+    TEST_SET_BUT_UNUSED_VARIABLE(s)
+
+    s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2);
+    CALL_SUBTEST_6(cholesky_cplx(MatrixXcd(s, s)));
+    TEST_SET_BUT_UNUSED_VARIABLE(s)
+  }
+  // empty matrix, regression test for Bug 785:
+  CALL_SUBTEST_2(cholesky(MatrixXd(0, 0)));
+
+  // This does not work yet:
+  // CALL_SUBTEST_2( cholesky(Matrix<double,0,0>()) );
+
+  CALL_SUBTEST_4(cholesky_verify_assert<Matrix3f>());
+  CALL_SUBTEST_7(cholesky_verify_assert<Matrix3d>());
+  CALL_SUBTEST_8(cholesky_verify_assert<MatrixXf>());
+  CALL_SUBTEST_2(cholesky_verify_assert<MatrixXd>());
+
+  // Test problem size constructors
+  CALL_SUBTEST_9(LLT<MatrixXf>(10));
+  CALL_SUBTEST_9(LDLT<MatrixXf>(10));
+
+  CALL_SUBTEST_2(cholesky_faillure_cases<void>());
+
+  TEST_SET_BUT_UNUSED_VARIABLE(nb_temporaries)
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/cholmod_support.cpp

@@ -0,0 +1,81 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Gael Guennebaud <g.gael@free.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/.
+
+#define EIGEN_NO_DEBUG_SMALL_PRODUCT_BLOCKS
+#include "sparse_solver.h"
+
+#include <Eigen/CholmodSupport>
+
+template <typename SparseType>
+void test_cholmod_ST() {
+  CholmodDecomposition<SparseType, Lower> g_chol_colmajor_lower;
+  g_chol_colmajor_lower.setMode(CholmodSupernodalLLt);
+  CholmodDecomposition<SparseType, Upper> g_chol_colmajor_upper;
+  g_chol_colmajor_upper.setMode(CholmodSupernodalLLt);
+  CholmodDecomposition<SparseType, Lower> g_llt_colmajor_lower;
+  g_llt_colmajor_lower.setMode(CholmodSimplicialLLt);
+  CholmodDecomposition<SparseType, Upper> g_llt_colmajor_upper;
+  g_llt_colmajor_upper.setMode(CholmodSimplicialLLt);
+  CholmodDecomposition<SparseType, Lower> g_ldlt_colmajor_lower;
+  g_ldlt_colmajor_lower.setMode(CholmodLDLt);
+  CholmodDecomposition<SparseType, Upper> g_ldlt_colmajor_upper;
+  g_ldlt_colmajor_upper.setMode(CholmodLDLt);
+
+  CholmodSupernodalLLT<SparseType, Lower> chol_colmajor_lower;
+  CholmodSupernodalLLT<SparseType, Upper> chol_colmajor_upper;
+  CholmodSimplicialLLT<SparseType, Lower> llt_colmajor_lower;
+  CholmodSimplicialLLT<SparseType, Upper> llt_colmajor_upper;
+  CholmodSimplicialLDLT<SparseType, Lower> ldlt_colmajor_lower;
+  CholmodSimplicialLDLT<SparseType, Upper> ldlt_colmajor_upper;
+
+  check_sparse_spd_solving(g_chol_colmajor_lower);
+  check_sparse_spd_solving(g_chol_colmajor_upper);
+  check_sparse_spd_solving(g_llt_colmajor_lower);
+  check_sparse_spd_solving(g_llt_colmajor_upper);
+  check_sparse_spd_solving(g_ldlt_colmajor_lower);
+  check_sparse_spd_solving(g_ldlt_colmajor_upper);
+
+  check_sparse_spd_solving(chol_colmajor_lower);
+  check_sparse_spd_solving(chol_colmajor_upper);
+  check_sparse_spd_solving(llt_colmajor_lower);
+  check_sparse_spd_solving(llt_colmajor_upper);
+  check_sparse_spd_solving(ldlt_colmajor_lower);
+  check_sparse_spd_solving(ldlt_colmajor_upper);
+
+  check_sparse_spd_determinant(chol_colmajor_lower);
+  check_sparse_spd_determinant(chol_colmajor_upper);
+  check_sparse_spd_determinant(llt_colmajor_lower);
+  check_sparse_spd_determinant(llt_colmajor_upper);
+  check_sparse_spd_determinant(ldlt_colmajor_lower);
+  check_sparse_spd_determinant(ldlt_colmajor_upper);
+
+  check_sparse_zero_matrix(chol_colmajor_lower);
+  check_sparse_zero_matrix(chol_colmajor_upper);
+  check_sparse_zero_matrix(llt_colmajor_lower);
+  check_sparse_zero_matrix(llt_colmajor_upper);
+  check_sparse_zero_matrix(ldlt_colmajor_lower);
+  check_sparse_zero_matrix(ldlt_colmajor_upper);
+}
+
+template <typename T, int flags, typename IdxType>
+void test_cholmod_T() {
+  test_cholmod_ST<SparseMatrix<T, flags, IdxType> >();
+}
+
+EIGEN_DECLARE_TEST(cholmod_support) {
+  CALL_SUBTEST_11((test_cholmod_T<double, ColMajor, int>()));
+  CALL_SUBTEST_12((test_cholmod_T<double, ColMajor, long>()));
+  CALL_SUBTEST_13((test_cholmod_T<double, RowMajor, int>()));
+  CALL_SUBTEST_14((test_cholmod_T<double, RowMajor, long>()));
+  CALL_SUBTEST_21((test_cholmod_T<std::complex<double>, ColMajor, int>()));
+  CALL_SUBTEST_22((test_cholmod_T<std::complex<double>, ColMajor, long>()));
+  // TODO complex row-major matrices do not work at the moment:
+  // CALL_SUBTEST_23( (test_cholmod_T<std::complex<double>, RowMajor, int >()) );
+  // CALL_SUBTEST_24( (test_cholmod_T<std::complex<double>, RowMajor, long>()) );
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/clz.cpp

@@ -0,0 +1,74 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2023 The Eigen Authors
+//
+// 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"
+
+template <typename T>
+int ref_clz(T val) {
+  constexpr int kNumBits = sizeof(T) * CHAR_BIT;
+  T kMsbMask = T(1) << (kNumBits - 1);
+  int z = 0;
+  for (; z < kNumBits && ((val & kMsbMask) == 0); ++z) {
+    val <<= 1;
+  }
+  return z;
+}
+
+template <typename T>
+int ref_ctz(T val) {
+  constexpr int kNumBits = sizeof(T) * CHAR_BIT;
+  T kLsbMask = T(1);
+  int z = 0;
+  for (; z < kNumBits && ((val & kLsbMask) == 0); ++z) {
+    val >>= 1;
+  }
+  return z;
+}
+
+template <typename T>
+void test_clz_ctz() {
+  T step = sizeof(T) <= 2 ? 1 : (Eigen::NumTraits<T>::highest() / (T(1) << 16));
+  T iters = Eigen::NumTraits<T>::highest() / step;
+  for (T i = 0; i < iters; ++i) {
+    T val = i * step;
+    int expected_clz = ref_clz(val);
+    int actual_clz = Eigen::internal::clz(val);
+    VERIFY(expected_clz == actual_clz);
+
+    int expected_ctz = ref_ctz(val);
+    int actual_ctz = Eigen::internal::ctz(val);
+    VERIFY(expected_ctz == actual_ctz);
+  }
+}
+
+template <typename T>
+void test_clz_ctz_random() {
+  for (int i = 0; i < 1024 * 1024; ++i) {
+    T val = Eigen::internal::random<T>();
+    int expected_clz = ref_clz(val);
+    int actual_clz = Eigen::internal::clz(val);
+    VERIFY(expected_clz == actual_clz);
+
+    int expected_ctz = ref_ctz(val);
+    int actual_ctz = Eigen::internal::ctz(val);
+    VERIFY(expected_ctz == actual_ctz);
+  }
+}
+
+EIGEN_DECLARE_TEST(clz) {
+  CALL_SUBTEST_1(test_clz_ctz<uint8_t>());
+  CALL_SUBTEST_2(test_clz_ctz<uint16_t>());
+  CALL_SUBTEST_3(test_clz_ctz<uint32_t>());
+  CALL_SUBTEST_4(test_clz_ctz<uint64_t>());
+
+  for (int i = 0; i < g_repeat; i++) {
+    test_clz_ctz_random<uint32_t>();
+    test_clz_ctz_random<uint64_t>();
+  }
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/commainitializer.cpp

@@ -0,0 +1,107 @@
+// 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/.
+
+#include "main.h"
+
+template <int M1, int M2, int N1, int N2>
+void test_blocks() {
+  Matrix<int, M1 + M2, N1 + N2> m_fixed;
+  MatrixXi m_dynamic(M1 + M2, N1 + N2);
+
+  Matrix<int, M1, N1> mat11;
+  mat11.setRandom();
+  Matrix<int, M1, N2> mat12;
+  mat12.setRandom();
+  Matrix<int, M2, N1> mat21;
+  mat21.setRandom();
+  Matrix<int, M2, N2> mat22;
+  mat22.setRandom();
+
+  MatrixXi matx11 = mat11, matx12 = mat12, matx21 = mat21, matx22 = mat22;
+
+  {
+    VERIFY_IS_EQUAL((m_fixed << mat11, mat12, mat21, matx22).finished(),
+                    (m_dynamic << mat11, matx12, mat21, matx22).finished());
+    VERIFY_IS_EQUAL((m_fixed.template topLeftCorner<M1, N1>()), mat11);
+    VERIFY_IS_EQUAL((m_fixed.template topRightCorner<M1, N2>()), mat12);
+    VERIFY_IS_EQUAL((m_fixed.template bottomLeftCorner<M2, N1>()), mat21);
+    VERIFY_IS_EQUAL((m_fixed.template bottomRightCorner<M2, N2>()), mat22);
+    VERIFY_IS_EQUAL((m_fixed << mat12, mat11, matx21, mat22).finished(),
+                    (m_dynamic << mat12, matx11, matx21, mat22).finished());
+  }
+
+  if (N1 > 0) {
+    if (M1 > 0) {
+      VERIFY_RAISES_ASSERT((m_fixed << mat11, mat12, mat11, mat21, mat22));
+    }
+    if (M2 > 0) {
+      VERIFY_RAISES_ASSERT((m_fixed << mat11, mat12, mat21, mat21, mat22));
+    }
+  } else {
+    // allow insertion of zero-column blocks:
+    VERIFY_IS_EQUAL((m_fixed << mat11, mat12, mat11, mat11, mat21, mat21, mat22).finished(),
+                    (m_dynamic << mat12, mat22).finished());
+  }
+  if (M1 != M2) {
+    VERIFY_RAISES_ASSERT((m_fixed << mat11, mat21, mat12, mat22));
+  }
+}
+
+template <int depth, int N = 0>
+struct test_block_recursion {
+  static void run() {
+    test_block_recursion<depth - 1, N>::run();
+    test_block_recursion<depth - 1, N + (1 << (depth - 1))>::run();
+  }
+};
+
+template <int N>
+struct test_block_recursion<0, N> {
+  static void run() { test_blocks<(N >> 6) & 3, (N >> 4) & 3, (N >> 2) & 3, N & 3>(); }
+};
+
+void test_basics() {
+  Matrix3d m3;
+  Matrix4d m4;
+
+  VERIFY_RAISES_ASSERT((m3 << 1, 2, 3, 4, 5, 6, 7, 8));
+
+#ifndef _MSC_VER
+  VERIFY_RAISES_ASSERT((m3 << 1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
+#endif
+
+  double data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+  Matrix3d ref = Map<Matrix<double, 3, 3, RowMajor> >(data);
+
+  m3 = Matrix3d::Random();
+  m3 << 1, 2, 3, 4, 5, 6, 7, 8, 9;
+  VERIFY_IS_APPROX(m3, ref);
+
+  Vector3d vec[3];
+  vec[0] << 1, 4, 7;
+  vec[1] << 2, 5, 8;
+  vec[2] << 3, 6, 9;
+  m3 = Matrix3d::Random();
+  m3 << vec[0], vec[1], vec[2];
+  VERIFY_IS_APPROX(m3, ref);
+
+  vec[0] << 1, 2, 3;
+  vec[1] << 4, 5, 6;
+  vec[2] << 7, 8, 9;
+  m3 = Matrix3d::Random();
+  m3 << vec[0].transpose(), 4, 5, 6, vec[2].transpose();
+  VERIFY_IS_APPROX(m3, ref);
+}
+
+EIGEN_DECLARE_TEST(commainitializer) {
+  CALL_SUBTEST_1(test_basics());
+
+  // recursively test all block-sizes from 0 to 3:
+  CALL_SUBTEST_2(test_block_recursion<8>::run());
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/complex_qz.cpp

@@ -0,0 +1,84 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 The Eigen Authors
+//
+// 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/.
+
+#define EIGEN_RUNTIME_NO_MALLOC
+#include "main.h"
+
+#include <Eigen/Eigenvalues>
+
+/* this test covers the following files:
+   ComplexQZ.h
+*/
+
+template <typename MatrixType>
+void generate_random_matrix_pair(const Index dim, MatrixType& A, MatrixType& B) {
+  A.setRandom(dim, dim);
+  B.setRandom(dim, dim);
+  // Zero out each row of B to with a probability of 10%.
+  for (int i = 0; i < dim; i++) {
+    if (internal::random<int>(0, 10) == 0) B.row(i).setZero();
+  }
+}
+
+template <typename MatrixType>
+void complex_qz(const MatrixType& A, const MatrixType& B) {
+  using std::abs;
+  const Index dim = A.rows();
+  ComplexQZ<MatrixType> qz(A, B);
+  VERIFY_IS_EQUAL(qz.info(), Success);
+  auto T = qz.matrixT(), S = qz.matrixS();
+  bool is_all_zero_T = true, is_all_zero_S = true;
+  using RealScalar = typename MatrixType::RealScalar;
+  RealScalar tol = dim * 10 * NumTraits<RealScalar>::epsilon();
+  for (Index j = 0; j < dim; j++) {
+    for (Index i = j + 1; i < dim; i++) {
+      if (std::abs(T(i, j)) > tol) {
+        std::cerr << std::abs(T(i, j)) << std::endl;
+        is_all_zero_T = false;
+      }
+      if (std::abs(S(i, j)) > tol) {
+        std::cerr << std::abs(S(i, j)) << std::endl;
+        is_all_zero_S = false;
+      }
+    }
+  }
+  VERIFY_IS_EQUAL(is_all_zero_T, true);
+  VERIFY_IS_EQUAL(is_all_zero_S, true);
+  VERIFY_IS_APPROX(qz.matrixQ() * qz.matrixS() * qz.matrixZ(), A);
+  VERIFY_IS_APPROX(qz.matrixQ() * qz.matrixT() * qz.matrixZ(), B);
+  VERIFY_IS_APPROX(qz.matrixQ() * qz.matrixQ().adjoint(), MatrixType::Identity(dim, dim));
+  VERIFY_IS_APPROX(qz.matrixZ() * qz.matrixZ().adjoint(), MatrixType::Identity(dim, dim));
+}
+
+EIGEN_DECLARE_TEST(complex_qz) {
+  for (int i = 0; i < g_repeat; i++) {
+    // Check for very small, fixed-sized double- and float complex matrices
+    Eigen::Matrix2cd A_2x2, B_2x2;
+    A_2x2.setRandom();
+    B_2x2.setRandom();
+    B_2x2.row(1).setZero();
+    Eigen::Matrix3cf A_3x3, B_3x3;
+    A_3x3.setRandom();
+    B_3x3.setRandom();
+    B_3x3.col(i % 3).setRandom();
+    CALL_SUBTEST_1(complex_qz(A_2x2, B_2x2));
+    CALL_SUBTEST_2(complex_qz(A_3x3, B_3x3));
+
+    // Test for float complex matrices
+    const Index dim = internal::random<Index>(15, 80);
+    Eigen::MatrixXcf A_float, B_float;
+    generate_random_matrix_pair(dim, A_float, B_float);
+    CALL_SUBTEST_3(complex_qz(A_float, B_float));
+
+    // Test for double complex matrices
+    Eigen::MatrixXcd A_double, B_double;
+    generate_random_matrix_pair(dim, A_double, B_double);
+    CALL_SUBTEST_4(complex_qz(A_double, B_double));
+  }
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/conjugate_gradient.cpp

@@ -0,0 +1,33 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Gael Guennebaud <g.gael@free.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/.
+
+#include "sparse_solver.h"
+#include <Eigen/IterativeLinearSolvers>
+
+template <typename T, typename I_>
+void test_conjugate_gradient_T() {
+  typedef SparseMatrix<T, 0, I_> SparseMatrixType;
+  ConjugateGradient<SparseMatrixType, Lower> cg_colmajor_lower_diag;
+  ConjugateGradient<SparseMatrixType, Upper> cg_colmajor_upper_diag;
+  ConjugateGradient<SparseMatrixType, Lower | Upper> cg_colmajor_loup_diag;
+  ConjugateGradient<SparseMatrixType, Lower, IdentityPreconditioner> cg_colmajor_lower_I;
+  ConjugateGradient<SparseMatrixType, Upper, IdentityPreconditioner> cg_colmajor_upper_I;
+
+  CALL_SUBTEST(check_sparse_spd_solving(cg_colmajor_lower_diag));
+  CALL_SUBTEST(check_sparse_spd_solving(cg_colmajor_upper_diag));
+  CALL_SUBTEST(check_sparse_spd_solving(cg_colmajor_loup_diag));
+  CALL_SUBTEST(check_sparse_spd_solving(cg_colmajor_lower_I));
+  CALL_SUBTEST(check_sparse_spd_solving(cg_colmajor_upper_I));
+}
+
+EIGEN_DECLARE_TEST(conjugate_gradient) {
+  CALL_SUBTEST_1((test_conjugate_gradient_T<double, int>()));
+  CALL_SUBTEST_2((test_conjugate_gradient_T<std::complex<double>, int>()));
+  CALL_SUBTEST_3((test_conjugate_gradient_T<double, long int>()));
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/conservative_resize.cpp

@@ -0,0 +1,162 @@
+// 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/.
+
+#include "main.h"
+
+#include <Eigen/Core>
+#include "AnnoyingScalar.h"
+
+using namespace Eigen;
+
+template <typename Scalar, int Storage>
+void run_matrix_tests() {
+  typedef Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Storage> MatrixType;
+
+  MatrixType m, n;
+
+  // boundary cases ...
+  m = n = MatrixType::Random(50, 50);
+  m.conservativeResize(1, 50);
+  VERIFY_IS_APPROX(m, n.block(0, 0, 1, 50));
+
+  m = n = MatrixType::Random(50, 50);
+  m.conservativeResize(50, 1);
+  VERIFY_IS_APPROX(m, n.block(0, 0, 50, 1));
+
+  m = n = MatrixType::Random(50, 50);
+  m.conservativeResize(50, 50);
+  VERIFY_IS_APPROX(m, n.block(0, 0, 50, 50));
+
+  // random shrinking ...
+  for (int i = 0; i < 25; ++i) {
+    const Index rows = internal::random<Index>(1, 50);
+    const Index cols = internal::random<Index>(1, 50);
+    m = n = MatrixType::Random(50, 50);
+    m.conservativeResize(rows, cols);
+    VERIFY_IS_APPROX(m, n.block(0, 0, rows, cols));
+  }
+
+  // random growing with zeroing ...
+  for (int i = 0; i < 25; ++i) {
+    const Index rows = internal::random<Index>(50, 75);
+    const Index cols = internal::random<Index>(50, 75);
+    m = n = MatrixType::Random(50, 50);
+    m.conservativeResizeLike(MatrixType::Zero(rows, cols));
+    VERIFY_IS_APPROX(m.block(0, 0, n.rows(), n.cols()), n);
+    VERIFY(rows <= 50 || m.block(50, 0, rows - 50, cols).sum() == Scalar(0));
+    VERIFY(cols <= 50 || m.block(0, 50, rows, cols - 50).sum() == Scalar(0));
+  }
+}
+
+template <typename Scalar>
+void run_vector_tests() {
+  typedef Matrix<Scalar, 1, Eigen::Dynamic> VectorType;
+
+  VectorType m, n;
+
+  // boundary cases ...
+  m = n = VectorType::Random(50);
+  m.conservativeResize(1);
+  VERIFY_IS_APPROX(m, n.segment(0, 1));
+
+  m = n = VectorType::Random(50);
+  m.conservativeResize(50);
+  VERIFY_IS_APPROX(m, n.segment(0, 50));
+
+  m = n = VectorType::Random(50);
+  m.conservativeResize(m.rows(), 1);
+  VERIFY_IS_APPROX(m, n.segment(0, 1));
+
+  m = n = VectorType::Random(50);
+  m.conservativeResize(m.rows(), 50);
+  VERIFY_IS_APPROX(m, n.segment(0, 50));
+
+  // random shrinking ...
+  for (int i = 0; i < 50; ++i) {
+    const int size = internal::random<int>(1, 50);
+    m = n = VectorType::Random(50);
+    m.conservativeResize(size);
+    VERIFY_IS_APPROX(m, n.segment(0, size));
+
+    m = n = VectorType::Random(50);
+    m.conservativeResize(m.rows(), size);
+    VERIFY_IS_APPROX(m, n.segment(0, size));
+  }
+
+  // random growing with zeroing ...
+  for (int i = 0; i < 50; ++i) {
+    const int size = internal::random<int>(50, 100);
+    m = n = VectorType::Random(50);
+    m.conservativeResizeLike(VectorType::Zero(size));
+    VERIFY_IS_APPROX(m.segment(0, 50), n);
+    VERIFY(size <= 50 || m.segment(50, size - 50).sum() == Scalar(0));
+
+    m = n = VectorType::Random(50);
+    m.conservativeResizeLike(Matrix<Scalar, Dynamic, Dynamic>::Zero(1, size));
+    VERIFY_IS_APPROX(m.segment(0, 50), n);
+    VERIFY(size <= 50 || m.segment(50, size - 50).sum() == Scalar(0));
+  }
+}
+
+// Basic memory leak check with a non-copyable scalar type
+template <int>
+void noncopyable() {
+  typedef Eigen::Matrix<AnnoyingScalar, Dynamic, 1> VectorType;
+  typedef Eigen::Matrix<AnnoyingScalar, Dynamic, Dynamic> MatrixType;
+
+  {
+#ifndef EIGEN_TEST_ANNOYING_SCALAR_DONT_THROW
+    AnnoyingScalar::dont_throw = true;
+#endif
+    int n = 50;
+    VectorType v0(n), v1(n);
+    MatrixType m0(n, n), m1(n, n), m2(n, n);
+    v0.setOnes();
+    v1.setOnes();
+    m0.setOnes();
+    m1.setOnes();
+    m2.setOnes();
+    VERIFY(m0 == m1);
+    m0.conservativeResize(2 * n, 2 * n);
+    VERIFY(m0.topLeftCorner(n, n) == m1);
+
+    VERIFY(v0.head(n) == v1);
+    v0.conservativeResize(2 * n);
+    VERIFY(v0.head(n) == v1);
+  }
+  VERIFY(AnnoyingScalar::instances == 0 && "global memory leak detected in noncopyable");
+}
+
+EIGEN_DECLARE_TEST(conservative_resize) {
+  for (int i = 0; i < g_repeat; ++i) {
+    CALL_SUBTEST_1((run_matrix_tests<int, Eigen::RowMajor>()));
+    CALL_SUBTEST_1((run_matrix_tests<int, Eigen::ColMajor>()));
+    CALL_SUBTEST_2((run_matrix_tests<float, Eigen::RowMajor>()));
+    CALL_SUBTEST_2((run_matrix_tests<float, Eigen::ColMajor>()));
+    CALL_SUBTEST_3((run_matrix_tests<double, Eigen::RowMajor>()));
+    CALL_SUBTEST_3((run_matrix_tests<double, Eigen::ColMajor>()));
+    CALL_SUBTEST_4((run_matrix_tests<std::complex<float>, Eigen::RowMajor>()));
+    CALL_SUBTEST_4((run_matrix_tests<std::complex<float>, Eigen::ColMajor>()));
+    CALL_SUBTEST_5((run_matrix_tests<std::complex<double>, Eigen::RowMajor>()));
+    CALL_SUBTEST_5((run_matrix_tests<std::complex<double>, Eigen::ColMajor>()));
+    CALL_SUBTEST_1((run_matrix_tests<int, Eigen::RowMajor | Eigen::DontAlign>()));
+
+    CALL_SUBTEST_1((run_vector_tests<int>()));
+    CALL_SUBTEST_2((run_vector_tests<float>()));
+    CALL_SUBTEST_3((run_vector_tests<double>()));
+    CALL_SUBTEST_4((run_vector_tests<std::complex<float> >()));
+    CALL_SUBTEST_5((run_vector_tests<std::complex<double> >()));
+
+#ifndef EIGEN_TEST_ANNOYING_SCALAR_DONT_THROW
+    AnnoyingScalar::dont_throw = true;
+#endif
+    CALL_SUBTEST_6((run_vector_tests<AnnoyingScalar>()));
+    CALL_SUBTEST_6((noncopyable<0>()));
+  }
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/constexpr.cpp

@@ -0,0 +1,82 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2022 Alex Richardson <alexrichardson@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/.
+
+#define EIGEN_TESTING_CONSTEXPR
+#include "main.h"
+
+template <typename Scalar, int Rows>
+struct ConstexprTest {
+  constexpr ConstexprTest(const Matrix<Scalar, Rows, Rows>& B) { A = B; }
+
+  Matrix<Scalar, Rows, Rows> A;
+};
+
+EIGEN_DECLARE_TEST(constexpr) {
+  // Clang accepts (some of) this code when using C++14/C++17, but GCC does not like
+  // the fact that `T array[Size]` inside Eigen::internal::plain_array is not initialized
+  // until after the constructor returns:
+  // error: member ‘Eigen::internal::plain_array<int, 9, 0, 0>::array’ must be initialized by mem-initializer in
+  // ‘constexpr’ constructor
+#if __cpp_constexpr >= 201907L
+  constexpr Matrix3i mat({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}});
+  VERIFY_IS_EQUAL(mat.size(), 9);
+  static_assert(mat(0, 0) == 1);
+  static_assert(mat(0) == 1);
+  static_assert(mat.coeff(0, 1) == 2);
+  constexpr Array33i arr({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}});
+  static_assert(arr(0, 0) == 1);
+  static_assert(arr(0) == 1);
+  VERIFY_IS_EQUAL(arr.size(), 9);
+  static_assert(arr.coeff(0, 1) == 2);
+  constexpr RowVector3i vec{{1, 2, 3}};
+  static_assert(vec(0, 0) == 1);
+  static_assert(vec[0] == 1);
+  VERIFY_IS_EQUAL(vec.size(), 3);
+  static_assert(vec.coeff(0, 1) == 2);
+
+  // Check assignment. A wrapper struct is used to avoid copy ellision.
+  constexpr ConstexprTest<double, 2> obj1(Matrix2d({{1, 2}, {3, 4}}));
+  VERIFY_IS_EQUAL(obj1.A.size(), 4);
+  static_assert(obj1.A(0, 0) == 1);
+  static_assert(obj1.A(0) == 1);
+  static_assert(obj1.A.coeff(0, 1) == 2);
+  constexpr ConstexprTest<double, 3> obj2(Matrix3d({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}));
+  VERIFY_IS_EQUAL(obj2.A.size(), 9);
+  static_assert(obj2.A(0, 0) == 1);
+  static_assert(obj2.A(0) == 1);
+  static_assert(obj2.A.coeff(0, 1) == 2);
+
+  // Also check dynamic size arrays/matrices with fixed-size storage (currently
+  // only works if all elements are initialized, since otherwise the compiler
+  // complains about uninitialized trailing elements.
+  constexpr Matrix<int, Eigen::Dynamic, Eigen::Dynamic, 0, 3, 3> dyn_mat({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}});
+  VERIFY_IS_EQUAL(dyn_mat.size(), 9);
+  static_assert(dyn_mat(0, 0) == 1);
+  static_assert(dyn_mat.coeff(0, 1) == 2);
+  constexpr Array<int, Eigen::Dynamic, Eigen::Dynamic, 0, 3, 3> dyn_arr({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}});
+  static_assert(dyn_arr(0, 0) == 1);
+  static_assert(dyn_arr(0) == 1);
+  VERIFY_IS_EQUAL(dyn_arr.size(), 9);
+  static_assert(dyn_arr.coeff(0, 1) == 2);
+#endif  // __cpp_constexpr >= 201907L
+}
+
+// Check that we can use the std::initializer_list constructor for constexpr variables.
+#if __cpp_constexpr >= 201907L
+// EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT() will fail constexpr evaluation unless
+// we have std::is_constant_evaluated().
+constexpr Matrix<int, 2, 2> global_mat({{1, 2}, {3, 4}});
+
+EIGEN_DECLARE_TEST(constexpr_global) {
+  VERIFY_IS_EQUAL(global_mat.size(), 4);
+  static_assert(global_mat(0, 0) == 1);
+  static_assert(global_mat(0) == 1);
+  static_assert(global_mat.coeff(0, 0) == 1);
+}
+#endif  // __cpp_constexpr >= 201907L

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/constructor.cpp

@@ -0,0 +1,97 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 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/.
+
+#define TEST_ENABLE_TEMPORARY_TRACKING
+
+#include "main.h"
+
+template <typename MatrixType>
+struct Wrapper {
+  MatrixType m_mat;
+  inline Wrapper(const MatrixType& x) : m_mat(x) {}
+  inline operator const MatrixType&() const { return m_mat; }
+  inline operator MatrixType&() { return m_mat; }
+};
+
+enum my_sizes { M = 12, N = 7 };
+
+template <typename MatrixType>
+void ctor_init1(const MatrixType& m) {
+  // Check logic in PlainObjectBase::_init1
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  MatrixType m0 = MatrixType::Random(rows, cols);
+
+  VERIFY_EVALUATION_COUNT(MatrixType m1(m0), 1);
+  VERIFY_EVALUATION_COUNT(MatrixType m2(m0 + m0), 1);
+  VERIFY_EVALUATION_COUNT(MatrixType m2(m0.block(0, 0, rows, cols)), 1);
+
+  Wrapper<MatrixType> wrapper(m0);
+  VERIFY_EVALUATION_COUNT(MatrixType m3(wrapper), 1);
+}
+
+EIGEN_DECLARE_TEST(constructor) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(ctor_init1(Matrix<float, 1, 1>()));
+    CALL_SUBTEST_1(ctor_init1(Matrix4d()));
+    CALL_SUBTEST_1(ctor_init1(
+        MatrixXcf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_1(ctor_init1(
+        MatrixXi(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+  }
+  {
+    Matrix<Index, 1, 1> a(123);
+    VERIFY_IS_EQUAL(a[0], 123);
+  }
+  {
+    Matrix<Index, 1, 1> a(123.0);
+    VERIFY_IS_EQUAL(a[0], 123);
+  }
+  {
+    Matrix<float, 1, 1> a(123);
+    VERIFY_IS_EQUAL(a[0], 123.f);
+  }
+  {
+    Array<Index, 1, 1> a(123);
+    VERIFY_IS_EQUAL(a[0], 123);
+  }
+  {
+    Array<Index, 1, 1> a(123.0);
+    VERIFY_IS_EQUAL(a[0], 123);
+  }
+  {
+    Array<float, 1, 1> a(123);
+    VERIFY_IS_EQUAL(a[0], 123.f);
+  }
+  {
+    Array<Index, 3, 3> a(123);
+    VERIFY_IS_EQUAL(a(4), 123);
+  }
+  {
+    Array<Index, 3, 3> a(123.0);
+    VERIFY_IS_EQUAL(a(4), 123);
+  }
+  {
+    Array<float, 3, 3> a(123);
+    VERIFY_IS_EQUAL(a(4), 123.f);
+  }
+  {
+    MatrixXi m1(M, N);
+    VERIFY_IS_EQUAL(m1.rows(), M);
+    VERIFY_IS_EQUAL(m1.cols(), N);
+    ArrayXXi a1(M, N);
+    VERIFY_IS_EQUAL(a1.rows(), M);
+    VERIFY_IS_EQUAL(a1.cols(), N);
+    VectorXi v1(M);
+    VERIFY_IS_EQUAL(v1.size(), M);
+    ArrayXi a2(M);
+    VERIFY_IS_EQUAL(a2.size(), M);
+  }
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/corners.cpp

@@ -0,0 +1,125 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2010 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"
+
+#define COMPARE_CORNER(A, B)           \
+  VERIFY_IS_EQUAL(matrix.A, matrix.B); \
+  VERIFY_IS_EQUAL(const_matrix.A, const_matrix.B);
+
+template <typename MatrixType>
+void corners(const MatrixType& m) {
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  Index r = internal::random<Index>(1, rows);
+  Index c = internal::random<Index>(1, cols);
+
+  MatrixType matrix = MatrixType::Random(rows, cols);
+  const MatrixType const_matrix = MatrixType::Random(rows, cols);
+
+  COMPARE_CORNER(topLeftCorner(r, c), block(0, 0, r, c));
+  COMPARE_CORNER(topRightCorner(r, c), block(0, cols - c, r, c));
+  COMPARE_CORNER(bottomLeftCorner(r, c), block(rows - r, 0, r, c));
+  COMPARE_CORNER(bottomRightCorner(r, c), block(rows - r, cols - c, r, c));
+
+  Index sr = internal::random<Index>(1, rows) - 1;
+  Index nr = internal::random<Index>(1, rows - sr);
+  Index sc = internal::random<Index>(1, cols) - 1;
+  Index nc = internal::random<Index>(1, cols - sc);
+
+  COMPARE_CORNER(topRows(r), block(0, 0, r, cols));
+  COMPARE_CORNER(middleRows(sr, nr), block(sr, 0, nr, cols));
+  COMPARE_CORNER(bottomRows(r), block(rows - r, 0, r, cols));
+  COMPARE_CORNER(leftCols(c), block(0, 0, rows, c));
+  COMPARE_CORNER(middleCols(sc, nc), block(0, sc, rows, nc));
+  COMPARE_CORNER(rightCols(c), block(0, cols - c, rows, c));
+}
+
+template <typename MatrixType, int CRows, int CCols, int SRows, int SCols>
+void corners_fixedsize() {
+  MatrixType matrix = MatrixType::Random();
+  const MatrixType const_matrix = MatrixType::Random();
+
+  enum {
+    rows = MatrixType::RowsAtCompileTime,
+    cols = MatrixType::ColsAtCompileTime,
+    r = CRows,
+    c = CCols,
+    sr = SRows,
+    sc = SCols
+  };
+
+  VERIFY_IS_EQUAL((matrix.template topLeftCorner<r, c>()), (matrix.template block<r, c>(0, 0)));
+  VERIFY_IS_EQUAL((matrix.template topRightCorner<r, c>()), (matrix.template block<r, c>(0, cols - c)));
+  VERIFY_IS_EQUAL((matrix.template bottomLeftCorner<r, c>()), (matrix.template block<r, c>(rows - r, 0)));
+  VERIFY_IS_EQUAL((matrix.template bottomRightCorner<r, c>()), (matrix.template block<r, c>(rows - r, cols - c)));
+
+  VERIFY_IS_EQUAL((matrix.template topLeftCorner<r, c>()), (matrix.template topLeftCorner<r, Dynamic>(r, c)));
+  VERIFY_IS_EQUAL((matrix.template topRightCorner<r, c>()), (matrix.template topRightCorner<r, Dynamic>(r, c)));
+  VERIFY_IS_EQUAL((matrix.template bottomLeftCorner<r, c>()), (matrix.template bottomLeftCorner<r, Dynamic>(r, c)));
+  VERIFY_IS_EQUAL((matrix.template bottomRightCorner<r, c>()), (matrix.template bottomRightCorner<r, Dynamic>(r, c)));
+
+  VERIFY_IS_EQUAL((matrix.template topLeftCorner<r, c>()), (matrix.template topLeftCorner<Dynamic, c>(r, c)));
+  VERIFY_IS_EQUAL((matrix.template topRightCorner<r, c>()), (matrix.template topRightCorner<Dynamic, c>(r, c)));
+  VERIFY_IS_EQUAL((matrix.template bottomLeftCorner<r, c>()), (matrix.template bottomLeftCorner<Dynamic, c>(r, c)));
+  VERIFY_IS_EQUAL((matrix.template bottomRightCorner<r, c>()), (matrix.template bottomRightCorner<Dynamic, c>(r, c)));
+
+  VERIFY_IS_EQUAL((matrix.template topRows<r>()), (matrix.template block<r, cols>(0, 0)));
+  VERIFY_IS_EQUAL((matrix.template middleRows<r>(sr)), (matrix.template block<r, cols>(sr, 0)));
+  VERIFY_IS_EQUAL((matrix.template bottomRows<r>()), (matrix.template block<r, cols>(rows - r, 0)));
+  VERIFY_IS_EQUAL((matrix.template leftCols<c>()), (matrix.template block<rows, c>(0, 0)));
+  VERIFY_IS_EQUAL((matrix.template middleCols<c>(sc)), (matrix.template block<rows, c>(0, sc)));
+  VERIFY_IS_EQUAL((matrix.template rightCols<c>()), (matrix.template block<rows, c>(0, cols - c)));
+
+  VERIFY_IS_EQUAL((const_matrix.template topLeftCorner<r, c>()), (const_matrix.template block<r, c>(0, 0)));
+  VERIFY_IS_EQUAL((const_matrix.template topRightCorner<r, c>()), (const_matrix.template block<r, c>(0, cols - c)));
+  VERIFY_IS_EQUAL((const_matrix.template bottomLeftCorner<r, c>()), (const_matrix.template block<r, c>(rows - r, 0)));
+  VERIFY_IS_EQUAL((const_matrix.template bottomRightCorner<r, c>()),
+                  (const_matrix.template block<r, c>(rows - r, cols - c)));
+
+  VERIFY_IS_EQUAL((const_matrix.template topLeftCorner<r, c>()),
+                  (const_matrix.template topLeftCorner<r, Dynamic>(r, c)));
+  VERIFY_IS_EQUAL((const_matrix.template topRightCorner<r, c>()),
+                  (const_matrix.template topRightCorner<r, Dynamic>(r, c)));
+  VERIFY_IS_EQUAL((const_matrix.template bottomLeftCorner<r, c>()),
+                  (const_matrix.template bottomLeftCorner<r, Dynamic>(r, c)));
+  VERIFY_IS_EQUAL((const_matrix.template bottomRightCorner<r, c>()),
+                  (const_matrix.template bottomRightCorner<r, Dynamic>(r, c)));
+
+  VERIFY_IS_EQUAL((const_matrix.template topLeftCorner<r, c>()),
+                  (const_matrix.template topLeftCorner<Dynamic, c>(r, c)));
+  VERIFY_IS_EQUAL((const_matrix.template topRightCorner<r, c>()),
+                  (const_matrix.template topRightCorner<Dynamic, c>(r, c)));
+  VERIFY_IS_EQUAL((const_matrix.template bottomLeftCorner<r, c>()),
+                  (const_matrix.template bottomLeftCorner<Dynamic, c>(r, c)));
+  VERIFY_IS_EQUAL((const_matrix.template bottomRightCorner<r, c>()),
+                  (const_matrix.template bottomRightCorner<Dynamic, c>(r, c)));
+
+  VERIFY_IS_EQUAL((const_matrix.template topRows<r>()), (const_matrix.template block<r, cols>(0, 0)));
+  VERIFY_IS_EQUAL((const_matrix.template middleRows<r>(sr)), (const_matrix.template block<r, cols>(sr, 0)));
+  VERIFY_IS_EQUAL((const_matrix.template bottomRows<r>()), (const_matrix.template block<r, cols>(rows - r, 0)));
+  VERIFY_IS_EQUAL((const_matrix.template leftCols<c>()), (const_matrix.template block<rows, c>(0, 0)));
+  VERIFY_IS_EQUAL((const_matrix.template middleCols<c>(sc)), (const_matrix.template block<rows, c>(0, sc)));
+  VERIFY_IS_EQUAL((const_matrix.template rightCols<c>()), (const_matrix.template block<rows, c>(0, cols - c)));
+}
+
+EIGEN_DECLARE_TEST(corners) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(corners(Matrix<float, 1, 1>()));
+    CALL_SUBTEST_2(corners(Matrix4d()));
+    CALL_SUBTEST_3(corners(Matrix<int, 10, 12>()));
+    CALL_SUBTEST_4(corners(MatrixXcf(5, 7)));
+    CALL_SUBTEST_5(corners(MatrixXf(21, 20)));
+
+    CALL_SUBTEST_1((corners_fixedsize<Matrix<float, 1, 1>, 1, 1, 0, 0>()));
+    CALL_SUBTEST_2((corners_fixedsize<Matrix4d, 2, 2, 1, 1>()));
+    CALL_SUBTEST_3((corners_fixedsize<Matrix<int, 10, 12>, 4, 7, 5, 2>()));
+  }
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/ctorleak.cpp

@@ -0,0 +1,79 @@
+#include "main.h"
+
+#include <exception>  // std::exception
+
+struct Foo {
+  static Index object_count;
+  static Index object_limit;
+  int dummy;
+
+  Foo() : dummy(0) {
+#ifdef EIGEN_EXCEPTIONS
+    // TODO: Is this the correct way to handle this?
+    if (Foo::object_count > Foo::object_limit) {
+      std::cout << "\nThrow!\n";
+      throw Foo::Fail();
+    }
+#endif
+    std::cout << '+';
+    ++Foo::object_count;
+  }
+
+  ~Foo() {
+    std::cout << '-';
+    --Foo::object_count;
+  }
+
+  class Fail : public std::exception {};
+};
+
+Index Foo::object_count = 0;
+Index Foo::object_limit = 0;
+
+#undef EIGEN_TEST_MAX_SIZE
+#define EIGEN_TEST_MAX_SIZE 3
+
+EIGEN_DECLARE_TEST(ctorleak) {
+  typedef Matrix<Foo, Dynamic, Dynamic> MatrixX;
+  typedef Matrix<Foo, Dynamic, 1> VectorX;
+
+  Foo::object_count = 0;
+  for (int i = 0; i < g_repeat; i++) {
+    Index rows = internal::random<Index>(2, EIGEN_TEST_MAX_SIZE),
+          cols = internal::random<Index>(2, EIGEN_TEST_MAX_SIZE);
+    Foo::object_limit = rows * cols;
+    {
+      MatrixX r(rows, cols);
+      Foo::object_limit = r.size() + internal::random<Index>(0, rows * cols - 2);
+      std::cout << "object_limit =" << Foo::object_limit << std::endl;
+#ifdef EIGEN_EXCEPTIONS
+      try {
+#endif
+        if (internal::random<bool>()) {
+          std::cout << "\nMatrixX m(" << rows << ", " << cols << ");\n";
+          MatrixX m(rows, cols);
+        } else {
+          std::cout << "\nMatrixX m(r);\n";
+          MatrixX m(r);
+        }
+#ifdef EIGEN_EXCEPTIONS
+        VERIFY(false);             // not reached if exceptions are enabled
+      } catch (const Foo::Fail&) { /* ignore */
+      }
+#endif
+    }
+    VERIFY_IS_EQUAL(Index(0), Foo::object_count);
+
+    {
+      Foo::object_limit = (rows + 1) * (cols + 1);
+      MatrixX A(rows, cols);
+      VERIFY_IS_EQUAL(Foo::object_count, rows * cols);
+      VectorX v = A.row(0);
+      VERIFY_IS_EQUAL(Foo::object_count, (rows + 1) * cols);
+      v = A.col(0);
+      VERIFY_IS_EQUAL(Foo::object_count, rows * (cols + 1));
+    }
+    VERIFY_IS_EQUAL(Index(0), Foo::object_count);
+  }
+  std::cout << "\n";
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/denseLM.cpp

@@ -0,0 +1,172 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Desire Nuentsa <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012 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/.
+
+#include <iostream>
+#include <fstream>
+#include <iomanip>
+
+#include "main.h"
+#include <Eigen/LevenbergMarquardt>
+using namespace std;
+using namespace Eigen;
+
+template <typename Scalar>
+struct DenseLM : DenseFunctor<Scalar> {
+  typedef DenseFunctor<Scalar> Base;
+  typedef typename Base::JacobianType JacobianType;
+  typedef Matrix<Scalar, Dynamic, 1> VectorType;
+
+  DenseLM(int n, int m) : DenseFunctor<Scalar>(n, m) {}
+
+  VectorType model(const VectorType& uv, VectorType& x) {
+    VectorType y;  // Should change to use expression template
+    int m = Base::values();
+    int n = Base::inputs();
+    eigen_assert(uv.size() % 2 == 0);
+    eigen_assert(uv.size() == n);
+    eigen_assert(x.size() == m);
+    y.setZero(m);
+    int half = n / 2;
+    VectorBlock<const VectorType> u(uv, 0, half);
+    VectorBlock<const VectorType> v(uv, half, half);
+    for (int j = 0; j < m; j++) {
+      for (int i = 0; i < half; i++) y(j) += u(i) * std::exp(-(x(j) - i) * (x(j) - i) / (v(i) * v(i)));
+    }
+    return y;
+  }
+  void initPoints(VectorType& uv_ref, VectorType& x) {
+    m_x = x;
+    m_y = this->model(uv_ref, x);
+  }
+
+  int operator()(const VectorType& uv, VectorType& fvec) {
+    int m = Base::values();
+    int n = Base::inputs();
+    eigen_assert(uv.size() % 2 == 0);
+    eigen_assert(uv.size() == n);
+    eigen_assert(fvec.size() == m);
+    int half = n / 2;
+    VectorBlock<const VectorType> u(uv, 0, half);
+    VectorBlock<const VectorType> v(uv, half, half);
+    for (int j = 0; j < m; j++) {
+      fvec(j) = m_y(j);
+      for (int i = 0; i < half; i++) {
+        fvec(j) -= u(i) * std::exp(-(m_x(j) - i) * (m_x(j) - i) / (v(i) * v(i)));
+      }
+    }
+
+    return 0;
+  }
+  int df(const VectorType& uv, JacobianType& fjac) {
+    int m = Base::values();
+    int n = Base::inputs();
+    eigen_assert(n == uv.size());
+    eigen_assert(fjac.rows() == m);
+    eigen_assert(fjac.cols() == n);
+    int half = n / 2;
+    VectorBlock<const VectorType> u(uv, 0, half);
+    VectorBlock<const VectorType> v(uv, half, half);
+    for (int j = 0; j < m; j++) {
+      for (int i = 0; i < half; i++) {
+        fjac.coeffRef(j, i) = -std::exp(-(m_x(j) - i) * (m_x(j) - i) / (v(i) * v(i)));
+        fjac.coeffRef(j, i + half) = -2. * u(i) * (m_x(j) - i) * (m_x(j) - i) / (std::pow(v(i), 3)) *
+                                     std::exp(-(m_x(j) - i) * (m_x(j) - i) / (v(i) * v(i)));
+      }
+    }
+    return 0;
+  }
+  VectorType m_x, m_y;  // Data Points
+};
+
+template <typename FunctorType, typename VectorType>
+int test_minimizeLM(FunctorType& functor, VectorType& uv) {
+  LevenbergMarquardt<FunctorType> lm(functor);
+  LevenbergMarquardtSpace::Status info;
+
+  info = lm.minimize(uv);
+
+  VERIFY_IS_EQUAL(info, 1);
+  // FIXME Check other parameters
+  return info;
+}
+
+template <typename FunctorType, typename VectorType>
+int test_lmder(FunctorType& functor, VectorType& uv) {
+  typedef typename VectorType::Scalar Scalar;
+  LevenbergMarquardtSpace::Status info;
+  LevenbergMarquardt<FunctorType> lm(functor);
+  info = lm.lmder1(uv);
+
+  VERIFY_IS_EQUAL(info, 1);
+  // FIXME Check other parameters
+  return info;
+}
+
+template <typename FunctorType, typename VectorType>
+int test_minimizeSteps(FunctorType& functor, VectorType& uv) {
+  LevenbergMarquardtSpace::Status info;
+  LevenbergMarquardt<FunctorType> lm(functor);
+  info = lm.minimizeInit(uv);
+  if (info == LevenbergMarquardtSpace::ImproperInputParameters) return info;
+  do {
+    info = lm.minimizeOneStep(uv);
+  } while (info == LevenbergMarquardtSpace::Running);
+
+  VERIFY_IS_EQUAL(info, 1);
+  // FIXME Check other parameters
+  return info;
+}
+
+template <typename T>
+void test_denseLM_T() {
+  typedef Matrix<T, Dynamic, 1> VectorType;
+
+  int inputs = 10;
+  int values = 1000;
+  DenseLM<T> dense_gaussian(inputs, values);
+  VectorType uv(inputs), uv_ref(inputs);
+  VectorType x(values);
+
+  // Generate the reference solution
+  uv_ref << -2, 1, 4, 8, 6, 1.8, 1.2, 1.1, 1.9, 3;
+
+  // Generate the reference data points
+  x.setRandom();
+  x = 10 * x;
+  x.array() += 10;
+  dense_gaussian.initPoints(uv_ref, x);
+
+  // Generate the initial parameters
+  VectorBlock<VectorType> u(uv, 0, inputs / 2);
+  VectorBlock<VectorType> v(uv, inputs / 2, inputs / 2);
+
+  // Solve the optimization problem
+
+  // Solve in one go
+  u.setOnes();
+  v.setOnes();
+  test_minimizeLM(dense_gaussian, uv);
+
+  // Solve until the machine precision
+  u.setOnes();
+  v.setOnes();
+  test_lmder(dense_gaussian, uv);
+
+  // Solve step by step
+  v.setOnes();
+  u.setOnes();
+  test_minimizeSteps(dense_gaussian, uv);
+}
+
+EIGEN_DECLARE_TEST(denseLM) {
+  CALL_SUBTEST_2(test_denseLM_T<double>());
+
+  // CALL_SUBTEST_2(test_sparseLM_T<std::complex<double>());
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/dense_storage.cpp

@@ -0,0 +1,285 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2013 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/.
+
+#define EIGEN_TESTING_PLAINOBJECT_CTOR
+
+#include "main.h"
+#include "AnnoyingScalar.h"
+#include "MovableScalar.h"
+#include "SafeScalar.h"
+
+#include <Eigen/Core>
+
+using DenseStorageD3x3 = Eigen::DenseStorage<double, 9, 3, 3, 0>;
+#if !defined(EIGEN_DENSE_STORAGE_CTOR_PLUGIN)
+static_assert(std::is_trivially_copy_constructible<DenseStorageD3x3>::value,
+              "DenseStorage not trivially_copy_constructible");
+static_assert(std::is_trivially_move_constructible<DenseStorageD3x3>::value,
+              "DenseStorage not trivially_move_constructible");
+static_assert(std::is_trivially_copy_assignable<DenseStorageD3x3>::value, "DenseStorage not trivially_copy_assignable");
+static_assert(std::is_trivially_move_assignable<DenseStorageD3x3>::value, "DenseStorage not trivially_move_assignable");
+#endif
+// all plain object types conform to standard layout
+static_assert(std::is_standard_layout<Matrix4f>::value, "Matrix4f not standard_layout");
+static_assert(std::is_standard_layout<Array4f>::value, "Array4f not standard_layout");
+static_assert(std::is_standard_layout<VectorXf>::value, "VectorXf not standard_layout");
+static_assert(std::is_standard_layout<ArrayXf>::value, "ArrayXf not standard_layout");
+static_assert(std::is_standard_layout<MatrixXf>::value, "MatrixXf not standard_layout");
+static_assert(std::is_standard_layout<ArrayXXf>::value, "ArrayXXf not standard_layout");
+// all fixed-size, fixed-dimension plain object types are trivially default constructible
+static_assert(std::is_trivially_default_constructible<Matrix4f>::value, "Matrix4f not trivially_default_constructible");
+static_assert(std::is_trivially_default_constructible<Array4f>::value, "Array4f not trivially_default_constructible");
+// all fixed-size, fixed-dimension plain object types are trivially move constructible
+static_assert(std::is_trivially_move_constructible<Matrix4f>::value, "Matrix4f not trivially_move_constructible");
+static_assert(std::is_trivially_move_constructible<Array4f>::value, "Array4f not trivially_move_constructible");
+// all statically-allocated plain object types are trivially destructible
+static_assert(std::is_trivially_destructible<Matrix4f>::value, "Matrix4f not trivially_destructible");
+static_assert(std::is_trivially_destructible<Array4f>::value, "Array4f not trivially_destructible");
+static_assert(std::is_trivially_destructible<Matrix<float, 4, Dynamic, 0, 4, 4>>::value,
+              "Matrix4X44 not trivially_destructible");
+static_assert(std::is_trivially_destructible<Array<float, 4, Dynamic, 0, 4, 4>>::value,
+              "Array4X44 not trivially_destructible");
+#if !defined(EIGEN_DENSE_STORAGE_CTOR_PLUGIN)
+// all fixed-size, fixed-dimension plain object types are trivially copy constructible
+static_assert(std::is_trivially_copy_constructible<Matrix4f>::value, "Matrix4f not trivially_copy_constructible");
+static_assert(std::is_trivially_copy_constructible<Array4f>::value, "Array4f not trivially_copy_constructible");
+#endif
+
+template <typename T, int Size, int Rows, int Cols>
+void dense_storage_copy(int rows, int cols) {
+  typedef DenseStorage<T, Size, Rows, Cols, 0> DenseStorageType;
+
+  const int size = rows * cols;
+  DenseStorageType reference(size, rows, cols);
+  T* raw_reference = reference.data();
+  for (int i = 0; i < size; ++i) raw_reference[i] = internal::random<T>();
+
+  DenseStorageType copied_reference(reference);
+  const T* raw_copied_reference = copied_reference.data();
+  for (int i = 0; i < size; ++i) VERIFY_IS_EQUAL(raw_reference[i], raw_copied_reference[i]);
+}
+
+template <typename T, int Size, int Rows, int Cols>
+void dense_storage_assignment(int rows, int cols) {
+  typedef DenseStorage<T, Size, Rows, Cols, 0> DenseStorageType;
+
+  const int size = rows * cols;
+  DenseStorageType reference(size, rows, cols);
+  T* raw_reference = reference.data();
+  for (int i = 0; i < size; ++i) raw_reference[i] = internal::random<T>();
+
+  DenseStorageType copied_reference;
+  copied_reference = reference;
+  const T* raw_copied_reference = copied_reference.data();
+  for (int i = 0; i < size; ++i) VERIFY_IS_EQUAL(raw_reference[i], raw_copied_reference[i]);
+}
+
+template <typename T, int Size, int Rows, int Cols>
+void dense_storage_swap(int rowsa, int colsa, int rowsb, int colsb) {
+  typedef DenseStorage<T, Size, Rows, Cols, 0> DenseStorageType;
+
+  const int sizea = rowsa * colsa;
+  ArrayX<T> referencea(sizea);
+  referencea.setRandom();
+  DenseStorageType a(sizea, rowsa, colsa);
+  for (int i = 0; i < sizea; ++i) a.data()[i] = referencea(i);
+
+  const int sizeb = rowsb * colsb;
+  ArrayX<T> referenceb(sizeb);
+  referenceb.setRandom();
+  DenseStorageType b(sizeb, rowsb, colsb);
+  for (int i = 0; i < sizeb; ++i) b.data()[i] = referenceb(i);
+
+  a.swap(b);
+
+  for (int i = 0; i < sizea; i++) VERIFY_IS_EQUAL(b.data()[i], referencea(i));
+  for (int i = 0; i < sizeb; i++) VERIFY_IS_EQUAL(a.data()[i], referenceb(i));
+}
+
+template <typename T, int Size, std::size_t Alignment>
+void dense_storage_alignment() {
+  struct alignas(Alignment) Empty1 {};
+  VERIFY_IS_EQUAL(std::alignment_of<Empty1>::value, Alignment);
+
+  struct EIGEN_ALIGN_TO_BOUNDARY(Alignment) Empty2 {};
+  VERIFY_IS_EQUAL(std::alignment_of<Empty2>::value, Alignment);
+
+  struct Nested1 {
+    EIGEN_ALIGN_TO_BOUNDARY(Alignment) T data[Size];
+  };
+  VERIFY_IS_EQUAL(std::alignment_of<Nested1>::value, Alignment);
+
+  VERIFY_IS_EQUAL((std::alignment_of<internal::plain_array<T, Size, AutoAlign, Alignment>>::value), Alignment);
+
+  const std::size_t default_alignment = internal::compute_default_alignment<T, Size>::value;
+  if (default_alignment > 0) {
+    VERIFY_IS_EQUAL((std::alignment_of<DenseStorage<T, Size, 1, 1, AutoAlign>>::value), default_alignment);
+    VERIFY_IS_EQUAL((std::alignment_of<Matrix<T, Size, 1, AutoAlign>>::value), default_alignment);
+    struct Nested2 {
+      Matrix<T, Size, 1, AutoAlign> mat;
+    };
+    VERIFY_IS_EQUAL(std::alignment_of<Nested2>::value, default_alignment);
+  }
+}
+
+template <typename T>
+void dense_storage_tests() {
+  // Dynamic Storage.
+  dense_storage_copy<T, Dynamic, Dynamic, Dynamic>(4, 3);
+  dense_storage_copy<T, Dynamic, Dynamic, 3>(4, 3);
+  dense_storage_copy<T, Dynamic, 4, Dynamic>(4, 3);
+  // Fixed Storage.
+  dense_storage_copy<T, 12, 4, 3>(4, 3);
+  dense_storage_copy<T, 12, Dynamic, Dynamic>(4, 3);
+  dense_storage_copy<T, 12, 4, Dynamic>(4, 3);
+  dense_storage_copy<T, 12, Dynamic, 3>(4, 3);
+  // Fixed Storage with Uninitialized Elements.
+  dense_storage_copy<T, 18, Dynamic, Dynamic>(4, 3);
+  dense_storage_copy<T, 18, 4, Dynamic>(4, 3);
+  dense_storage_copy<T, 18, Dynamic, 3>(4, 3);
+
+  // Dynamic Storage.
+  dense_storage_assignment<T, Dynamic, Dynamic, Dynamic>(4, 3);
+  dense_storage_assignment<T, Dynamic, Dynamic, 3>(4, 3);
+  dense_storage_assignment<T, Dynamic, 4, Dynamic>(4, 3);
+  // Fixed Storage.
+  dense_storage_assignment<T, 12, 4, 3>(4, 3);
+  dense_storage_assignment<T, 12, Dynamic, Dynamic>(4, 3);
+  dense_storage_assignment<T, 12, 4, Dynamic>(4, 3);
+  dense_storage_assignment<T, 12, Dynamic, 3>(4, 3);
+  // Fixed Storage with Uninitialized Elements.
+  dense_storage_assignment<T, 18, Dynamic, Dynamic>(4, 3);
+  dense_storage_assignment<T, 18, 4, Dynamic>(4, 3);
+  dense_storage_assignment<T, 18, Dynamic, 3>(4, 3);
+
+  // Dynamic Storage.
+  dense_storage_swap<T, Dynamic, Dynamic, Dynamic>(4, 3, 4, 3);
+  dense_storage_swap<T, Dynamic, Dynamic, Dynamic>(4, 3, 2, 1);
+  dense_storage_swap<T, Dynamic, Dynamic, Dynamic>(2, 1, 4, 3);
+  dense_storage_swap<T, Dynamic, Dynamic, 3>(4, 3, 4, 3);
+  dense_storage_swap<T, Dynamic, Dynamic, 3>(4, 3, 2, 3);
+  dense_storage_swap<T, Dynamic, Dynamic, 3>(2, 3, 4, 3);
+  dense_storage_swap<T, Dynamic, 4, Dynamic>(4, 3, 4, 3);
+  dense_storage_swap<T, Dynamic, 4, Dynamic>(4, 3, 4, 1);
+  dense_storage_swap<T, Dynamic, 4, Dynamic>(4, 1, 4, 3);
+  // Fixed Storage.
+  dense_storage_swap<T, 12, 4, 3>(4, 3, 4, 3);
+  dense_storage_swap<T, 12, Dynamic, Dynamic>(4, 3, 4, 3);
+  dense_storage_swap<T, 12, Dynamic, Dynamic>(4, 3, 2, 1);
+  dense_storage_swap<T, 12, Dynamic, Dynamic>(2, 1, 4, 3);
+  dense_storage_swap<T, 12, 4, Dynamic>(4, 3, 4, 3);
+  dense_storage_swap<T, 12, 4, Dynamic>(4, 3, 4, 1);
+  dense_storage_swap<T, 12, 4, Dynamic>(4, 1, 4, 3);
+  dense_storage_swap<T, 12, Dynamic, 3>(4, 3, 4, 3);
+  dense_storage_swap<T, 12, Dynamic, 3>(4, 3, 2, 3);
+  dense_storage_swap<T, 12, Dynamic, 3>(2, 3, 4, 3);
+  // Fixed Storage with Uninitialized Elements.
+  dense_storage_swap<T, 18, Dynamic, Dynamic>(4, 3, 4, 3);
+  dense_storage_swap<T, 18, Dynamic, Dynamic>(4, 3, 2, 1);
+  dense_storage_swap<T, 18, Dynamic, Dynamic>(2, 1, 4, 3);
+  dense_storage_swap<T, 18, 4, Dynamic>(4, 3, 4, 3);
+  dense_storage_swap<T, 18, 4, Dynamic>(4, 3, 4, 1);
+  dense_storage_swap<T, 18, 4, Dynamic>(4, 1, 4, 3);
+  dense_storage_swap<T, 18, Dynamic, 3>(4, 3, 4, 3);
+  dense_storage_swap<T, 18, Dynamic, 3>(4, 3, 2, 3);
+  dense_storage_swap<T, 18, Dynamic, 3>(2, 3, 4, 3);
+
+  dense_storage_alignment<T, 16, 8>();
+  dense_storage_alignment<T, 16, 16>();
+  dense_storage_alignment<T, 16, 32>();
+  dense_storage_alignment<T, 16, 64>();
+}
+
+template <typename PlainType>
+void plaintype_tests() {
+  constexpr int RowsAtCompileTime = PlainType::RowsAtCompileTime;
+  constexpr int ColsAtCompileTime = PlainType::ColsAtCompileTime;
+  constexpr int MaxRowsAtCompileTime = PlainType::MaxRowsAtCompileTime;
+  constexpr int MaxColsAtCompileTime = PlainType::MaxColsAtCompileTime;
+  const Index expectedDefaultRows = RowsAtCompileTime == Dynamic ? 0 : RowsAtCompileTime;
+  const Index expectedDefaultCols = ColsAtCompileTime == Dynamic ? 0 : ColsAtCompileTime;
+  const Index minRows = RowsAtCompileTime == Dynamic ? 0 : RowsAtCompileTime;
+  const Index minCols = ColsAtCompileTime == Dynamic ? 0 : ColsAtCompileTime;
+  const Index maxRows = MaxRowsAtCompileTime == Dynamic ? 100 : MaxRowsAtCompileTime;
+  const Index maxCols = MaxColsAtCompileTime == Dynamic ? 100 : MaxColsAtCompileTime;
+  const Index rows = internal::random<Index>(minRows, maxRows);
+  const Index cols = internal::random<Index>(minCols, maxCols);
+  // default construction
+  PlainType m0;
+  VERIFY_IS_EQUAL(m0.rows(), expectedDefaultRows);
+  VERIFY_IS_EQUAL(m0.cols(), expectedDefaultCols);
+  m0.resize(rows, cols);
+  m0.setRandom();
+  // copy construction
+  PlainType m1(m0);
+  VERIFY_IS_EQUAL(m1.rows(), m0.rows());
+  VERIFY_IS_EQUAL(m1.cols(), m0.cols());
+  VERIFY_IS_CWISE_EQUAL(m1, m0);
+  // move construction
+  PlainType m2(std::move(m1));
+  VERIFY_IS_EQUAL(m2.rows(), m0.rows());
+  VERIFY_IS_EQUAL(m2.cols(), m0.cols());
+  VERIFY_IS_CWISE_EQUAL(m2, m0);
+  // check that object is usable after move construction
+  m1.resize(minRows, minCols);
+  m1.setRandom();
+  // copy assignment
+  m1 = m0;
+  VERIFY_IS_EQUAL(m1.rows(), m0.rows());
+  VERIFY_IS_EQUAL(m1.cols(), m0.cols());
+  VERIFY_IS_CWISE_EQUAL(m1, m0);
+  // move assignment
+  m2.resize(minRows, minCols);
+  m2.setRandom();
+  m2 = std::move(m1);
+  VERIFY_IS_EQUAL(m2.rows(), m0.rows());
+  VERIFY_IS_EQUAL(m2.cols(), m0.cols());
+  VERIFY_IS_CWISE_EQUAL(m2, m0);
+  // check that object is usable after move assignment
+  m1.resize(minRows, minCols);
+  m1.setRandom();
+  m1 = m2;
+  VERIFY_IS_EQUAL(m1.rows(), m0.rows());
+  VERIFY_IS_EQUAL(m1.cols(), m0.cols());
+  VERIFY_IS_CWISE_EQUAL(m1, m0);
+}
+
+EIGEN_DECLARE_TEST(dense_storage) {
+  dense_storage_tests<int>();
+  dense_storage_tests<float>();
+  dense_storage_tests<SafeScalar<float>>();
+  dense_storage_tests<MovableScalar<float>>();
+  dense_storage_tests<AnnoyingScalar>();
+  for (int i = 0; i < g_repeat; i++) {
+    plaintype_tests<Matrix<float, 0, 0, ColMajor>>();
+    plaintype_tests<Matrix<float, Dynamic, Dynamic, ColMajor, 0, 0>>();
+
+    plaintype_tests<Matrix<float, 16, 16, ColMajor>>();
+    plaintype_tests<Matrix<float, 16, Dynamic, ColMajor>>();
+    plaintype_tests<Matrix<float, Dynamic, Dynamic, ColMajor>>();
+    plaintype_tests<Matrix<float, Dynamic, Dynamic, ColMajor, 16, 16>>();
+
+    plaintype_tests<Matrix<SafeScalar<float>, 16, 16, ColMajor>>();
+    plaintype_tests<Matrix<SafeScalar<float>, 16, Dynamic, ColMajor>>();
+    plaintype_tests<Matrix<SafeScalar<float>, Dynamic, Dynamic, ColMajor>>();
+    plaintype_tests<Matrix<SafeScalar<float>, Dynamic, Dynamic, ColMajor, 16, 16>>();
+
+    plaintype_tests<Matrix<MovableScalar<float>, 16, 16, ColMajor>>();
+    plaintype_tests<Matrix<MovableScalar<float>, 16, Dynamic, ColMajor>>();
+    plaintype_tests<Matrix<MovableScalar<float>, Dynamic, Dynamic, ColMajor>>();
+    plaintype_tests<Matrix<MovableScalar<float>, Dynamic, Dynamic, ColMajor, 16, 16>>();
+
+    plaintype_tests<Matrix<AnnoyingScalar, 16, 16, ColMajor>>();
+    plaintype_tests<Matrix<AnnoyingScalar, 16, Dynamic, ColMajor>>();
+    plaintype_tests<Matrix<AnnoyingScalar, Dynamic, Dynamic, ColMajor>>();
+    plaintype_tests<Matrix<AnnoyingScalar, Dynamic, Dynamic, ColMajor, 16, 16>>();
+  }
+}
+
+#undef EIGEN_TESTING_PLAINOBJECT_CTOR

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/determinant.cpp

@@ -0,0 +1,65 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// 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/.
+
+#include "main.h"
+#include <Eigen/LU>
+
+template <typename MatrixType>
+void determinant(const MatrixType& m) {
+  /* this test covers the following files:
+     Determinant.h
+  */
+  Index size = m.rows();
+
+  MatrixType m1(size, size), m2(size, size);
+  m1.setRandom();
+  m2.setRandom();
+  typedef typename MatrixType::Scalar Scalar;
+  Scalar x = internal::random<Scalar>();
+  VERIFY_IS_APPROX(MatrixType::Identity(size, size).determinant(), Scalar(1));
+  VERIFY_IS_APPROX((m1 * m2).eval().determinant(), m1.determinant() * m2.determinant());
+  if (size == 1) return;
+  Index i = internal::random<Index>(0, size - 1);
+  Index j;
+  do {
+    j = internal::random<Index>(0, size - 1);
+  } while (j == i);
+  m2 = m1;
+  m2.row(i).swap(m2.row(j));
+  VERIFY_IS_APPROX(m2.determinant(), -m1.determinant());
+  m2 = m1;
+  m2.col(i).swap(m2.col(j));
+  VERIFY_IS_APPROX(m2.determinant(), -m1.determinant());
+  VERIFY_IS_APPROX(m2.determinant(), m2.transpose().determinant());
+  VERIFY_IS_APPROX(numext::conj(m2.determinant()), m2.adjoint().determinant());
+  m2 = m1;
+  m2.row(i) += x * m2.row(j);
+  VERIFY_IS_APPROX(m2.determinant(), m1.determinant());
+  m2 = m1;
+  m2.row(i) *= x;
+  VERIFY_IS_APPROX(m2.determinant(), m1.determinant() * x);
+
+  // check empty matrix
+  VERIFY_IS_APPROX(m2.block(0, 0, 0, 0).determinant(), Scalar(1));
+}
+
+EIGEN_DECLARE_TEST(determinant) {
+  for (int i = 0; i < g_repeat; i++) {
+    int s = 0;
+    CALL_SUBTEST_1(determinant(Matrix<float, 1, 1>()));
+    CALL_SUBTEST_2(determinant(Matrix<double, 2, 2>()));
+    CALL_SUBTEST_3(determinant(Matrix<double, 3, 3>()));
+    CALL_SUBTEST_4(determinant(Matrix<double, 4, 4>()));
+    CALL_SUBTEST_5(determinant(Matrix<std::complex<double>, 10, 10>()));
+    s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 4);
+    CALL_SUBTEST_6(determinant(MatrixXd(s, s)));
+    TEST_SET_BUT_UNUSED_VARIABLE(s)
+  }
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/diagonal.cpp

@@ -0,0 +1,102 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2010 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"
+
+template <typename MatrixType>
+void diagonal(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  MatrixType m1 = MatrixType::Random(rows, cols), m2 = MatrixType::Random(rows, cols);
+
+  Scalar s1 = internal::random<Scalar>();
+
+  // check diagonal()
+  VERIFY_IS_APPROX(m1.diagonal(), m1.transpose().diagonal());
+  m2.diagonal() = 2 * m1.diagonal();
+  m2.diagonal()[0] *= 3;
+
+  if (rows > 2) {
+    enum { N1 = MatrixType::RowsAtCompileTime > 2 ? 2 : 0, N2 = MatrixType::RowsAtCompileTime > 1 ? -1 : 0 };
+
+    // check sub/super diagonal
+    if (MatrixType::SizeAtCompileTime != Dynamic) {
+      VERIFY(m1.template diagonal<N1>().RowsAtCompileTime == m1.diagonal(N1).size());
+      VERIFY(m1.template diagonal<N2>().RowsAtCompileTime == m1.diagonal(N2).size());
+    }
+
+    m2.template diagonal<N1>() = 2 * m1.template diagonal<N1>();
+    VERIFY_IS_APPROX(m2.template diagonal<N1>(), static_cast<Scalar>(2) * m1.diagonal(N1));
+    m2.template diagonal<N1>()[0] *= 3;
+    VERIFY_IS_APPROX(m2.template diagonal<N1>()[0], static_cast<Scalar>(6) * m1.template diagonal<N1>()[0]);
+
+    m2.template diagonal<N2>() = 2 * m1.template diagonal<N2>();
+    m2.template diagonal<N2>()[0] *= 3;
+    VERIFY_IS_APPROX(m2.template diagonal<N2>()[0], static_cast<Scalar>(6) * m1.template diagonal<N2>()[0]);
+
+    m2.diagonal(N1) = 2 * m1.diagonal(N1);
+    VERIFY_IS_APPROX(m2.template diagonal<N1>(), static_cast<Scalar>(2) * m1.diagonal(N1));
+    m2.diagonal(N1)[0] *= 3;
+    VERIFY_IS_APPROX(m2.diagonal(N1)[0], static_cast<Scalar>(6) * m1.diagonal(N1)[0]);
+
+    m2.diagonal(N2) = 2 * m1.diagonal(N2);
+    VERIFY_IS_APPROX(m2.template diagonal<N2>(), static_cast<Scalar>(2) * m1.diagonal(N2));
+    m2.diagonal(N2)[0] *= 3;
+    VERIFY_IS_APPROX(m2.diagonal(N2)[0], static_cast<Scalar>(6) * m1.diagonal(N2)[0]);
+
+    m2.diagonal(N2).x() = s1;
+    VERIFY_IS_APPROX(m2.diagonal(N2).x(), s1);
+    m2.diagonal(N2).coeffRef(0) = Scalar(2) * s1;
+    VERIFY_IS_APPROX(m2.diagonal(N2).coeff(0), Scalar(2) * s1);
+  }
+
+  VERIFY(m1.diagonal(cols).size() == 0);
+  VERIFY(m1.diagonal(-rows).size() == 0);
+}
+
+template <typename MatrixType>
+void diagonal_assert(const MatrixType& m) {
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  MatrixType m1 = MatrixType::Random(rows, cols);
+
+  if (rows >= 2 && cols >= 2) {
+    VERIFY_RAISES_ASSERT(m1 += m1.diagonal());
+    VERIFY_RAISES_ASSERT(m1 -= m1.diagonal());
+    VERIFY_RAISES_ASSERT(m1.array() *= m1.diagonal().array());
+    VERIFY_RAISES_ASSERT(m1.array() /= m1.diagonal().array());
+  }
+
+  VERIFY_RAISES_ASSERT(m1.diagonal(cols + 1));
+  VERIFY_RAISES_ASSERT(m1.diagonal(-(rows + 1)));
+}
+
+EIGEN_DECLARE_TEST(diagonal) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(diagonal(Matrix<float, 1, 1>()));
+    CALL_SUBTEST_1(diagonal(Matrix<float, 4, 9>()));
+    CALL_SUBTEST_1(diagonal(Matrix<float, 7, 3>()));
+    CALL_SUBTEST_2(diagonal(Matrix4d()));
+    CALL_SUBTEST_2(diagonal(
+        MatrixXcf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_2(diagonal(
+        MatrixXi(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_2(diagonal(
+        MatrixXcd(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_1(diagonal(
+        MatrixXf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_1(diagonal(Matrix<float, Dynamic, 4>(3, 4)));
+    CALL_SUBTEST_1(diagonal_assert(
+        MatrixXf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+  }
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/diagonal_matrix_variadic_ctor.cpp

@@ -0,0 +1,150 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2019 David Tellenbach <david.tellenbach@tellnotes.org>
+//
+// 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"
+
+#define VERIFY_IMPLICIT_CONVERSION_3(DIAGTYPE, V0, V1, V2) \
+  DIAGTYPE d(V0, V1, V2);                                  \
+  DIAGTYPE::DenseMatrixType Dense = d.toDenseMatrix();     \
+  VERIFY_IS_APPROX(Dense(0, 0), (Scalar)V0);               \
+  VERIFY_IS_APPROX(Dense(1, 1), (Scalar)V1);               \
+  VERIFY_IS_APPROX(Dense(2, 2), (Scalar)V2);
+
+#define VERIFY_IMPLICIT_CONVERSION_4(DIAGTYPE, V0, V1, V2, V3) \
+  DIAGTYPE d(V0, V1, V2, V3);                                  \
+  DIAGTYPE::DenseMatrixType Dense = d.toDenseMatrix();         \
+  VERIFY_IS_APPROX(Dense(0, 0), (Scalar)V0);                   \
+  VERIFY_IS_APPROX(Dense(1, 1), (Scalar)V1);                   \
+  VERIFY_IS_APPROX(Dense(2, 2), (Scalar)V2);                   \
+  VERIFY_IS_APPROX(Dense(3, 3), (Scalar)V3);
+
+#define VERIFY_IMPLICIT_CONVERSION_5(DIAGTYPE, V0, V1, V2, V3, V4) \
+  DIAGTYPE d(V0, V1, V2, V3, V4);                                  \
+  DIAGTYPE::DenseMatrixType Dense = d.toDenseMatrix();             \
+  VERIFY_IS_APPROX(Dense(0, 0), (Scalar)V0);                       \
+  VERIFY_IS_APPROX(Dense(1, 1), (Scalar)V1);                       \
+  VERIFY_IS_APPROX(Dense(2, 2), (Scalar)V2);                       \
+  VERIFY_IS_APPROX(Dense(3, 3), (Scalar)V3);                       \
+  VERIFY_IS_APPROX(Dense(4, 4), (Scalar)V4);
+
+template <typename Scalar>
+void constructorTest() {
+  typedef DiagonalMatrix<Scalar, 0> DiagonalMatrix0;
+  typedef DiagonalMatrix<Scalar, 3> DiagonalMatrix3;
+  typedef DiagonalMatrix<Scalar, 4> DiagonalMatrix4;
+  typedef DiagonalMatrix<Scalar, Dynamic> DiagonalMatrixX;
+
+  Scalar raw[7];
+  for (int k = 0; k < 7; ++k) raw[k] = internal::random<Scalar>();
+
+  // Fixed-sized matrices
+  {
+    DiagonalMatrix0 a{{}};
+    VERIFY(a.rows() == 0);
+    VERIFY(a.cols() == 0);
+    typename DiagonalMatrix0::DenseMatrixType m = a.toDenseMatrix();
+    for (Index k = 0; k < a.rows(); ++k) VERIFY(m(k, k) == raw[k]);
+  }
+  {
+    DiagonalMatrix3 a{{raw[0], raw[1], raw[2]}};
+    VERIFY(a.rows() == 3);
+    VERIFY(a.cols() == 3);
+    typename DiagonalMatrix3::DenseMatrixType m = a.toDenseMatrix();
+    for (Index k = 0; k < a.rows(); ++k) VERIFY(m(k, k) == raw[k]);
+  }
+  {
+    DiagonalMatrix4 a{{raw[0], raw[1], raw[2], raw[3]}};
+    VERIFY(a.rows() == 4);
+    VERIFY(a.cols() == 4);
+    typename DiagonalMatrix4::DenseMatrixType m = a.toDenseMatrix();
+    for (Index k = 0; k < a.rows(); ++k) VERIFY(m(k, k) == raw[k]);
+  }
+
+  // dynamically sized matrices
+  {
+    DiagonalMatrixX a{{}};
+    VERIFY(a.rows() == 0);
+    VERIFY(a.rows() == 0);
+    typename DiagonalMatrixX::DenseMatrixType m = a.toDenseMatrix();
+    for (Index k = 0; k < a.rows(); ++k) VERIFY(m(k, k) == raw[k]);
+  }
+  {
+    DiagonalMatrixX a{{raw[0], raw[1], raw[2], raw[3], raw[4], raw[5], raw[6]}};
+    VERIFY(a.rows() == 7);
+    VERIFY(a.rows() == 7);
+    typename DiagonalMatrixX::DenseMatrixType m = a.toDenseMatrix();
+    for (Index k = 0; k < a.rows(); ++k) VERIFY(m(k, k) == raw[k]);
+  }
+}
+
+template <>
+void constructorTest<float>() {
+  typedef float Scalar;
+
+  typedef DiagonalMatrix<Scalar, 0> DiagonalMatrix0;
+  typedef DiagonalMatrix<Scalar, 3> DiagonalMatrix3;
+  typedef DiagonalMatrix<Scalar, 4> DiagonalMatrix4;
+  typedef DiagonalMatrix<Scalar, 5> DiagonalMatrix5;
+  typedef DiagonalMatrix<Scalar, Dynamic> DiagonalMatrixX;
+
+  Scalar raw[7];
+  for (int k = 0; k < 7; ++k) raw[k] = internal::random<Scalar>();
+
+  // Fixed-sized matrices
+  {
+    DiagonalMatrix0 a{{}};
+    VERIFY(a.rows() == 0);
+    VERIFY(a.cols() == 0);
+    typename DiagonalMatrix0::DenseMatrixType m = a.toDenseMatrix();
+    for (Index k = 0; k < a.rows(); ++k) VERIFY(m(k, k) == raw[k]);
+  }
+  {
+    DiagonalMatrix3 a{{raw[0], raw[1], raw[2]}};
+    VERIFY(a.rows() == 3);
+    VERIFY(a.cols() == 3);
+    typename DiagonalMatrix3::DenseMatrixType m = a.toDenseMatrix();
+    for (Index k = 0; k < a.rows(); ++k) VERIFY(m(k, k) == raw[k]);
+  }
+  {
+    DiagonalMatrix4 a{{raw[0], raw[1], raw[2], raw[3]}};
+    VERIFY(a.rows() == 4);
+    VERIFY(a.cols() == 4);
+    typename DiagonalMatrix4::DenseMatrixType m = a.toDenseMatrix();
+    for (Index k = 0; k < a.rows(); ++k) VERIFY(m(k, k) == raw[k]);
+  }
+
+  // dynamically sized matrices
+  {
+    DiagonalMatrixX a{{}};
+    VERIFY(a.rows() == 0);
+    VERIFY(a.rows() == 0);
+    typename DiagonalMatrixX::DenseMatrixType m = a.toDenseMatrix();
+    for (Index k = 0; k < a.rows(); ++k) VERIFY(m(k, k) == raw[k]);
+  }
+  {
+    DiagonalMatrixX a{{raw[0], raw[1], raw[2], raw[3], raw[4], raw[5], raw[6]}};
+    VERIFY(a.rows() == 7);
+    VERIFY(a.rows() == 7);
+    typename DiagonalMatrixX::DenseMatrixType m = a.toDenseMatrix();
+    for (Index k = 0; k < a.rows(); ++k) VERIFY(m(k, k) == raw[k]);
+  }
+  { VERIFY_IMPLICIT_CONVERSION_3(DiagonalMatrix3, 1.2647, 2.56f, -3); }
+  { VERIFY_IMPLICIT_CONVERSION_4(DiagonalMatrix4, 1.2647, 2.56f, -3, 3.23f); }
+  { VERIFY_IMPLICIT_CONVERSION_5(DiagonalMatrix5, 1.2647, 2.56f, -3, 3.23f, 2); }
+}
+
+EIGEN_DECLARE_TEST(diagonal_matrix_variadic_ctor) {
+  CALL_SUBTEST_2(constructorTest<unsigned char>());
+  CALL_SUBTEST_2(constructorTest<float>());
+  CALL_SUBTEST_2(constructorTest<Index>());
+  CALL_SUBTEST_2(constructorTest<int>());
+  CALL_SUBTEST_2(constructorTest<long int>());
+  CALL_SUBTEST_2(constructorTest<std::ptrdiff_t>());
+  CALL_SUBTEST_2(constructorTest<std::complex<double>>());
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/diagonalmatrices.cpp

@@ -0,0 +1,197 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 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/.
+
+// discard stack allocation as that too bypasses malloc
+#define EIGEN_STACK_ALLOCATION_LIMIT 0
+// heap allocation will raise an assert if enabled at runtime
+#define EIGEN_RUNTIME_NO_MALLOC
+
+#include "main.h"
+using namespace std;
+template <typename MatrixType>
+void diagonalmatrices(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  enum { Rows = MatrixType::RowsAtCompileTime, Cols = MatrixType::ColsAtCompileTime };
+  typedef Matrix<Scalar, Rows, 1> VectorType;
+  typedef Matrix<Scalar, 1, Cols> RowVectorType;
+  typedef Matrix<Scalar, Rows, Rows> SquareMatrixType;
+  typedef Matrix<Scalar, Dynamic, Dynamic> DynMatrixType;
+  typedef DiagonalMatrix<Scalar, Rows> LeftDiagonalMatrix;
+  typedef DiagonalMatrix<Scalar, Cols> RightDiagonalMatrix;
+  typedef Matrix<Scalar, Rows == Dynamic ? Dynamic : 2 * Rows, Cols == Dynamic ? Dynamic : 2 * Cols> BigMatrix;
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  MatrixType m1 = MatrixType::Random(rows, cols), m2 = MatrixType::Random(rows, cols);
+  VectorType v1 = VectorType::Random(rows), v2 = VectorType::Random(rows);
+  RowVectorType rv1 = RowVectorType::Random(cols), rv2 = RowVectorType::Random(cols);
+
+  LeftDiagonalMatrix ldm1(v1), ldm2(v2);
+  RightDiagonalMatrix rdm1(rv1), rdm2(rv2);
+
+  Scalar s1 = internal::random<Scalar>();
+
+  SquareMatrixType sq_m1(v1.asDiagonal());
+  VERIFY_IS_APPROX(sq_m1, v1.asDiagonal().toDenseMatrix());
+  sq_m1 = v1.asDiagonal();
+  VERIFY_IS_APPROX(sq_m1, v1.asDiagonal().toDenseMatrix());
+  SquareMatrixType sq_m2 = v1.asDiagonal();
+  VERIFY_IS_APPROX(sq_m1, sq_m2);
+
+  ldm1 = v1.asDiagonal();
+  LeftDiagonalMatrix ldm3(v1);
+  VERIFY_IS_APPROX(ldm1.diagonal(), ldm3.diagonal());
+  LeftDiagonalMatrix ldm4 = v1.asDiagonal();
+  VERIFY_IS_APPROX(ldm1.diagonal(), ldm4.diagonal());
+
+  sq_m1.block(0, 0, rows, rows) = ldm1;
+  VERIFY_IS_APPROX(sq_m1, ldm1.toDenseMatrix());
+  sq_m1.transpose() = ldm1;
+  VERIFY_IS_APPROX(sq_m1, ldm1.toDenseMatrix());
+
+  Index i = internal::random<Index>(0, rows - 1);
+  Index j = internal::random<Index>(0, cols - 1);
+
+  internal::set_is_malloc_allowed(false);
+  VERIFY_IS_APPROX(((ldm1 * m1)(i, j)), ldm1.diagonal()(i) * m1(i, j));
+  VERIFY_IS_APPROX(((ldm1 * (m1 + m2))(i, j)), ldm1.diagonal()(i) * (m1 + m2)(i, j));
+  VERIFY_IS_APPROX(((m1 * rdm1)(i, j)), rdm1.diagonal()(j) * m1(i, j));
+  VERIFY_IS_APPROX(((v1.asDiagonal() * m1)(i, j)), v1(i) * m1(i, j));
+  VERIFY_IS_APPROX(((m1 * rv1.asDiagonal())(i, j)), rv1(j) * m1(i, j));
+  VERIFY_IS_APPROX((((v1 + v2).asDiagonal() * m1)(i, j)), (v1 + v2)(i)*m1(i, j));
+  VERIFY_IS_APPROX((((v1 + v2).asDiagonal() * (m1 + m2))(i, j)), (v1 + v2)(i) * (m1 + m2)(i, j));
+  VERIFY_IS_APPROX(((m1 * (rv1 + rv2).asDiagonal())(i, j)), (rv1 + rv2)(j)*m1(i, j));
+  VERIFY_IS_APPROX((((m1 + m2) * (rv1 + rv2).asDiagonal())(i, j)), (rv1 + rv2)(j) * (m1 + m2)(i, j));
+  VERIFY_IS_APPROX((ldm1 * ldm1).diagonal()(i), ldm1.diagonal()(i) * ldm1.diagonal()(i));
+  VERIFY_IS_APPROX((ldm1 * ldm1 * m1)(i, j), ldm1.diagonal()(i) * ldm1.diagonal()(i) * m1(i, j));
+  VERIFY_IS_APPROX(((v1.asDiagonal() * v1.asDiagonal()).diagonal()(i)), v1(i) * v1(i));
+  internal::set_is_malloc_allowed(true);
+
+  if (rows > 1) {
+    DynMatrixType tmp = m1.topRows(rows / 2), res;
+    VERIFY_IS_APPROX((res = m1.topRows(rows / 2) * rv1.asDiagonal()), tmp * rv1.asDiagonal());
+    VERIFY_IS_APPROX((res = v1.head(rows / 2).asDiagonal() * m1.topRows(rows / 2)),
+                     v1.head(rows / 2).asDiagonal() * tmp);
+  }
+
+  BigMatrix big;
+  big.setZero(2 * rows, 2 * cols);
+
+  big.block(i, j, rows, cols) = m1;
+  big.block(i, j, rows, cols) = v1.asDiagonal() * big.block(i, j, rows, cols);
+
+  VERIFY_IS_APPROX((big.block(i, j, rows, cols)), v1.asDiagonal() * m1);
+
+  big.block(i, j, rows, cols) = m1;
+  big.block(i, j, rows, cols) = big.block(i, j, rows, cols) * rv1.asDiagonal();
+  VERIFY_IS_APPROX((big.block(i, j, rows, cols)), m1 * rv1.asDiagonal());
+
+  // products do not allocate memory
+  MatrixType res(rows, cols);
+  internal::set_is_malloc_allowed(false);
+  res.noalias() = ldm1 * m1;
+  res.noalias() = m1 * rdm1;
+  res.noalias() = ldm1 * m1 * rdm1;
+  res.noalias() = LeftDiagonalMatrix::Identity(rows) * m1 * RightDiagonalMatrix::Zero(cols);
+  internal::set_is_malloc_allowed(true);
+
+  // scalar multiple
+  VERIFY_IS_APPROX(LeftDiagonalMatrix(ldm1 * s1).diagonal(), ldm1.diagonal() * s1);
+  VERIFY_IS_APPROX(LeftDiagonalMatrix(s1 * ldm1).diagonal(), s1 * ldm1.diagonal());
+
+  VERIFY_IS_APPROX(m1 * (rdm1 * s1), (m1 * rdm1) * s1);
+  VERIFY_IS_APPROX(m1 * (s1 * rdm1), (m1 * rdm1) * s1);
+
+  // Diagonal to dense
+  sq_m1.setRandom();
+  sq_m2 = sq_m1;
+  VERIFY_IS_APPROX((sq_m1 += (s1 * v1).asDiagonal()), sq_m2 += (s1 * v1).asDiagonal().toDenseMatrix());
+  VERIFY_IS_APPROX((sq_m1 -= (s1 * v1).asDiagonal()), sq_m2 -= (s1 * v1).asDiagonal().toDenseMatrix());
+  VERIFY_IS_APPROX((sq_m1 = (s1 * v1).asDiagonal()), (s1 * v1).asDiagonal().toDenseMatrix());
+
+  sq_m1.setRandom();
+  sq_m2 = v1.asDiagonal();
+  sq_m2 = sq_m1 * sq_m2;
+  VERIFY_IS_APPROX((sq_m1 * v1.asDiagonal()).col(i), sq_m2.col(i));
+  VERIFY_IS_APPROX((sq_m1 * v1.asDiagonal()).row(i), sq_m2.row(i));
+
+  sq_m1 = v1.asDiagonal();
+  sq_m2 = v2.asDiagonal();
+  SquareMatrixType sq_m3 = v1.asDiagonal();
+  VERIFY_IS_APPROX(sq_m3 = v1.asDiagonal() + v2.asDiagonal(), sq_m1 + sq_m2);
+  VERIFY_IS_APPROX(sq_m3 = v1.asDiagonal() - v2.asDiagonal(), sq_m1 - sq_m2);
+  VERIFY_IS_APPROX(sq_m3 = v1.asDiagonal() - 2 * v2.asDiagonal() + v1.asDiagonal(), sq_m1 - 2 * sq_m2 + sq_m1);
+
+  // Zero and Identity
+  LeftDiagonalMatrix zero = LeftDiagonalMatrix::Zero(rows);
+  LeftDiagonalMatrix identity = LeftDiagonalMatrix::Identity(rows);
+  VERIFY_IS_APPROX(identity.diagonal().sum(), Scalar(rows));
+  VERIFY_IS_APPROX(zero.diagonal().sum(), Scalar(0));
+  VERIFY_IS_APPROX((zero + 2 * LeftDiagonalMatrix::Identity(rows)).diagonal().sum(), Scalar(2 * rows));
+}
+
+template <typename MatrixType>
+void as_scalar_product(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
+  typedef Matrix<Scalar, Dynamic, Dynamic> DynMatrixType;
+  typedef Matrix<Scalar, Dynamic, 1> DynVectorType;
+  typedef Matrix<Scalar, 1, Dynamic> DynRowVectorType;
+
+  Index rows = m.rows();
+  Index depth = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
+
+  VectorType v1 = VectorType::Random(rows);
+  DynVectorType dv1 = DynVectorType::Random(depth);
+  DynRowVectorType drv1 = DynRowVectorType::Random(depth);
+  DynMatrixType dm1 = dv1;
+  DynMatrixType drm1 = drv1;
+
+  Scalar s = v1(0);
+
+  VERIFY_IS_APPROX(v1.asDiagonal() * drv1, s * drv1);
+  VERIFY_IS_APPROX(dv1 * v1.asDiagonal(), dv1 * s);
+
+  VERIFY_IS_APPROX(v1.asDiagonal() * drm1, s * drm1);
+  VERIFY_IS_APPROX(dm1 * v1.asDiagonal(), dm1 * s);
+}
+
+template <int>
+void bug987() {
+  Matrix3Xd points = Matrix3Xd::Random(3, 3);
+  Vector2d diag = Vector2d::Random();
+  Matrix2Xd tmp1 = points.topRows<2>(), res1, res2;
+  VERIFY_IS_APPROX(res1 = diag.asDiagonal() * points.topRows<2>(), res2 = diag.asDiagonal() * tmp1);
+  Matrix2d tmp2 = points.topLeftCorner<2, 2>();
+  VERIFY_IS_APPROX((res1 = points.topLeftCorner<2, 2>() * diag.asDiagonal()), res2 = tmp2 * diag.asDiagonal());
+}
+
+EIGEN_DECLARE_TEST(diagonalmatrices) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(diagonalmatrices(Matrix<float, 1, 1>()));
+    CALL_SUBTEST_1(as_scalar_product(Matrix<float, 1, 1>()));
+
+    CALL_SUBTEST_2(diagonalmatrices(Matrix3f()));
+    CALL_SUBTEST_3(diagonalmatrices(Matrix<double, 3, 3, RowMajor>()));
+    CALL_SUBTEST_4(diagonalmatrices(Matrix4d()));
+    CALL_SUBTEST_5(diagonalmatrices(Matrix<float, 4, 4, RowMajor>()));
+    CALL_SUBTEST_6(diagonalmatrices(
+        MatrixXcf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_6(as_scalar_product(MatrixXcf(1, 1)));
+    CALL_SUBTEST_7(diagonalmatrices(
+        MatrixXi(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_8(diagonalmatrices(Matrix<double, Dynamic, Dynamic, RowMajor>(
+        internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_9(diagonalmatrices(
+        MatrixXf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_9(diagonalmatrices(MatrixXf(1, 1)));
+    CALL_SUBTEST_9(as_scalar_product(MatrixXf(1, 1)));
+  }
+  CALL_SUBTEST_10(bug987<0>());
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/dontalign.cpp

@@ -0,0 +1,60 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 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/.
+
+#if defined EIGEN_TEST_PART_1 || defined EIGEN_TEST_PART_2 || defined EIGEN_TEST_PART_3 || defined EIGEN_TEST_PART_4
+#define EIGEN_DONT_ALIGN
+#elif defined EIGEN_TEST_PART_5 || defined EIGEN_TEST_PART_6 || defined EIGEN_TEST_PART_7 || defined EIGEN_TEST_PART_8
+#define EIGEN_DONT_ALIGN_STATICALLY
+#endif
+
+#include "main.h"
+#include <Eigen/Dense>
+
+template <typename MatrixType>
+void dontalign(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> SquareMatrixType;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  MatrixType a = MatrixType::Random(rows, cols);
+  SquareMatrixType square = SquareMatrixType::Random(rows, rows);
+  VectorType v = VectorType::Random(rows);
+
+  VERIFY_IS_APPROX(v, square * square.colPivHouseholderQr().solve(v));
+  square = square.inverse().eval();
+  a = square * a;
+  square = square * square;
+  v = square * v;
+  v = a.adjoint() * v;
+  VERIFY(square.determinant() != Scalar(0));
+
+  // bug 219: MapAligned() was giving an assert with EIGEN_DONT_ALIGN, because Map Flags were miscomputed
+  Scalar* array = internal::aligned_new<Scalar>(rows);
+  v = VectorType::MapAligned(array, rows);
+  internal::aligned_delete(array, rows);
+}
+
+EIGEN_DECLARE_TEST(dontalign) {
+#if defined EIGEN_TEST_PART_1 || defined EIGEN_TEST_PART_5
+  dontalign(Matrix3d());
+  dontalign(Matrix4f());
+#elif defined EIGEN_TEST_PART_2 || defined EIGEN_TEST_PART_6
+  dontalign(Matrix3cd());
+  dontalign(Matrix4cf());
+#elif defined EIGEN_TEST_PART_3 || defined EIGEN_TEST_PART_7
+  dontalign(Matrix<float, 32, 32>());
+  dontalign(Matrix<std::complex<float>, 32, 32>());
+#elif defined EIGEN_TEST_PART_4 || defined EIGEN_TEST_PART_8
+  dontalign(MatrixXd(32, 32));
+  dontalign(MatrixXcf(32, 32));
+#endif
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/dynalloc.cpp

@@ -0,0 +1,168 @@
+// 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/.
+
+#include "main.h"
+
+#if EIGEN_MAX_ALIGN_BYTES > 0
+#define ALIGNMENT EIGEN_MAX_ALIGN_BYTES
+#else
+#define ALIGNMENT 1
+#endif
+
+typedef Matrix<float, 16, 1> Vector16f;
+typedef Matrix<float, 8, 1> Vector8f;
+
+void check_handmade_aligned_malloc() {
+  // Hand-make alignment needs at least sizeof(void*) to store the offset.
+  constexpr int alignment = (std::max<int>)(EIGEN_DEFAULT_ALIGN_BYTES, sizeof(void *));
+
+  for (int i = 1; i < 1000; i++) {
+    char *p = (char *)internal::handmade_aligned_malloc(i, alignment);
+    VERIFY(std::uintptr_t(p) % ALIGNMENT == 0);
+    // if the buffer is wrongly allocated this will give a bad write --> check with valgrind
+    for (int j = 0; j < i; j++) p[j] = 0;
+    internal::handmade_aligned_free(p);
+  }
+}
+
+void check_aligned_malloc() {
+  for (int i = ALIGNMENT; i < 1000; i++) {
+    char *p = (char *)internal::aligned_malloc(i);
+    VERIFY(std::uintptr_t(p) % ALIGNMENT == 0);
+    // if the buffer is wrongly allocated this will give a bad write --> check with valgrind
+    for (int j = 0; j < i; j++) p[j] = 0;
+    internal::aligned_free(p);
+  }
+}
+
+void check_aligned_new() {
+  for (int i = ALIGNMENT; i < 1000; i++) {
+    float *p = internal::aligned_new<float>(i);
+    VERIFY(std::uintptr_t(p) % ALIGNMENT == 0);
+    // if the buffer is wrongly allocated this will give a bad write --> check with valgrind
+    for (int j = 0; j < i; j++) p[j] = 0;
+    internal::aligned_delete(p, i);
+  }
+}
+
+void check_aligned_stack_alloc() {
+  for (int i = ALIGNMENT; i < 400; i++) {
+    ei_declare_aligned_stack_constructed_variable(float, p, i, 0);
+    VERIFY(std::uintptr_t(p) % ALIGNMENT == 0);
+    // if the buffer is wrongly allocated this will give a bad write --> check with valgrind
+    for (int j = 0; j < i; j++) p[j] = 0;
+  }
+}
+
+// test compilation with both a struct and a class...
+struct MyStruct {
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+  char dummychar;
+  Vector16f avec;
+};
+
+class MyClassA {
+ public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+  char dummychar;
+  Vector16f avec;
+};
+
+template <typename T>
+void check_dynaligned() {
+  // TODO have to be updated once we support multiple alignment values
+  if (T::SizeAtCompileTime % ALIGNMENT == 0) {
+    T *obj = new T;
+    VERIFY(T::NeedsToAlign == 1);
+    VERIFY(std::uintptr_t(obj) % ALIGNMENT == 0);
+    delete obj;
+  }
+}
+
+template <typename T>
+void check_custom_new_delete() {
+  {
+    T *t = new T;
+    delete t;
+  }
+
+  {
+    std::size_t N = internal::random<std::size_t>(1, 10);
+    T *t = new T[N];
+    delete[] t;
+  }
+
+#if EIGEN_MAX_ALIGN_BYTES > 0 && (!EIGEN_HAS_CXX17_OVERALIGN)
+  {
+    T *t = static_cast<T *>((T::operator new)(sizeof(T)));
+    (T::operator delete)(t, sizeof(T));
+  }
+
+  {
+    T *t = static_cast<T *>((T::operator new)(sizeof(T)));
+    (T::operator delete)(t);
+  }
+#endif
+}
+
+EIGEN_DECLARE_TEST(dynalloc) {
+  // low level dynamic memory allocation
+  CALL_SUBTEST(check_handmade_aligned_malloc());
+  CALL_SUBTEST(check_aligned_malloc());
+  CALL_SUBTEST(check_aligned_new());
+  CALL_SUBTEST(check_aligned_stack_alloc());
+
+  for (int i = 0; i < g_repeat * 100; ++i) {
+    CALL_SUBTEST(check_custom_new_delete<Vector4f>());
+    CALL_SUBTEST(check_custom_new_delete<Vector2f>());
+    CALL_SUBTEST(check_custom_new_delete<Matrix4f>());
+    CALL_SUBTEST(check_custom_new_delete<MatrixXi>());
+  }
+
+// check static allocation, who knows ?
+#if EIGEN_MAX_STATIC_ALIGN_BYTES
+  for (int i = 0; i < g_repeat * 100; ++i) {
+    CALL_SUBTEST(check_dynaligned<Vector4f>());
+    CALL_SUBTEST(check_dynaligned<Vector2d>());
+    CALL_SUBTEST(check_dynaligned<Matrix4f>());
+    CALL_SUBTEST(check_dynaligned<Vector4d>());
+    CALL_SUBTEST(check_dynaligned<Vector4i>());
+    CALL_SUBTEST(check_dynaligned<Vector8f>());
+    CALL_SUBTEST(check_dynaligned<Vector16f>());
+  }
+
+  {
+    MyStruct foo0;
+    VERIFY(std::uintptr_t(foo0.avec.data()) % ALIGNMENT == 0);
+    MyClassA fooA;
+    VERIFY(std::uintptr_t(fooA.avec.data()) % ALIGNMENT == 0);
+  }
+
+  // dynamic allocation, single object
+  for (int i = 0; i < g_repeat * 100; ++i) {
+    MyStruct *foo0 = new MyStruct();
+    VERIFY(std::uintptr_t(foo0->avec.data()) % ALIGNMENT == 0);
+    MyClassA *fooA = new MyClassA();
+    VERIFY(std::uintptr_t(fooA->avec.data()) % ALIGNMENT == 0);
+    delete foo0;
+    delete fooA;
+  }
+
+  // dynamic allocation, array
+  const int N = 10;
+  for (int i = 0; i < g_repeat * 100; ++i) {
+    MyStruct *foo0 = new MyStruct[N];
+    VERIFY(std::uintptr_t(foo0->avec.data()) % ALIGNMENT == 0);
+    MyClassA *fooA = new MyClassA[N];
+    VERIFY(std::uintptr_t(fooA->avec.data()) % ALIGNMENT == 0);
+    delete[] foo0;
+    delete[] fooA;
+  }
+#endif
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/eigen2support.cpp

@@ -0,0 +1,62 @@
+// 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/.
+
+#define EIGEN2_SUPPORT
+
+#include "main.h"
+
+template <typename MatrixType>
+void eigen2support(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  MatrixType m1 = MatrixType::Random(rows, cols), m3(rows, cols);
+
+  Scalar s1 = internal::random<Scalar>(), s2 = internal::random<Scalar>();
+
+  // scalar addition
+  VERIFY_IS_APPROX(m1.cwise() + s1, s1 + m1.cwise());
+  VERIFY_IS_APPROX(m1.cwise() + s1, MatrixType::Constant(rows, cols, s1) + m1);
+  VERIFY_IS_APPROX((m1 * Scalar(2)).cwise() - s2, (m1 + m1) - MatrixType::Constant(rows, cols, s2));
+  m3 = m1;
+  m3.cwise() += s2;
+  VERIFY_IS_APPROX(m3, m1.cwise() + s2);
+  m3 = m1;
+  m3.cwise() -= s1;
+  VERIFY_IS_APPROX(m3, m1.cwise() - s1);
+
+  VERIFY_IS_EQUAL((m1.corner(TopLeft, 1, 1)), (m1.block(0, 0, 1, 1)));
+  VERIFY_IS_EQUAL((m1.template corner<1, 1>(TopLeft)), (m1.template block<1, 1>(0, 0)));
+  VERIFY_IS_EQUAL((m1.col(0).start(1)), (m1.col(0).segment(0, 1)));
+  VERIFY_IS_EQUAL((m1.col(0).template start<1>()), (m1.col(0).segment(0, 1)));
+  VERIFY_IS_EQUAL((m1.col(0).end(1)), (m1.col(0).segment(rows - 1, 1)));
+  VERIFY_IS_EQUAL((m1.col(0).template end<1>()), (m1.col(0).segment(rows - 1, 1)));
+
+  using numext::abs2;
+  using numext::real;
+  using std::cos;
+  VERIFY_IS_EQUAL(ei_cos(s1), cos(s1));
+  VERIFY_IS_EQUAL(ei_real(s1), real(s1));
+  VERIFY_IS_EQUAL(ei_abs2(s1), abs2(s1));
+
+  m1.minor(0, 0);
+}
+
+EIGEN_DECLARE_TEST(eigen2support) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(eigen2support(Matrix<double, 1, 1>()));
+    CALL_SUBTEST_2(eigen2support(MatrixXd(1, 1)));
+    CALL_SUBTEST_4(eigen2support(Matrix3f()));
+    CALL_SUBTEST_5(eigen2support(Matrix4d()));
+    CALL_SUBTEST_2(eigen2support(MatrixXf(200, 200)));
+    CALL_SUBTEST_6(eigen2support(MatrixXcd(100, 100)));
+  }
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/eigensolver_complex.cpp

@@ -0,0 +1,173 @@
+// 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) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// 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 <limits>
+#include <Eigen/Eigenvalues>
+#include <Eigen/LU>
+#include "CustomComplex.h"
+
+template <typename MatrixType>
+bool find_pivot(typename MatrixType::Scalar tol, MatrixType& diffs, Index col = 0) {
+  bool match = diffs.diagonal().sum() <= tol;
+  if (match || col == diffs.cols()) {
+    return match;
+  } else {
+    Index n = diffs.cols();
+    std::vector<std::pair<Index, Index> > transpositions;
+    for (Index i = col; i < n; ++i) {
+      Index best_index(0);
+      if (diffs.col(col).segment(col, n - i).minCoeff(&best_index) > tol) break;
+
+      best_index += col;
+
+      diffs.row(col).swap(diffs.row(best_index));
+      if (find_pivot(tol, diffs, col + 1)) return true;
+      diffs.row(col).swap(diffs.row(best_index));
+
+      // move current pivot to the end
+      diffs.row(n - (i - col) - 1).swap(diffs.row(best_index));
+      transpositions.push_back(std::pair<Index, Index>(n - (i - col) - 1, best_index));
+    }
+    // restore
+    for (Index k = transpositions.size() - 1; k >= 0; --k)
+      diffs.row(transpositions[k].first).swap(diffs.row(transpositions[k].second));
+  }
+  return false;
+}
+
+/* Check that two column vectors are approximately equal up to permutations.
+ * Initially, this method checked that the k-th power sums are equal for all k = 1, ..., vec1.rows(),
+ * however this strategy is numerically inaccurate because of numerical cancellation issues.
+ */
+template <typename VectorType>
+void verify_is_approx_upto_permutation(const VectorType& vec1, const VectorType& vec2) {
+  typedef typename VectorType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  VERIFY(vec1.cols() == 1);
+  VERIFY(vec2.cols() == 1);
+  VERIFY(vec1.rows() == vec2.rows());
+
+  Index n = vec1.rows();
+  RealScalar tol = test_precision<RealScalar>() * test_precision<RealScalar>() *
+                   numext::maxi(vec1.squaredNorm(), vec2.squaredNorm());
+  Matrix<RealScalar, Dynamic, Dynamic> diffs =
+      (vec1.rowwise().replicate(n) - vec2.rowwise().replicate(n).transpose()).cwiseAbs2();
+
+  VERIFY(find_pivot(tol, diffs));
+}
+
+template <typename MatrixType>
+void eigensolver(const MatrixType& m) {
+  /* this test covers the following files:
+     ComplexEigenSolver.h, and indirectly ComplexSchur.h
+  */
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  MatrixType a = MatrixType::Random(rows, cols);
+  MatrixType symmA = a.adjoint() * a;
+
+  ComplexEigenSolver<MatrixType> ei0(symmA);
+  VERIFY_IS_EQUAL(ei0.info(), Success);
+  VERIFY_IS_APPROX(symmA * ei0.eigenvectors(), ei0.eigenvectors() * ei0.eigenvalues().asDiagonal());
+
+  ComplexEigenSolver<MatrixType> ei1(a);
+  VERIFY_IS_EQUAL(ei1.info(), Success);
+  VERIFY_IS_APPROX(a * ei1.eigenvectors(), ei1.eigenvectors() * ei1.eigenvalues().asDiagonal());
+  // Note: If MatrixType is real then a.eigenvalues() uses EigenSolver and thus
+  // another algorithm so results may differ slightly
+  verify_is_approx_upto_permutation(a.eigenvalues(), ei1.eigenvalues());
+
+  ComplexEigenSolver<MatrixType> ei2;
+  ei2.setMaxIterations(ComplexSchur<MatrixType>::m_maxIterationsPerRow * rows).compute(a);
+  VERIFY_IS_EQUAL(ei2.info(), Success);
+  VERIFY_IS_EQUAL(ei2.eigenvectors(), ei1.eigenvectors());
+  VERIFY_IS_EQUAL(ei2.eigenvalues(), ei1.eigenvalues());
+  if (rows > 2) {
+    ei2.setMaxIterations(1).compute(a);
+    VERIFY_IS_EQUAL(ei2.info(), NoConvergence);
+    VERIFY_IS_EQUAL(ei2.getMaxIterations(), 1);
+  }
+
+  ComplexEigenSolver<MatrixType> eiNoEivecs(a, false);
+  VERIFY_IS_EQUAL(eiNoEivecs.info(), Success);
+  VERIFY_IS_APPROX(ei1.eigenvalues(), eiNoEivecs.eigenvalues());
+
+  // Regression test for issue #66
+  MatrixType z = MatrixType::Zero(rows, cols);
+  ComplexEigenSolver<MatrixType> eiz(z);
+  VERIFY((eiz.eigenvalues().cwiseEqual(0)).all());
+
+  MatrixType id = MatrixType::Identity(rows, cols);
+  VERIFY_IS_APPROX(id.operatorNorm(), RealScalar(1));
+
+  if (rows > 1 && rows < 20) {
+    // Test matrix with NaN
+    a(0, 0) = std::numeric_limits<typename MatrixType::RealScalar>::quiet_NaN();
+    ComplexEigenSolver<MatrixType> eiNaN(a);
+    VERIFY_IS_EQUAL(eiNaN.info(), NoConvergence);
+  }
+
+  // regression test for bug 1098
+  {
+    ComplexEigenSolver<MatrixType> eig(a.adjoint() * a);
+    eig.compute(a.adjoint() * a);
+  }
+
+  // regression test for bug 478
+  {
+    a.setZero();
+    ComplexEigenSolver<MatrixType> ei3(a);
+    VERIFY_IS_EQUAL(ei3.info(), Success);
+    VERIFY_IS_MUCH_SMALLER_THAN(ei3.eigenvalues().norm(), RealScalar(1));
+    VERIFY((ei3.eigenvectors().transpose() * ei3.eigenvectors().transpose()).eval().isIdentity());
+  }
+}
+
+template <typename MatrixType>
+void eigensolver_verify_assert(const MatrixType& m) {
+  ComplexEigenSolver<MatrixType> eig;
+  VERIFY_RAISES_ASSERT(eig.eigenvectors());
+  VERIFY_RAISES_ASSERT(eig.eigenvalues());
+
+  MatrixType a = MatrixType::Random(m.rows(), m.cols());
+  eig.compute(a, false);
+  VERIFY_RAISES_ASSERT(eig.eigenvectors());
+}
+
+EIGEN_DECLARE_TEST(eigensolver_complex) {
+  int s = 0;
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(eigensolver(Matrix4cf()));
+    s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 4);
+    CALL_SUBTEST_2(eigensolver(MatrixXcd(s, s)));
+    CALL_SUBTEST_3(eigensolver(Matrix<std::complex<float>, 1, 1>()));
+    CALL_SUBTEST_4(eigensolver(Matrix3f()));
+    TEST_SET_BUT_UNUSED_VARIABLE(s)
+  }
+  CALL_SUBTEST_1(eigensolver_verify_assert(Matrix4cf()));
+  s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 4);
+  CALL_SUBTEST_2(eigensolver_verify_assert(MatrixXcd(s, s)));
+  CALL_SUBTEST_3(eigensolver_verify_assert(Matrix<std::complex<float>, 1, 1>()));
+  CALL_SUBTEST_4(eigensolver_verify_assert(Matrix3f()));
+
+  // Test problem size constructors
+  CALL_SUBTEST_5(ComplexEigenSolver<MatrixXf> tmp(s));
+
+  // Test custom complex scalar type.
+  CALL_SUBTEST_6(eigensolver(Matrix<CustomComplex<double>, 5, 5>()));
+
+  TEST_SET_BUT_UNUSED_VARIABLE(s)
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/eigensolver_generalized_real.cpp

@@ -0,0 +1,139 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012-2016 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/.
+
+#define EIGEN_RUNTIME_NO_MALLOC
+#include "main.h"
+#include <limits>
+#include <Eigen/Eigenvalues>
+#include <Eigen/LU>
+
+template <typename MatrixType>
+void generalized_eigensolver_real(const MatrixType& m) {
+  /* this test covers the following files:
+     GeneralizedEigenSolver.h
+  */
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  typedef typename MatrixType::Scalar Scalar;
+  typedef std::complex<Scalar> ComplexScalar;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
+
+  MatrixType a = MatrixType::Random(rows, cols);
+  MatrixType b = MatrixType::Random(rows, cols);
+  MatrixType a1 = MatrixType::Random(rows, cols);
+  MatrixType b1 = MatrixType::Random(rows, cols);
+  MatrixType spdA = a.adjoint() * a + a1.adjoint() * a1;
+  MatrixType spdB = b.adjoint() * b + b1.adjoint() * b1;
+
+  // lets compare to GeneralizedSelfAdjointEigenSolver
+  {
+    GeneralizedSelfAdjointEigenSolver<MatrixType> symmEig(spdA, spdB);
+    GeneralizedEigenSolver<MatrixType> eig(spdA, spdB);
+
+    VERIFY_IS_EQUAL(eig.eigenvalues().imag().cwiseAbs().maxCoeff(), 0);
+
+    VectorType realEigenvalues = eig.eigenvalues().real();
+    std::sort(realEigenvalues.data(), realEigenvalues.data() + realEigenvalues.size());
+    VERIFY_IS_APPROX(realEigenvalues, symmEig.eigenvalues());
+
+    // check eigenvectors
+    typename GeneralizedEigenSolver<MatrixType>::EigenvectorsType D = eig.eigenvalues().asDiagonal();
+    typename GeneralizedEigenSolver<MatrixType>::EigenvectorsType V = eig.eigenvectors();
+    VERIFY_IS_APPROX(spdA * V, spdB * V * D);
+  }
+
+  // non symmetric case:
+  {
+    GeneralizedEigenSolver<MatrixType> eig(rows);
+    // TODO enable full-prealocation of required memory, this probably requires an in-place mode for
+    // HessenbergDecomposition
+    // Eigen::internal::set_is_malloc_allowed(false);
+    eig.compute(a, b);
+    // Eigen::internal::set_is_malloc_allowed(true);
+    for (Index k = 0; k < cols; ++k) {
+      Matrix<ComplexScalar, Dynamic, Dynamic> tmp =
+          (eig.betas()(k) * a).template cast<ComplexScalar>() - eig.alphas()(k) * b;
+      if (tmp.size() > 1 && tmp.norm() > (std::numeric_limits<Scalar>::min)()) tmp /= tmp.norm();
+      VERIFY_IS_MUCH_SMALLER_THAN(std::abs(tmp.determinant()), Scalar(1));
+    }
+    // check eigenvectors
+    typename GeneralizedEigenSolver<MatrixType>::EigenvectorsType D = eig.eigenvalues().asDiagonal();
+    typename GeneralizedEigenSolver<MatrixType>::EigenvectorsType V = eig.eigenvectors();
+    VERIFY_IS_APPROX(a * V, b * V * D);
+  }
+
+  // regression test for bug 1098
+  {
+    GeneralizedSelfAdjointEigenSolver<MatrixType> eig1(a.adjoint() * a, b.adjoint() * b);
+    eig1.compute(a.adjoint() * a, b.adjoint() * b);
+    GeneralizedEigenSolver<MatrixType> eig2(a.adjoint() * a, b.adjoint() * b);
+    eig2.compute(a.adjoint() * a, b.adjoint() * b);
+  }
+
+  // check without eigenvectors
+  {
+    GeneralizedEigenSolver<MatrixType> eig1(spdA, spdB, true);
+    GeneralizedEigenSolver<MatrixType> eig2(spdA, spdB, false);
+    VERIFY_IS_APPROX(eig1.eigenvalues(), eig2.eigenvalues());
+  }
+}
+
+template <typename MatrixType>
+void generalized_eigensolver_assert() {
+  GeneralizedEigenSolver<MatrixType> eig;
+  // all raise assert if uninitialized
+  VERIFY_RAISES_ASSERT(eig.info());
+  VERIFY_RAISES_ASSERT(eig.eigenvectors());
+  VERIFY_RAISES_ASSERT(eig.eigenvalues());
+  VERIFY_RAISES_ASSERT(eig.alphas());
+  VERIFY_RAISES_ASSERT(eig.betas());
+
+  // none raise assert after compute called
+  eig.compute(MatrixType::Random(20, 20), MatrixType::Random(20, 20));
+  VERIFY(eig.info() == Success);
+  eig.eigenvectors();
+  eig.eigenvalues();
+  eig.alphas();
+  eig.betas();
+
+  // eigenvectors() raises assert, if eigenvectors were not requested
+  eig.compute(MatrixType::Random(20, 20), MatrixType::Random(20, 20), false);
+  VERIFY(eig.info() == Success);
+  VERIFY_RAISES_ASSERT(eig.eigenvectors());
+  eig.eigenvalues();
+  eig.alphas();
+  eig.betas();
+
+  // all except info raise assert if realQZ did not converge
+  eig.setMaxIterations(0);  // force real QZ to fail.
+  eig.compute(MatrixType::Random(20, 20), MatrixType::Random(20, 20));
+  VERIFY(eig.info() == NoConvergence);
+  VERIFY_RAISES_ASSERT(eig.eigenvectors());
+  VERIFY_RAISES_ASSERT(eig.eigenvalues());
+  VERIFY_RAISES_ASSERT(eig.alphas());
+  VERIFY_RAISES_ASSERT(eig.betas());
+}
+
+EIGEN_DECLARE_TEST(eigensolver_generalized_real) {
+  for (int i = 0; i < g_repeat; i++) {
+    int s = 0;
+    CALL_SUBTEST_1(generalized_eigensolver_real(Matrix4f()));
+    s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 4);
+    CALL_SUBTEST_2(generalized_eigensolver_real(MatrixXd(s, s)));
+
+    // some trivial but implementation-wise special cases
+    CALL_SUBTEST_2(generalized_eigensolver_real(MatrixXd(1, 1)));
+    CALL_SUBTEST_2(generalized_eigensolver_real(MatrixXd(2, 2)));
+    CALL_SUBTEST_3(generalized_eigensolver_real(Matrix<double, 1, 1>()));
+    CALL_SUBTEST_4(generalized_eigensolver_real(Matrix2d()));
+    CALL_SUBTEST_5(generalized_eigensolver_assert<MatrixXd>());
+    TEST_SET_BUT_UNUSED_VARIABLE(s)
+  }
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/eigensolver_generic.cpp

@@ -0,0 +1,233 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010,2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// 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 <limits>
+#include <Eigen/Eigenvalues>
+
+template <typename EigType, typename MatType>
+void check_eigensolver_for_given_mat(const EigType& eig, const MatType& a) {
+  typedef typename NumTraits<typename MatType::Scalar>::Real RealScalar;
+  typedef Matrix<RealScalar, MatType::RowsAtCompileTime, 1> RealVectorType;
+  typedef typename std::complex<RealScalar> Complex;
+  Index n = a.rows();
+  VERIFY_IS_EQUAL(eig.info(), Success);
+  VERIFY_IS_APPROX(a * eig.pseudoEigenvectors(), eig.pseudoEigenvectors() * eig.pseudoEigenvalueMatrix());
+  VERIFY_IS_APPROX(a.template cast<Complex>() * eig.eigenvectors(),
+                   eig.eigenvectors() * eig.eigenvalues().asDiagonal());
+  VERIFY_IS_APPROX(eig.eigenvectors().colwise().norm(), RealVectorType::Ones(n).transpose());
+  VERIFY_IS_APPROX(a.eigenvalues(), eig.eigenvalues());
+}
+
+template <typename MatrixType>
+void eigensolver(const MatrixType& m) {
+  /* this test covers the following files:
+     EigenSolver.h
+  */
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef typename std::complex<RealScalar> Complex;
+
+  MatrixType a = MatrixType::Random(rows, cols);
+  MatrixType a1 = MatrixType::Random(rows, cols);
+  MatrixType symmA = a.adjoint() * a + a1.adjoint() * a1;
+
+  EigenSolver<MatrixType> ei0(symmA);
+  VERIFY_IS_EQUAL(ei0.info(), Success);
+  VERIFY_IS_APPROX(symmA * ei0.pseudoEigenvectors(), ei0.pseudoEigenvectors() * ei0.pseudoEigenvalueMatrix());
+  VERIFY_IS_APPROX((symmA.template cast<Complex>()) * (ei0.pseudoEigenvectors().template cast<Complex>()),
+                   (ei0.pseudoEigenvectors().template cast<Complex>()) * (ei0.eigenvalues().asDiagonal()));
+
+  EigenSolver<MatrixType> ei1(a);
+  CALL_SUBTEST(check_eigensolver_for_given_mat(ei1, a));
+
+  EigenSolver<MatrixType> ei2;
+  ei2.setMaxIterations(RealSchur<MatrixType>::m_maxIterationsPerRow * rows).compute(a);
+  VERIFY_IS_EQUAL(ei2.info(), Success);
+  VERIFY_IS_EQUAL(ei2.eigenvectors(), ei1.eigenvectors());
+  VERIFY_IS_EQUAL(ei2.eigenvalues(), ei1.eigenvalues());
+  if (rows > 2) {
+    ei2.setMaxIterations(1).compute(a);
+    VERIFY_IS_EQUAL(ei2.info(), NoConvergence);
+    VERIFY_IS_EQUAL(ei2.getMaxIterations(), 1);
+  }
+
+  EigenSolver<MatrixType> eiNoEivecs(a, false);
+  VERIFY_IS_EQUAL(eiNoEivecs.info(), Success);
+  VERIFY_IS_APPROX(ei1.eigenvalues(), eiNoEivecs.eigenvalues());
+  VERIFY_IS_APPROX(ei1.pseudoEigenvalueMatrix(), eiNoEivecs.pseudoEigenvalueMatrix());
+
+  MatrixType id = MatrixType::Identity(rows, cols);
+  VERIFY_IS_APPROX(id.operatorNorm(), RealScalar(1));
+
+  if (rows > 2 && rows < 20) {
+    // Test matrix with NaN
+    a(0, 0) = std::numeric_limits<typename MatrixType::RealScalar>::quiet_NaN();
+    EigenSolver<MatrixType> eiNaN(a);
+    VERIFY_IS_NOT_EQUAL(eiNaN.info(), Success);
+  }
+
+  // regression test for bug 1098
+  {
+    EigenSolver<MatrixType> eig(a.adjoint() * a);
+    eig.compute(a.adjoint() * a);
+  }
+
+  // regression test for bug 478
+  {
+    a.setZero();
+    EigenSolver<MatrixType> ei3(a);
+    VERIFY_IS_EQUAL(ei3.info(), Success);
+    VERIFY_IS_MUCH_SMALLER_THAN(ei3.eigenvalues().norm(), RealScalar(1));
+    VERIFY((ei3.eigenvectors().transpose() * ei3.eigenvectors().transpose()).eval().isIdentity());
+  }
+}
+
+template <typename MatrixType>
+void eigensolver_verify_assert(const MatrixType& m) {
+  EigenSolver<MatrixType> eig;
+  VERIFY_RAISES_ASSERT(eig.eigenvectors());
+  VERIFY_RAISES_ASSERT(eig.pseudoEigenvectors());
+  VERIFY_RAISES_ASSERT(eig.pseudoEigenvalueMatrix());
+  VERIFY_RAISES_ASSERT(eig.eigenvalues());
+
+  MatrixType a = MatrixType::Random(m.rows(), m.cols());
+  eig.compute(a, false);
+  VERIFY_RAISES_ASSERT(eig.eigenvectors());
+  VERIFY_RAISES_ASSERT(eig.pseudoEigenvectors());
+}
+
+template <typename CoeffType>
+Matrix<typename CoeffType::Scalar, Dynamic, Dynamic> make_companion(const CoeffType& coeffs) {
+  Index n = coeffs.size() - 1;
+  Matrix<typename CoeffType::Scalar, Dynamic, Dynamic> res(n, n);
+  res.setZero();
+  res.row(0) = -coeffs.tail(n) / coeffs(0);
+  res.diagonal(-1).setOnes();
+  return res;
+}
+
+template <int>
+void eigensolver_generic_extra() {
+  {
+    // regression test for bug 793
+    MatrixXd a(3, 3);
+    a << 0, 0, 1, 1, 1, 1, 1, 1e+200, 1;
+    Eigen::EigenSolver<MatrixXd> eig(a);
+    double scale = 1e-200;  // scale to avoid overflow during the comparisons
+    VERIFY_IS_APPROX(a * eig.pseudoEigenvectors() * scale,
+                     eig.pseudoEigenvectors() * eig.pseudoEigenvalueMatrix() * scale);
+    VERIFY_IS_APPROX(a * eig.eigenvectors() * scale, eig.eigenvectors() * eig.eigenvalues().asDiagonal() * scale);
+  }
+  {
+    // check a case where all eigenvalues are null.
+    MatrixXd a(2, 2);
+    a << 1, 1, -1, -1;
+    Eigen::EigenSolver<MatrixXd> eig(a);
+    VERIFY_IS_APPROX(eig.pseudoEigenvectors().squaredNorm(), 2.);
+    VERIFY_IS_APPROX((a * eig.pseudoEigenvectors()).norm() + 1., 1.);
+    VERIFY_IS_APPROX((eig.pseudoEigenvectors() * eig.pseudoEigenvalueMatrix()).norm() + 1., 1.);
+    VERIFY_IS_APPROX((a * eig.eigenvectors()).norm() + 1., 1.);
+    VERIFY_IS_APPROX((eig.eigenvectors() * eig.eigenvalues().asDiagonal()).norm() + 1., 1.);
+  }
+
+  // regression test for bug 933
+  {
+    {
+      VectorXd coeffs(5);
+      coeffs << 1, -3, -175, -225, 2250;
+      MatrixXd C = make_companion(coeffs);
+      EigenSolver<MatrixXd> eig(C);
+      CALL_SUBTEST(check_eigensolver_for_given_mat(eig, C));
+    }
+    {
+      // this test is tricky because it requires high accuracy in smallest eigenvalues
+      VectorXd coeffs(5);
+      coeffs << 6.154671e-15, -1.003870e-10, -9.819570e-01, 3.995715e+03, 2.211511e+08;
+      MatrixXd C = make_companion(coeffs);
+      EigenSolver<MatrixXd> eig(C);
+      CALL_SUBTEST(check_eigensolver_for_given_mat(eig, C));
+      Index n = C.rows();
+      for (Index i = 0; i < n; ++i) {
+        typedef std::complex<double> Complex;
+        MatrixXcd ac = C.cast<Complex>();
+        ac.diagonal().array() -= eig.eigenvalues()(i);
+        VectorXd sv = ac.jacobiSvd().singularValues();
+        // comparing to sv(0) is not enough here to catch the "bug",
+        // the hard-coded 1.0 is important!
+        VERIFY_IS_MUCH_SMALLER_THAN(sv(n - 1), 1.0);
+      }
+    }
+  }
+  // regression test for bug 1557
+  {
+    // this test is interesting because it contains zeros on the diagonal.
+    MatrixXd A_bug1557(3, 3);
+    A_bug1557 << 0, 0, 0, 1, 0, 0.5887907064808635127, 0, 1, 0;
+    EigenSolver<MatrixXd> eig(A_bug1557);
+    CALL_SUBTEST(check_eigensolver_for_given_mat(eig, A_bug1557));
+  }
+
+  // regression test for bug 1174
+  {
+    Index n = 12;
+    MatrixXf A_bug1174(n, n);
+    A_bug1174 << 262144, 0, 0, 262144, 786432, 0, 0, 0, 0, 0, 0, 786432, 262144, 0, 0, 262144, 786432, 0, 0, 0, 0, 0, 0,
+        786432, 262144, 0, 0, 262144, 786432, 0, 0, 0, 0, 0, 0, 786432, 262144, 0, 0, 262144, 786432, 0, 0, 0, 0, 0, 0,
+        786432, 0, 262144, 262144, 0, 0, 262144, 262144, 262144, 262144, 262144, 262144, 0, 0, 262144, 262144, 0, 0,
+        262144, 262144, 262144, 262144, 262144, 262144, 0, 0, 262144, 262144, 0, 0, 262144, 262144, 262144, 262144,
+        262144, 262144, 0, 0, 262144, 262144, 0, 0, 262144, 262144, 262144, 262144, 262144, 262144, 0, 0, 262144,
+        262144, 0, 0, 262144, 262144, 262144, 262144, 262144, 262144, 0, 0, 262144, 262144, 0, 0, 262144, 262144,
+        262144, 262144, 262144, 262144, 0, 0, 262144, 262144, 0, 0, 262144, 262144, 262144, 262144, 262144, 262144, 0,
+        0, 262144, 262144, 0, 0, 262144, 262144, 262144, 262144, 262144, 262144, 0;
+    EigenSolver<MatrixXf> eig(A_bug1174);
+    CALL_SUBTEST(check_eigensolver_for_given_mat(eig, A_bug1174));
+  }
+}
+
+EIGEN_DECLARE_TEST(eigensolver_generic) {
+  int s = 0;
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(eigensolver(Matrix4f()));
+    s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 4);
+    CALL_SUBTEST_2(eigensolver(MatrixXd(s, s)));
+    TEST_SET_BUT_UNUSED_VARIABLE(s)
+
+    // some trivial but implementation-wise tricky cases
+    CALL_SUBTEST_2(eigensolver(MatrixXd(1, 1)));
+    CALL_SUBTEST_2(eigensolver(MatrixXd(2, 2)));
+    CALL_SUBTEST_3(eigensolver(Matrix<double, 1, 1>()));
+    CALL_SUBTEST_4(eigensolver(Matrix2d()));
+  }
+
+  CALL_SUBTEST_1(eigensolver_verify_assert(Matrix4f()));
+  s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 4);
+  CALL_SUBTEST_2(eigensolver_verify_assert(MatrixXd(s, s)));
+  CALL_SUBTEST_3(eigensolver_verify_assert(Matrix<double, 1, 1>()));
+  CALL_SUBTEST_4(eigensolver_verify_assert(Matrix2d()));
+
+  // Test problem size constructors
+  CALL_SUBTEST_5(EigenSolver<MatrixXf> tmp(s));
+
+  // regression test for bug 410
+  CALL_SUBTEST_2({
+    MatrixXd A(1, 1);
+    A(0, 0) = std::sqrt(-1.);  // is Not-a-Number
+    Eigen::EigenSolver<MatrixXd> solver(A);
+    VERIFY_IS_EQUAL(solver.info(), NumericalIssue);
+  });
+
+  CALL_SUBTEST_2(eigensolver_generic_extra<0>());
+
+  TEST_SET_BUT_UNUSED_VARIABLE(s)
+}

wheels/TRELLIS.2/o-voxels/third_party/eigen/test/eigensolver_selfadjoint.cpp

@@ -0,0 +1,281 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// 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 "svd_fill.h"
+#include <limits>
+#include <Eigen/Eigenvalues>
+#include <Eigen/SparseCore>
+#include <unsupported/Eigen/MatrixFunctions>
+
+template <typename MatrixType>
+void selfadjointeigensolver_essential_check(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  RealScalar eival_eps =
+      numext::mini<RealScalar>(test_precision<RealScalar>(), NumTraits<Scalar>::dummy_precision() * 20000);
+
+  SelfAdjointEigenSolver<MatrixType> eiSymm(m);
+  VERIFY_IS_EQUAL(eiSymm.info(), Success);
+
+  RealScalar scaling = m.cwiseAbs().maxCoeff();
+  RealScalar unitary_error_factor = RealScalar(16);
+
+  if (scaling < (std::numeric_limits<RealScalar>::min)()) {
+    VERIFY(eiSymm.eigenvalues().cwiseAbs().maxCoeff() <= (std::numeric_limits<RealScalar>::min)());
+  } else {
+    VERIFY_IS_APPROX((m.template selfadjointView<Lower>() * eiSymm.eigenvectors()) / scaling,
+                     (eiSymm.eigenvectors() * eiSymm.eigenvalues().asDiagonal()) / scaling);
+  }
+  VERIFY_IS_APPROX(m.template selfadjointView<Lower>().eigenvalues(), eiSymm.eigenvalues());
+  VERIFY(eiSymm.eigenvectors().isUnitary(test_precision<RealScalar>() * unitary_error_factor));
+
+  if (m.cols() <= 4) {
+    SelfAdjointEigenSolver<MatrixType> eiDirect;
+    eiDirect.computeDirect(m);
+    VERIFY_IS_EQUAL(eiDirect.info(), Success);
+    if (!eiSymm.eigenvalues().isApprox(eiDirect.eigenvalues(), eival_eps)) {
+      std::cerr << "reference eigenvalues: " << eiSymm.eigenvalues().transpose() << "\n"
+                << "obtained eigenvalues:  " << eiDirect.eigenvalues().transpose() << "\n"
+                << "diff:                  " << (eiSymm.eigenvalues() - eiDirect.eigenvalues()).transpose() << "\n"
+                << "error (eps):           "
+                << (eiSymm.eigenvalues() - eiDirect.eigenvalues()).norm() / eiSymm.eigenvalues().norm() << "  ("
+                << eival_eps << ")\n";
+    }
+    if (scaling < (std::numeric_limits<RealScalar>::min)()) {
+      VERIFY(eiDirect.eigenvalues().cwiseAbs().maxCoeff() <= (std::numeric_limits<RealScalar>::min)());
+    } else {
+      VERIFY_IS_APPROX(eiSymm.eigenvalues() / scaling, eiDirect.eigenvalues() / scaling);
+      VERIFY_IS_APPROX((m.template selfadjointView<Lower>() * eiDirect.eigenvectors()) / scaling,
+                       (eiDirect.eigenvectors() * eiDirect.eigenvalues().asDiagonal()) / scaling);
+      VERIFY_IS_APPROX(m.template selfadjointView<Lower>().eigenvalues() / scaling, eiDirect.eigenvalues() / scaling);
+    }
+
+    VERIFY(eiDirect.eigenvectors().isUnitary(test_precision<RealScalar>() * unitary_error_factor));
+  }
+}
+
+template <typename MatrixType>
+void selfadjointeigensolver(const MatrixType& m) {
+  /* this test covers the following files:
+     EigenSolver.h, SelfAdjointEigenSolver.h (and indirectly: Tridiagonalization.h)
+  */
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  RealScalar largerEps = 10 * test_precision<RealScalar>();
+
+  MatrixType a = MatrixType::Random(rows, cols);
+  MatrixType a1 = MatrixType::Random(rows, cols);
+  MatrixType symmA = a.adjoint() * a + a1.adjoint() * a1;
+  MatrixType symmC = symmA;
+
+  svd_fill_random(symmA, Symmetric);
+
+  symmA.template triangularView<StrictlyUpper>().setZero();
+  symmC.template triangularView<StrictlyUpper>().setZero();
+
+  MatrixType b = MatrixType::Random(rows, cols);
+  MatrixType b1 = MatrixType::Random(rows, cols);
+  MatrixType symmB = b.adjoint() * b + b1.adjoint() * b1;
+  symmB.template triangularView<StrictlyUpper>().setZero();
+
+  CALL_SUBTEST(selfadjointeigensolver_essential_check(symmA));
+
+  SelfAdjointEigenSolver<MatrixType> eiSymm(symmA);
+  // generalized eigen pb
+  GeneralizedSelfAdjointEigenSolver<MatrixType> eiSymmGen(symmC, symmB);
+
+  SelfAdjointEigenSolver<MatrixType> eiSymmNoEivecs(symmA, false);
+  VERIFY_IS_EQUAL(eiSymmNoEivecs.info(), Success);
+  VERIFY_IS_APPROX(eiSymm.eigenvalues(), eiSymmNoEivecs.eigenvalues());
+
+  // generalized eigen problem Ax = lBx
+  eiSymmGen.compute(symmC, symmB, Ax_lBx);
+  VERIFY_IS_EQUAL(eiSymmGen.info(), Success);
+  VERIFY((symmC.template selfadjointView<Lower>() * eiSymmGen.eigenvectors())
+             .isApprox(symmB.template selfadjointView<Lower>() *
+                           (eiSymmGen.eigenvectors() * eiSymmGen.eigenvalues().asDiagonal()),
+                       largerEps));
+
+  // generalized eigen problem BAx = lx
+  eiSymmGen.compute(symmC, symmB, BAx_lx);
+  VERIFY_IS_EQUAL(eiSymmGen.info(), Success);
+  VERIFY(
+      (symmB.template selfadjointView<Lower>() * (symmC.template selfadjointView<Lower>() * eiSymmGen.eigenvectors()))
+          .isApprox((eiSymmGen.eigenvectors() * eiSymmGen.eigenvalues().asDiagonal()), largerEps));
+
+  // generalized eigen problem ABx = lx
+  eiSymmGen.compute(symmC, symmB, ABx_lx);
+  VERIFY_IS_EQUAL(eiSymmGen.info(), Success);
+  VERIFY(
+      (symmC.template selfadjointView<Lower>() * (symmB.template selfadjointView<Lower>() * eiSymmGen.eigenvectors()))
+          .isApprox((eiSymmGen.eigenvectors() * eiSymmGen.eigenvalues().asDiagonal()), largerEps));
+
+  eiSymm.compute(symmC);
+  MatrixType sqrtSymmA = eiSymm.operatorSqrt();
+  VERIFY_IS_APPROX(MatrixType(symmC.template selfadjointView<Lower>()), sqrtSymmA * sqrtSymmA);
+  VERIFY_IS_APPROX(sqrtSymmA, symmC.template selfadjointView<Lower>() * eiSymm.operatorInverseSqrt());
+
+  MatrixType id = MatrixType::Identity(rows, cols);
+  VERIFY_IS_APPROX(id.template selfadjointView<Lower>().operatorNorm(), RealScalar(1));
+
+  SelfAdjointEigenSolver<MatrixType> eiSymmUninitialized;
+  VERIFY_RAISES_ASSERT(eiSymmUninitialized.info());
+  VERIFY_RAISES_ASSERT(eiSymmUninitialized.eigenvalues());
+  VERIFY_RAISES_ASSERT(eiSymmUninitialized.eigenvectors());
+  VERIFY_RAISES_ASSERT(eiSymmUninitialized.operatorSqrt());
+  VERIFY_RAISES_ASSERT(eiSymmUninitialized.operatorInverseSqrt());
+  VERIFY_RAISES_ASSERT(eiSymmUninitialized.operatorExp());
+
+  eiSymmUninitialized.compute(symmA, false);
+  VERIFY_RAISES_ASSERT(eiSymmUninitialized.eigenvectors());
+  VERIFY_RAISES_ASSERT(eiSymmUninitialized.operatorSqrt());
+  VERIFY_RAISES_ASSERT(eiSymmUninitialized.operatorInverseSqrt());
+  VERIFY_RAISES_ASSERT(eiSymmUninitialized.operatorExp());
+
+  // test Tridiagonalization's methods
+  Tridiagonalization<MatrixType> tridiag(symmC);
+  VERIFY_IS_APPROX(tridiag.diagonal(), tridiag.matrixT().diagonal());
+  VERIFY_IS_APPROX(tridiag.subDiagonal(), tridiag.matrixT().template diagonal<-1>());
+  Matrix<RealScalar, Dynamic, Dynamic> T = tridiag.matrixT();
+  if (rows > 1 && cols > 1) {
+    // FIXME check that upper and lower part are 0:
+    // VERIFY(T.topRightCorner(rows-2, cols-2).template triangularView<Upper>().isZero());
+  }
+  VERIFY_IS_APPROX(tridiag.diagonal(), T.diagonal());
+  VERIFY_IS_APPROX(tridiag.subDiagonal(), T.template diagonal<1>());
+  VERIFY_IS_APPROX(MatrixType(symmC.template selfadjointView<Lower>()),
+                   tridiag.matrixQ() * tridiag.matrixT().eval() * MatrixType(tridiag.matrixQ()).adjoint());
+  VERIFY_IS_APPROX(MatrixType(symmC.template selfadjointView<Lower>()),
+                   tridiag.matrixQ() * tridiag.matrixT() * tridiag.matrixQ().adjoint());
+
+  // Test computation of eigenvalues from tridiagonal matrix
+  if (rows > 1) {
+    SelfAdjointEigenSolver<MatrixType> eiSymmTridiag;
+    eiSymmTridiag.computeFromTridiagonal(tridiag.matrixT().diagonal(), tridiag.matrixT().diagonal(-1),
+                                         ComputeEigenvectors);
+    VERIFY_IS_APPROX(eiSymm.eigenvalues(), eiSymmTridiag.eigenvalues());
+    VERIFY_IS_APPROX(tridiag.matrixT(), eiSymmTridiag.eigenvectors().real() * eiSymmTridiag.eigenvalues().asDiagonal() *
+                                            eiSymmTridiag.eigenvectors().real().transpose());
+  }
+
+  // Test matrix expponential from eigendecomposition.
+  // First scale to avoid overflow.
+  symmB = symmB / symmB.norm();
+  eiSymm.compute(symmB);
+  MatrixType expSymmB = eiSymm.operatorExp();
+  symmB = symmB.template selfadjointView<Lower>();
+  VERIFY_IS_APPROX(expSymmB, symmB.exp());
+
+  if (rows > 1 && rows < 20) {
+    // Test matrix with NaN
+    symmC(0, 0) = std::numeric_limits<typename MatrixType::RealScalar>::quiet_NaN();
+    SelfAdjointEigenSolver<MatrixType> eiSymmNaN(symmC);
+    VERIFY_IS_EQUAL(eiSymmNaN.info(), NoConvergence);
+  }
+
+  // regression test for bug 1098
+  {
+    SelfAdjointEigenSolver<MatrixType> eig(a.adjoint() * a);
+    eig.compute(a.adjoint() * a);
+  }
+
+  // regression test for bug 478
+  {
+    a.setZero();
+    SelfAdjointEigenSolver<MatrixType> ei3(a);
+    VERIFY_IS_EQUAL(ei3.info(), Success);
+    VERIFY_IS_MUCH_SMALLER_THAN(ei3.eigenvalues().norm(), RealScalar(1));
+    VERIFY((ei3.eigenvectors().transpose() * ei3.eigenvectors().transpose()).eval().isIdentity());
+  }
+}
+
+template <int>
+void bug_854() {
+  Matrix3d m;
+  m << 850.961, 51.966, 0, 51.966, 254.841, 0, 0, 0, 0;
+  selfadjointeigensolver_essential_check(m);
+}
+
+template <int>
+void bug_1014() {
+  Matrix3d m;
+  m << 0.11111111111111114658, 0, 0, 0, 0.11111111111111109107, 0, 0, 0, 0.11111111111111107719;
+  selfadjointeigensolver_essential_check(m);
+}
+
+template <int>
+void bug_1225() {
+  Matrix3d m1, m2;
+  m1.setRandom();
+  m1 = m1 * m1.transpose();
+  m2 = m1.triangularView<Upper>();
+  SelfAdjointEigenSolver<Matrix3d> eig1(m1);
+  SelfAdjointEigenSolver<Matrix3d> eig2(m2.selfadjointView<Upper>());
+  VERIFY_IS_APPROX(eig1.eigenvalues(), eig2.eigenvalues());
+}
+
+template <int>
+void bug_1204() {
+  SparseMatrix<double> A(2, 2);
+  A.setIdentity();
+  SelfAdjointEigenSolver<Eigen::SparseMatrix<double> > eig(A);
+}
+
+EIGEN_DECLARE_TEST(eigensolver_selfadjoint) {
+  int s = 0;
+  for (int i = 0; i < g_repeat; i++) {
+    // trivial test for 1x1 matrices:
+    CALL_SUBTEST_1(selfadjointeigensolver(Matrix<float, 1, 1>()));
+    CALL_SUBTEST_1(selfadjointeigensolver(Matrix<double, 1, 1>()));
+    CALL_SUBTEST_1(selfadjointeigensolver(Matrix<std::complex<double>, 1, 1>()));
+
+    // very important to test 3x3 and 2x2 matrices since we provide special paths for them
+    CALL_SUBTEST_12(selfadjointeigensolver(Matrix2f()));
+    CALL_SUBTEST_12(selfadjointeigensolver(Matrix2d()));
+    CALL_SUBTEST_12(selfadjointeigensolver(Matrix2cd()));
+    CALL_SUBTEST_13(selfadjointeigensolver(Matrix3f()));
+    CALL_SUBTEST_13(selfadjointeigensolver(Matrix3d()));
+    CALL_SUBTEST_13(selfadjointeigensolver(Matrix3cd()));
+    CALL_SUBTEST_2(selfadjointeigensolver(Matrix4d()));
+    CALL_SUBTEST_2(selfadjointeigensolver(Matrix4cd()));
+
+    s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 4);
+    CALL_SUBTEST_3(selfadjointeigensolver(MatrixXf(s, s)));
+    CALL_SUBTEST_4(selfadjointeigensolver(MatrixXd(s, s)));
+    CALL_SUBTEST_5(selfadjointeigensolver(MatrixXcd(s, s)));
+    CALL_SUBTEST_9(selfadjointeigensolver(Matrix<std::complex<double>, Dynamic, Dynamic, RowMajor>(s, s)));
+    TEST_SET_BUT_UNUSED_VARIABLE(s)
+
+    // some trivial but implementation-wise tricky cases
+    CALL_SUBTEST_4(selfadjointeigensolver(MatrixXd(1, 1)));
+    CALL_SUBTEST_4(selfadjointeigensolver(MatrixXd(2, 2)));
+    CALL_SUBTEST_5(selfadjointeigensolver(MatrixXcd(1, 1)));
+    CALL_SUBTEST_5(selfadjointeigensolver(MatrixXcd(2, 2)));
+    CALL_SUBTEST_6(selfadjointeigensolver(Matrix<double, 1, 1>()));
+    CALL_SUBTEST_7(selfadjointeigensolver(Matrix<double, 2, 2>()));
+  }
+
+  CALL_SUBTEST_13(bug_854<0>());
+  CALL_SUBTEST_13(bug_1014<0>());
+  CALL_SUBTEST_13(bug_1204<0>());
+  CALL_SUBTEST_13(bug_1225<0>());
+
+  // Test problem size constructors
+  s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 4);
+  CALL_SUBTEST_8(SelfAdjointEigenSolver<MatrixXf> tmp1(s));
+  CALL_SUBTEST_8(Tridiagonalization<MatrixXf> tmp2(s));
+
+  TEST_SET_BUT_UNUSED_VARIABLE(s)
+}