109 lines
4.2 KiB
C++
109 lines
4.2 KiB
C++
// This file is part of Eigen, a lightweight C++ template library
|
|
// for linear algebra.
|
|
//
|
|
// SPDX-FileCopyrightText: The Eigen Authors
|
|
// SPDX-License-Identifier: MPL-2.0
|
|
|
|
#include "main.h"
|
|
|
|
#include <Eigen/Geometry>
|
|
#include <Eigen/IterativeLinearSolvers>
|
|
#include <Eigen/SVD>
|
|
#include <Eigen/SparseCholesky>
|
|
|
|
static_assert(std::is_trivially_destructible<AlignedBox<double, 3>>::value,
|
|
"AlignedBox should have a trivial destructor");
|
|
static_assert(std::is_trivially_destructible<Hyperplane<double, 3>>::value,
|
|
"Hyperplane should have a trivial destructor");
|
|
static_assert(std::is_trivially_destructible<ParametrizedLine<double, 3>>::value,
|
|
"ParametrizedLine should have a trivial destructor");
|
|
|
|
static_assert(std::is_move_constructible<SimplicialLLT<SparseMatrix<double>>>::value,
|
|
"SimplicialLLT should be move constructible");
|
|
static_assert(std::is_move_constructible<ConjugateGradient<SparseMatrix<double>, Lower | Upper>>::value,
|
|
"ConjugateGradient should be move constructible");
|
|
static_assert(std::is_move_constructible<BiCGSTAB<SparseMatrix<double>>>::value,
|
|
"BiCGSTAB should be move constructible");
|
|
|
|
using StorageVal = internal::StorageVal<double, int>;
|
|
static_assert(std::is_copy_constructible<StorageVal>::value, "StorageVal should remain copy constructible");
|
|
static_assert(std::is_move_constructible<StorageVal>::value, "StorageVal should remain move constructible");
|
|
static_assert(!std::is_copy_assignable<StorageVal>::value, "StorageVal should not become copy assignable");
|
|
static_assert(!std::is_move_assignable<StorageVal>::value, "StorageVal should not become move assignable");
|
|
|
|
SparseMatrix<double> make_spd_matrix() {
|
|
SparseMatrix<double> matrix(3, 3);
|
|
std::vector<Triplet<double>> triplets;
|
|
triplets.push_back(Triplet<double>(0, 0, 4.0));
|
|
triplets.push_back(Triplet<double>(0, 1, -1.0));
|
|
triplets.push_back(Triplet<double>(1, 0, -1.0));
|
|
triplets.push_back(Triplet<double>(1, 1, 4.0));
|
|
triplets.push_back(Triplet<double>(1, 2, -1.0));
|
|
triplets.push_back(Triplet<double>(2, 1, -1.0));
|
|
triplets.push_back(Triplet<double>(2, 2, 3.0));
|
|
matrix.setFromTriplets(triplets.begin(), triplets.end());
|
|
matrix.makeCompressed();
|
|
return matrix;
|
|
}
|
|
|
|
template <typename Solver, typename MatrixType>
|
|
Solver move_computed_solver(const MatrixType& matrix) {
|
|
Solver source;
|
|
source.compute(matrix);
|
|
VERIFY_IS_EQUAL(source.info(), Success);
|
|
Solver moved(std::move(source));
|
|
return moved;
|
|
}
|
|
|
|
void test_move_initialized_bdcsvd() {
|
|
MatrixXd matrix(3, 3);
|
|
matrix << 4.0, 1.0, 0.0, 1.0, 3.0, 1.0, 0.0, 1.0, 2.0;
|
|
VectorXd expected(3);
|
|
expected << 1.0, -2.0, 3.0;
|
|
const VectorXd rhs = matrix * expected;
|
|
|
|
typedef BDCSVD<MatrixXd, ComputeThinU | ComputeThinV> Solver;
|
|
Solver solver = move_computed_solver<Solver>(matrix);
|
|
const VectorXd actual = solver.solve(rhs);
|
|
|
|
VERIFY_IS_EQUAL(solver.info(), Success);
|
|
VERIFY_IS_APPROX(actual, expected);
|
|
}
|
|
|
|
void test_move_initialized_simplicial_llt() {
|
|
const SparseMatrix<double> matrix = make_spd_matrix();
|
|
VectorXd expected(3);
|
|
expected << 1.0, -2.0, 3.0;
|
|
const VectorXd rhs = matrix * expected;
|
|
|
|
typedef SimplicialLLT<SparseMatrix<double>> Solver;
|
|
Solver solver = move_computed_solver<Solver>(matrix);
|
|
const VectorXd actual = solver.solve(rhs);
|
|
|
|
VERIFY_IS_EQUAL(solver.info(), Success);
|
|
VERIFY_IS_APPROX(actual, expected);
|
|
}
|
|
|
|
template <typename Solver>
|
|
void test_move_initialized_iterative_solver() {
|
|
const SparseMatrix<double> matrix = make_spd_matrix();
|
|
VectorXd expected(3);
|
|
expected << 1.0, -2.0, 3.0;
|
|
const VectorXd rhs = matrix * expected;
|
|
|
|
Solver solver = move_computed_solver<Solver>(matrix);
|
|
solver.setMaxIterations(100);
|
|
solver.setTolerance(NumTraits<double>::epsilon() * 100);
|
|
const VectorXd actual = solver.solve(rhs);
|
|
|
|
VERIFY_IS_EQUAL(solver.info(), Success);
|
|
VERIFY_IS_APPROX(actual, expected);
|
|
}
|
|
|
|
EIGEN_DECLARE_TEST(special_members) {
|
|
CALL_SUBTEST_1(test_move_initialized_bdcsvd());
|
|
CALL_SUBTEST_2(test_move_initialized_simplicial_llt());
|
|
CALL_SUBTEST_3((test_move_initialized_iterative_solver<ConjugateGradient<SparseMatrix<double>, Lower | Upper>>()));
|
|
CALL_SUBTEST_4((test_move_initialized_iterative_solver<BiCGSTAB<SparseMatrix<double>>>()));
|
|
}
|