devtools/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2026-04-10 11:34:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add support for Apple's Accelerate sparse matrix solvers

Browse Source
This commit is contained in:
John Mather
2022-03-08 00:09:18 +00:00
committed by Rasmus Munk Larsen
parent 008ff3483a
commit 3a9d404d76
8 changed files with 702 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
test/CMakeLists.txt
View File

@@ -134,6 +134,17 @@ 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)
@@ -344,6 +355,10 @@ 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")

176
test/accelerate_support.cpp Normal file
View File

@@ -0,0 +1,176 @@
#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 | Symmetric> >();
test_accelerate_ldlt<Scalar, AccelerateLDLTUnpivoted<MatrixType, Lower | Symmetric> >();
test_accelerate_ldlt<Scalar, AccelerateLDLTSBK<MatrixType, Lower | Symmetric> >();
test_accelerate_ldlt<Scalar, AccelerateLDLTTPP<MatrixType, Lower | Symmetric> >();
test_accelerate_ldlt<Scalar, AccelerateLDLT<MatrixType, Upper | Symmetric> >();
test_accelerate_ldlt<Scalar, AccelerateLDLTUnpivoted<MatrixType, Upper | Symmetric> >();
test_accelerate_ldlt<Scalar, AccelerateLDLTSBK<MatrixType, Upper | Symmetric> >();
test_accelerate_ldlt<Scalar, AccelerateLDLTTPP<MatrixType, Upper | Symmetric> >();
test_accelerate_llt<Scalar, AccelerateLLT<MatrixType, Lower | Symmetric> >();
test_accelerate_llt<Scalar, AccelerateLLT<MatrixType, Upper | Symmetric> >();
test_accelerate_qr<Scalar, AccelerateQR<MatrixType, 0> >();
}
EIGEN_DECLARE_TEST(accelerate_support)
{
CALL_SUBTEST_1(run_tests<float>());
CALL_SUBTEST_2(run_tests<double>());
}