Skip to content

テンプレート修正、コンストラクタテスト追加 #32

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
claude-a merged 4 commits into from
Feb 9, 2025
Merged

テンプレート修正、コンストラクタテスト追加 #32

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
ef17780
修正
claude-a Feb 9, 2025
e0d9a46
コンストラクタテストを追加
claude-a Feb 9, 2025
9ee5efd
テスト
claude-a Feb 9, 2025
9913f2e
テスト完了
claude-a Feb 9, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 2 additions & 2 deletions base_matrix/base_matrix_eigen_solver.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -62,7 +62,7 @@ template <typename T, std::size_t M> class EigenSolverReal {
_eigen_vectors(other._eigen_vectors), _gmres_k_rho(other._gmres_k_rho),
_gmres_k_rep_num(other._gmres_k_rep_num) {}

EigenSolverReal &operator=(EigenSolverReal<T, M> &other) {
EigenSolverReal &operator=(const EigenSolverReal<T, M> &other) {
if (this != &other) {
this->iteration_max = other.iteration_max;
this->division_min = other.division_min;
Expand Down Expand Up @@ -445,7 +445,7 @@ template <typename T, std::size_t M> class EigenSolverComplex {
_eigen_vectors(other._eigen_vectors), _gmres_k_rho(other._gmres_k_rho),
_gmres_k_rep_num(other._gmres_k_rep_num) {}

EigenSolverComplex &operator=(EigenSolverComplex<T, M> &other) {
EigenSolverComplex &operator=(const EigenSolverComplex<T, M> &other) {
if (this != &other) {
this->iteration_max = other.iteration_max;
this->iteration_max_for_eigen_vector =
Expand Down
3 changes: 3 additions & 0 deletions python_numpy/python_numpy_base_simplification.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -197,6 +197,9 @@ template <typename T, typename SparseAvailable>
using SparseMatrix_Type =
decltype(make_SparseMatrixZeros<T, SparseAvailable>());

template <typename T, std::size_t M, std::size_t N>
using SparseMatrixEmpty_Type = decltype(make_SparseMatrixEmpty<T, M, N>());

} // namespace PythonNumpy

#endif // __PYTHON_NUMPY_BASE_SIMPLIFICATION_HPP__
3 changes: 0 additions & 3 deletions python_numpy/python_numpy_templates.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -69,9 +69,6 @@ template <std::size_t M, std::size_t N>
using UpperTriangularRowPointers =
Base::Matrix::UpperTriangularRowPointers<M, N>;

template <std::size_t M, std::size_t N>
using SparseAvailable_NoUse = DenseAvailableEmpty<M, N>;

template <typename SparseAvailable_A, typename SparseAvailable_B>
using MatrixAddSubSparseAvailable =
Base::Matrix::MatrixAddSubSparseAvailable<SparseAvailable_A,
Expand Down
61 changes: 60 additions & 1 deletion test_vs/check_python_numpy.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -599,7 +599,7 @@ void CheckPythonNumpy<T>::check_python_numpy_base_simplification(void) {
tester.expect_near(Identity_dense.matrix.data, Identity_answer.matrix.data, NEAR_LIMIT_STRICT,
"check make_DiagMatrixIdentity.");

auto Empty = make_SparseMatrixEmpty<T, 3, 4>();
SparseMatrixEmpty_Type<T, 3, 4> Empty = make_SparseMatrixEmpty<T, 3, 4>();
auto Empty_dense = Empty.create_dense();

Matrix<DefDense, T, 3, 4> Empty_answer;
Expand Down Expand Up @@ -718,9 +718,14 @@ void CheckPythonNumpy<T>::check_python_numpy_left_divide_and_inv(void) {

LinalgSolver_Type<decltype(A), decltype(A)> A_A_linalg_solver
= make_LinalgSolver<decltype(A), decltype(A)>();

A_A_linalg_solver.set_division_min(static_cast<T>(1.0e-10));
A_A_linalg_solver.set_decay_rate(static_cast<T>(0));

LinalgSolver_Type<decltype(A), decltype(A)> A_A_linalg_solver_copy = A_A_linalg_solver;
LinalgSolver_Type<decltype(A), decltype(A)> A_A_linalg_solver_move = std::move(A_A_linalg_solver_copy);
A_A_linalg_solver = A_A_linalg_solver_move;

auto A_A_x = A_A_linalg_solver.solve(A, A);

Matrix<DefDense, T, 3, 3> A_A_x_answer({
Expand Down Expand Up @@ -880,6 +885,10 @@ void CheckPythonNumpy<T>::check_python_numpy_left_divide_and_inv(void) {
LinalgLstsqSolver_Type<decltype(CL), decltype(CL )> CL_CL_lstsq_solver
= make_LinalgLstsqSolver<decltype(CL), decltype(CL)>();

LinalgLstsqSolver_Type<decltype(CL), decltype(CL)> CL_CL_lstsq_solver_copy = CL_CL_lstsq_solver;
LinalgLstsqSolver_Type<decltype(CL), decltype(CL)> CL_CL_lstsq_solver_move = std::move(CL_CL_lstsq_solver_copy);
CL_CL_lstsq_solver = CL_CL_lstsq_solver_move;

auto CL_CL_x = CL_CL_lstsq_solver.solve(CL, CL);

Matrix<DefDense, T, 3, 3> CL_CL_x_answer({
Expand All @@ -897,6 +906,10 @@ void CheckPythonNumpy<T>::check_python_numpy_left_divide_and_inv(void) {

auto A_Inv = A_inv_solver.inv(A);

LinalgSolverInv_Type<decltype(A)> A_inv_solver_copy = A_inv_solver;
LinalgSolverInv_Type<decltype(A)> A_inv_solver_move = std::move(A_inv_solver_copy);
A_inv_solver = A_inv_solver_move;

Matrix<DefDense, T, 3, 3> A_Inv_answer({
{-6.66666667e-01F, 3.33333333e-01F, 0.0F },
{6.33333333e-01F, -6.66666667e-01F, 3.00000000e-01F },
Expand All @@ -908,6 +921,10 @@ void CheckPythonNumpy<T>::check_python_numpy_left_divide_and_inv(void) {

static auto B_inv_solver = make_LinalgSolverInv<decltype(B)>();

LinalgSolverInv_Type<decltype(B)> B_inv_solver_copy = B_inv_solver;
LinalgSolverInv_Type<decltype(B)> B_inv_solver_move = std::move(B_inv_solver_copy);
B_inv_solver = B_inv_solver_move;

auto B_Inv = B_inv_solver.inv(B);
B_Inv = B_inv_solver.get_answer();
auto B_Inv_dense = B_Inv.create_dense();
Expand Down Expand Up @@ -1973,6 +1990,10 @@ void CheckPythonNumpy<T>::check_python_numpy_cholesky(void) {
Chol_solver.set_division_min(static_cast<T>(1.0e-10));
Chol_solver = make_LinalgSolverCholesky<decltype(K)>();

LinalgSolverCholesky_Type<decltype(K)> Chol_solver_copy = Chol_solver;
LinalgSolverCholesky_Type<decltype(K)> Chol_solver_move = std::move(Chol_solver_copy);
Chol_solver = std::move(Chol_solver_move);

auto A_ch = Chol_solver.solve(K);
auto A_ch_dense = A_ch.create_dense();

Expand Down Expand Up @@ -2300,6 +2321,10 @@ void CheckPythonNumpy<T>::check_python_numpy_qr(void) {
QR_solver_dense.set_division_min(static_cast<T>(1.0e-10));
QR_solver_dense.solve(A);

LinalgSolverQR_Type<decltype(A)> QR_solver_dense_copy = QR_solver_dense;
LinalgSolverQR_Type<decltype(A)> QR_solver_dense_move = std::move(QR_solver_dense_copy);
QR_solver_dense = QR_solver_dense_move;

auto Q = QR_solver_dense.get_Q();
auto R = QR_solver_dense.get_R();
auto R_dense = R.create_dense();
Expand Down Expand Up @@ -2327,6 +2352,10 @@ void CheckPythonNumpy<T>::check_python_numpy_qr(void) {
LinalgSolverQR_Type<decltype(B)> QR_solver_diag = make_LinalgSolverQR<decltype(B)>();
QR_solver_diag.solve(B);

LinalgSolverQR_Type<decltype(B)> QR_solver_diag_copy = QR_solver_diag;
LinalgSolverQR_Type<decltype(B)> QR_solver_diag_move = std::move(QR_solver_diag_copy);
QR_solver_diag = QR_solver_diag_move;

auto R_diag = QR_solver_diag.get_R();
auto R_diag_dense = R_diag.create_dense();

Expand All @@ -2341,6 +2370,11 @@ void CheckPythonNumpy<T>::check_python_numpy_qr(void) {

LinalgSolverQR_Type<decltype(C)> QR_solver_sparse = make_LinalgSolverQR<decltype(C)>();
QR_solver_sparse.set_division_min(static_cast<T>(1.0e-10));

LinalgSolverQR_Type<decltype(C)> QR_solver_sparse_copy = QR_solver_sparse;
LinalgSolverQR_Type<decltype(C)> QR_solver_sparse_move = std::move(QR_solver_sparse_copy);
QR_solver_sparse = QR_solver_sparse_move;

QR_solver_sparse.solve(C);
auto C_QR = QR_solver_sparse.get_Q() * QR_solver_sparse.get_R();

Expand Down Expand Up @@ -2378,6 +2412,11 @@ void CheckPythonNumpy<T>::check_python_numpy_eig(void) {
/* 対角行列の固有値 実数 */
LinalgSolverEigReal_Type<decltype(B)> eig_solver_diag
= make_LinalgSolverEigReal<decltype(B)>();

LinalgSolverEigReal_Type<decltype(B)> eig_solver_diag_copy = eig_solver_diag;
LinalgSolverEigReal_Type<decltype(B)> eig_solver_diag_move = std::move(eig_solver_diag_copy);
eig_solver_diag = eig_solver_diag_move;

eig_solver_diag.solve_eigen_values(B);

auto eigen_values_diag = eig_solver_diag.get_eigen_values();
Expand All @@ -2401,6 +2440,10 @@ void CheckPythonNumpy<T>::check_python_numpy_eig(void) {
eig_solver_sparse.set_iteration_max(10);
eig_solver_sparse.set_division_min(static_cast<T>(1.0e-20));

LinalgSolverEigReal_Type<decltype(C)> eig_solver_sparse_copy = eig_solver_sparse;
LinalgSolverEigReal_Type<decltype(C)> eig_solver_sparse_move = std::move(eig_solver_sparse_copy);
eig_solver_sparse = eig_solver_sparse_move;

eig_solver_sparse.solve_eigen_values(C);

auto eigen_values_sparse = eig_solver_sparse.get_eigen_values();
Expand Down Expand Up @@ -2435,6 +2478,10 @@ void CheckPythonNumpy<T>::check_python_numpy_eig(void) {
eig_solver.set_iteration_max(10);
eig_solver.solve_eigen_values(A0);

LinalgSolverEigReal_Type<decltype(A)> eig_solver_copy = eig_solver;
LinalgSolverEigReal_Type<decltype(A)> eig_solver_move = std::move(eig_solver_copy);
eig_solver = eig_solver_move;

auto eigen_values = eig_solver.get_eigen_values();

decltype(eigen_values) eigen_values_sorted = eigen_values;
Expand Down Expand Up @@ -2480,6 +2527,10 @@ void CheckPythonNumpy<T>::check_python_numpy_eig(void) {
static auto eig_solver_diag_comp = make_LinalgSolverEig<decltype(B)>();
eig_solver_diag_comp.solve_eigen_values(B);

LinalgSolverEig_Type<decltype(B)> eig_solver_diag_comp_copy = eig_solver_diag_comp;
LinalgSolverEig_Type<decltype(B)> eig_solver_diag_comp_move = std::move(eig_solver_diag_comp_copy);
eig_solver_diag_comp = eig_solver_diag_comp_move;

auto eigen_values_comp_diag = eig_solver_diag_comp.get_eigen_values();

Matrix<DefDense, T, 3, 1> eigen_values_comp_diag_real(
Expand Down Expand Up @@ -2510,6 +2561,10 @@ void CheckPythonNumpy<T>::check_python_numpy_eig(void) {
eig_solver_comp_sparse.set_iteration_max_for_eigen_vector(30);
eig_solver_comp_sparse.set_division_min(static_cast<T>(1.0e-20));

LinalgSolverEig_Type<decltype(C)> eig_solver_comp_sparse_copy = eig_solver_comp_sparse;
LinalgSolverEig_Type<decltype(C)> eig_solver_comp_sparse_move = std::move(eig_solver_comp_sparse_copy);
eig_solver_comp_sparse = eig_solver_comp_sparse_move;

eig_solver_comp_sparse.solve_eigen_values(C);

auto eigen_values_comp_sparse = eig_solver_comp_sparse.get_eigen_values();
Expand Down Expand Up @@ -2560,6 +2615,10 @@ void CheckPythonNumpy<T>::check_python_numpy_eig(void) {
eig_solver_comp.set_iteration_max_for_eigen_vector(15);
eig_solver_comp.set_division_min(static_cast<T>(1.0e-20));

LinalgSolverEig_Type<decltype(A1)> eig_solver_comp_copy = eig_solver_comp;
LinalgSolverEig_Type<decltype(A1)> eig_solver_comp_move = std::move(eig_solver_comp_copy);
eig_solver_comp = eig_solver_comp_move;

eig_solver_comp.solve_eigen_values(A1);

auto eigen_values_comp = eig_solver_comp.get_eigen_values();
Expand Down