Integrate Refactor solver sources and dual MSVC CMake builds
This commit is contained in:
KOKO\Mimi
@@ -7,8 +7,271 @@
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include "math/finite_values.h"
|
||||
|
||||
namespace fesa::dense_blas_internal {
|
||||
|
||||
namespace {
|
||||
|
||||
using math_internal::IsFinite;
|
||||
|
||||
/// @brief Keeps dense failures backend-neutral for caller-specific diagnostics.
|
||||
Status FactorFailure(const char* code, const char* message) {
|
||||
return Status::Failure({{Severity::kError, code, {}, "", "", message}});
|
||||
}
|
||||
|
||||
/// @brief Preserves each value owner's size exception at the private boundary.
|
||||
MKL_INT MklSizeOrThrow(const std::size_t size, const char* message) {
|
||||
const auto converted = ToMklSize(size);
|
||||
if (!converted.HasValue()) throw std::length_error{message};
|
||||
return converted.Value();
|
||||
}
|
||||
|
||||
/// @brief Converts a contiguous BLAS vector length with its existing contract.
|
||||
MKL_INT VectorSizeOrThrow(const std::size_t size) {
|
||||
return MklSizeOrThrow(size,
|
||||
"Dense vector size exceeds the MKL integer range.");
|
||||
}
|
||||
|
||||
/// @brief Converts a matrix dimension with its existing exception contract.
|
||||
MKL_INT MatrixSizeOrThrow(const std::size_t size) {
|
||||
return MklSizeOrThrow(size,
|
||||
"Dense matrix dimension exceeds the MKL integer range.");
|
||||
}
|
||||
|
||||
/// @brief Rejects Matrix product inputs before allocation or empty returns.
|
||||
void RequireFinite(const double* values, const std::size_t size) {
|
||||
for (std::size_t i = 0; i < size; ++i)
|
||||
if (!std::isfinite(values[i]))
|
||||
throw std::invalid_argument{"Matrix product inputs must be finite."};
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
DenseFactor::DenseFactor(const Matrix& coefficients,
|
||||
const bool positive_definite)
|
||||
: factors_{coefficients},
|
||||
pivots_(positive_definite ? 0U : coefficients.Rows()),
|
||||
positive_definite_{positive_definite} {
|
||||
for (std::size_t row = 0; row < coefficients.Rows(); ++row) {
|
||||
double row_sum = 0.0;
|
||||
for (std::size_t column = 0; column < coefficients.Columns(); ++column)
|
||||
row_sum += std::abs(coefficients(row, column));
|
||||
coefficient_norm_inf_ = (std::max)(coefficient_norm_inf_, row_sum);
|
||||
}
|
||||
}
|
||||
|
||||
Result<DenseFactor> DenseFactor::Lu(const Matrix& coefficients) {
|
||||
return Create(coefficients, false);
|
||||
}
|
||||
|
||||
Result<DenseFactor> DenseFactor::Cholesky(const Matrix& coefficients) {
|
||||
return Create(coefficients, true);
|
||||
}
|
||||
|
||||
Result<DenseFactor> DenseFactor::Create(const Matrix& coefficients,
|
||||
const bool positive_definite) {
|
||||
if (coefficients.Rows() != coefficients.Columns())
|
||||
return Result<DenseFactor>::Failure(FactorFailure(
|
||||
"dense-factor-shape", "Dense factor requires a square matrix."));
|
||||
const auto size = ToMklSize(coefficients.Rows());
|
||||
if (!size.HasValue()) return Result<DenseFactor>::Failure(size.GetStatus());
|
||||
if (!IsFinite(coefficients))
|
||||
return Result<DenseFactor>::Failure(FactorFailure(
|
||||
"dense-factor-nonfinite", "Dense factor inputs must be finite."));
|
||||
DenseFactor candidate{coefficients, positive_definite};
|
||||
if (size.Value() != 0) {
|
||||
const auto info =
|
||||
positive_definite
|
||||
? LAPACKE_dpotrf(LAPACK_ROW_MAJOR, 'L', size.Value(),
|
||||
candidate.factors_.Data(), size.Value())
|
||||
: LAPACKE_dgetrf(LAPACK_ROW_MAJOR, size.Value(), size.Value(),
|
||||
candidate.factors_.Data(), size.Value(),
|
||||
candidate.pivots_.data());
|
||||
if (info != 0 || !IsFinite(candidate.factors_))
|
||||
return Result<DenseFactor>::Failure(FactorFailure(
|
||||
"dense-factor-pivot", "Dense numerical factorization failed."));
|
||||
}
|
||||
return Result<DenseFactor>::Success(std::move(candidate));
|
||||
}
|
||||
|
||||
Result<Matrix> DenseFactor::Solve(const Matrix& rhs,
|
||||
const bool transpose) const {
|
||||
return SolveImpl(rhs, transpose, false, false);
|
||||
}
|
||||
|
||||
Result<Matrix> DenseFactor::SolveRight(const Matrix& rhs,
|
||||
const bool transpose) const {
|
||||
return SolveImpl(rhs, transpose, true, false);
|
||||
}
|
||||
|
||||
Result<Matrix> DenseFactor::SolveLower(const Matrix& rhs,
|
||||
const bool transpose) const {
|
||||
return SolveImpl(rhs, transpose, false, true);
|
||||
}
|
||||
|
||||
Result<Matrix> DenseFactor::SolveLowerRight(const Matrix& rhs,
|
||||
const bool transpose) const {
|
||||
return SolveImpl(rhs, transpose, true, true);
|
||||
}
|
||||
|
||||
Result<Matrix> DenseFactor::SolveImpl(const Matrix& rhs, const bool transpose,
|
||||
const bool right,
|
||||
const bool lower_only) const {
|
||||
const auto order = factors_.Rows();
|
||||
if ((right ? rhs.Columns() : rhs.Rows()) != order ||
|
||||
(lower_only && !positive_definite_))
|
||||
return Result<Matrix>::Failure(FactorFailure(
|
||||
"dense-solve-shape", "Dense solve shape or factor property differs."));
|
||||
const auto count = ToMklSize(right ? rhs.Rows() : rhs.Columns());
|
||||
if (!count.HasValue()) return Result<Matrix>::Failure(count.GetStatus());
|
||||
if (!IsFinite(rhs))
|
||||
return Result<Matrix>::Failure(FactorFailure(
|
||||
"dense-solve-nonfinite", "Dense solve RHS must be finite."));
|
||||
if (order == 0U || count.Value() == 0)
|
||||
return Result<Matrix>::Success(Matrix{rhs});
|
||||
Matrix candidate = right && !lower_only ? Matrix{order, rhs.Rows()}
|
||||
: Matrix{rhs};
|
||||
const auto size = ToMklSize(order).Value();
|
||||
if (lower_only) {
|
||||
cblas_dtrsm(CblasRowMajor, right ? CblasRight : CblasLeft, CblasLower,
|
||||
transpose ? CblasTrans : CblasNoTrans, CblasNonUnit,
|
||||
right ? count.Value() : size, right ? size : count.Value(), 1.0,
|
||||
factors_.Data(), size, candidate.Data(),
|
||||
right ? size : count.Value());
|
||||
} else {
|
||||
// X*op(A)=B becomes op(A)^T*X^T=B^T. GETRS uses a compact n-by-nrhs
|
||||
// row-major RHS with ldb=nrhs, including nonsquare multi-RHS storage.
|
||||
if (right) {
|
||||
for (std::size_t i = 0; i < rhs.Rows(); ++i)
|
||||
for (std::size_t j = 0; j < order; ++j) candidate(j, i) = rhs(i, j);
|
||||
}
|
||||
const auto info =
|
||||
positive_definite_
|
||||
? LAPACKE_dpotrs(LAPACK_ROW_MAJOR, 'L', size, count.Value(),
|
||||
factors_.Data(), size, candidate.Data(),
|
||||
count.Value())
|
||||
: LAPACKE_dgetrs(LAPACK_ROW_MAJOR, transpose != right ? 'T' : 'N',
|
||||
size, count.Value(), factors_.Data(), size,
|
||||
pivots_.data(), candidate.Data(), count.Value());
|
||||
if (info != 0)
|
||||
return Result<Matrix>::Failure(
|
||||
FactorFailure("dense-solve-backend", "Dense backend solve failed."));
|
||||
if (right) {
|
||||
Matrix transposed{rhs.Rows(), order};
|
||||
for (std::size_t i = 0; i < rhs.Rows(); ++i)
|
||||
for (std::size_t j = 0; j < order; ++j)
|
||||
transposed(i, j) = candidate(j, i);
|
||||
candidate = std::move(transposed);
|
||||
}
|
||||
}
|
||||
if (!IsFinite(candidate))
|
||||
return Result<Matrix>::Failure(FactorFailure(
|
||||
"dense-solve-nonfinite", "Dense solve result is nonfinite."));
|
||||
return Result<Matrix>::Success(std::move(candidate));
|
||||
}
|
||||
|
||||
Result<Matrix> DenseFactor::Lower() const {
|
||||
if (!positive_definite_)
|
||||
return Result<Matrix>::Failure(FactorFailure(
|
||||
"dense-factor-property", "An LU factor has no Cholesky lower factor."));
|
||||
Matrix lower{factors_.Rows(), factors_.Columns()};
|
||||
for (std::size_t i = 0; i < factors_.Rows(); ++i)
|
||||
for (std::size_t j = 0; j <= i; ++j) lower(i, j) = factors_(i, j);
|
||||
return Result<Matrix>::Success(std::move(lower));
|
||||
}
|
||||
|
||||
double DenseFactor::Determinant() const {
|
||||
double determinant = 1.0;
|
||||
for (std::size_t i = 0; i < factors_.Rows(); ++i) {
|
||||
determinant *= factors_(i, i);
|
||||
if (positive_definite_)
|
||||
determinant *= factors_(i, i);
|
||||
else if (pivots_[i] != static_cast<MKL_INT>(i + 1U))
|
||||
determinant = -determinant;
|
||||
}
|
||||
return determinant;
|
||||
}
|
||||
|
||||
Result<double> DenseFactor::ReciprocalConditionInfinity() const {
|
||||
if (!(coefficient_norm_inf_ > 0.0) || !std::isfinite(coefficient_norm_inf_))
|
||||
return Result<double>::Failure(FactorFailure(
|
||||
"dense-condition-norm", "Dense coefficient infinity norm is invalid."));
|
||||
const auto order = factors_.Rows();
|
||||
std::vector<double> row_sums(order, 0.0);
|
||||
Matrix rhs{order, 1U};
|
||||
for (std::size_t column = 0; column < order; ++column) {
|
||||
if (column != 0U) rhs(column - 1U, 0U) = 0.0;
|
||||
rhs(column, 0U) = 1.0;
|
||||
const auto solved = Solve(rhs);
|
||||
if (!solved.HasValue()) return Result<double>::Failure(solved.GetStatus());
|
||||
for (std::size_t row = 0; row < order; ++row)
|
||||
row_sums[row] += std::abs(solved.Value()(row, 0U));
|
||||
}
|
||||
double inverse_norm = 0.0;
|
||||
for (const auto row_sum : row_sums)
|
||||
inverse_norm = (std::max)(inverse_norm, row_sum);
|
||||
if (!(inverse_norm > 0.0) || !std::isfinite(inverse_norm))
|
||||
return Result<double>::Failure(FactorFailure(
|
||||
"dense-condition-norm", "Dense inverse infinity norm is invalid."));
|
||||
return Result<double>::Success((1.0 / coefficient_norm_inf_) / inverse_norm);
|
||||
}
|
||||
|
||||
double DotValues(const double* left, const std::size_t size,
|
||||
const double* right) {
|
||||
if (size == 0U) return 0.0;
|
||||
return cblas_ddot(VectorSizeOrThrow(size), left, 1, right, 1);
|
||||
}
|
||||
|
||||
double NormValues(const double* values, const std::size_t size) {
|
||||
if (size == 0U) return 0.0;
|
||||
return cblas_dnrm2(VectorSizeOrThrow(size), values, 1);
|
||||
}
|
||||
|
||||
void ScaleValues(const double alpha, double* values, const std::size_t size) {
|
||||
if (size == 0U) return;
|
||||
cblas_dscal(VectorSizeOrThrow(size), alpha, values, 1);
|
||||
}
|
||||
|
||||
void AxpyValues(const double alpha, const double* x, const std::size_t size,
|
||||
double* y) {
|
||||
if (size == 0U) return;
|
||||
cblas_daxpy(VectorSizeOrThrow(size), alpha, x, 1, y, 1);
|
||||
}
|
||||
|
||||
Vector Multiply(const Matrix& left, const Vector& right) {
|
||||
if (left.Columns() != right.Size())
|
||||
throw std::invalid_argument{
|
||||
"Matrix-vector multiplication has incompatible dimensions."};
|
||||
RequireFinite(left.Data(), left.Rows() * left.Columns());
|
||||
RequireFinite(right.Data(), right.Size());
|
||||
Vector result{left.Rows()};
|
||||
if (left.Rows() == 0U || left.Columns() == 0U) return result;
|
||||
const auto rows = MatrixSizeOrThrow(left.Rows());
|
||||
const auto columns = MatrixSizeOrThrow(left.Columns());
|
||||
cblas_dgemv(CblasRowMajor, CblasNoTrans, rows, columns, 1.0, left.Data(),
|
||||
columns, right.Data(), 1, 0.0, result.Data(), 1);
|
||||
return result;
|
||||
}
|
||||
|
||||
Matrix Multiply(const Matrix& left, const Matrix& right) {
|
||||
if (left.Columns() != right.Rows())
|
||||
throw std::invalid_argument{
|
||||
"Matrix multiplication has incompatible dimensions."};
|
||||
RequireFinite(left.Data(), left.Rows() * left.Columns());
|
||||
RequireFinite(right.Data(), right.Rows() * right.Columns());
|
||||
Matrix result{left.Rows(), right.Columns()};
|
||||
if (left.Rows() == 0U || left.Columns() == 0U || right.Columns() == 0U)
|
||||
return result;
|
||||
const auto rows = MatrixSizeOrThrow(left.Rows());
|
||||
const auto columns = MatrixSizeOrThrow(right.Columns());
|
||||
const auto inner = MatrixSizeOrThrow(left.Columns());
|
||||
cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, rows, columns, inner,
|
||||
1.0, left.Data(), inner, right.Data(), columns, 0.0,
|
||||
result.Data(), columns);
|
||||
return result;
|
||||
}
|
||||
|
||||
ScopedSingleEquationThreads::ScopedSingleEquationThreads(
|
||||
const std::size_t equation_count) noexcept {
|
||||
// The measured 1x1 PARDISO case has backend/thread overhead and an
|
||||
@@ -45,60 +308,6 @@ LocalDensePolicy ReadScopedLocalDensePolicy() noexcept {
|
||||
return {mkl_domain_get_max_threads(MKL_DOMAIN_BLAS), mkl_get_dynamic()};
|
||||
}
|
||||
|
||||
bool CholeskyLowerAndInverse(const Matrix& matrix, Matrix& lower,
|
||||
Matrix& inverse_lower, CholeskyFailure* failure) {
|
||||
if (failure != nullptr) *failure = CholeskyFailure::kNone;
|
||||
if (matrix.Rows() != matrix.Columns())
|
||||
throw std::invalid_argument{"Cholesky requires a square matrix."};
|
||||
const auto size = ToMklSize(matrix.Rows());
|
||||
if (!size.HasValue())
|
||||
throw std::length_error{"Cholesky size exceeds the MKL integer range."};
|
||||
Matrix candidate_lower{matrix.Rows(), matrix.Columns()};
|
||||
Matrix candidate_inverse{matrix.Rows(), matrix.Columns()};
|
||||
if (matrix.Rows() == 0U) {
|
||||
lower = std::move(candidate_lower);
|
||||
inverse_lower = std::move(candidate_inverse);
|
||||
return true;
|
||||
}
|
||||
std::vector<double> values(matrix.Rows() * matrix.Columns());
|
||||
for (std::size_t row = 0; row < matrix.Rows(); ++row)
|
||||
for (std::size_t column = 0; column < matrix.Columns(); ++column) {
|
||||
if (!std::isfinite(matrix(row, column)))
|
||||
throw std::invalid_argument{"Cholesky inputs must be finite."};
|
||||
values[row * matrix.Columns() + column] = matrix(row, column);
|
||||
}
|
||||
if (LAPACKE_dpotrf(LAPACK_ROW_MAJOR, 'L', size.Value(), values.data(),
|
||||
size.Value()) != 0) {
|
||||
if (failure != nullptr) *failure = CholeskyFailure::kPivot;
|
||||
return false;
|
||||
}
|
||||
for (std::size_t row = 0; row < matrix.Rows(); ++row)
|
||||
for (std::size_t column = 0; column <= row; ++column) {
|
||||
candidate_lower(row, column) = values[row * matrix.Columns() + column];
|
||||
if (!std::isfinite(candidate_lower(row, column))) {
|
||||
if (failure != nullptr) *failure = CholeskyFailure::kPivot;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (LAPACKE_dtrtri(LAPACK_ROW_MAJOR, 'L', 'N', size.Value(), values.data(),
|
||||
size.Value()) != 0) {
|
||||
if (failure != nullptr) *failure = CholeskyFailure::kInverse;
|
||||
return false;
|
||||
}
|
||||
for (std::size_t row = 0; row < matrix.Rows(); ++row)
|
||||
for (std::size_t column = 0; column <= row; ++column) {
|
||||
const auto value = values[row * matrix.Columns() + column];
|
||||
if (!std::isfinite(value)) {
|
||||
if (failure != nullptr) *failure = CholeskyFailure::kInverse;
|
||||
return false;
|
||||
}
|
||||
candidate_inverse(row, column) = value;
|
||||
}
|
||||
lower = std::move(candidate_lower);
|
||||
inverse_lower = std::move(candidate_inverse);
|
||||
return true;
|
||||
}
|
||||
|
||||
Vector MultiplyDiagonal(const Vector& diagonal, const Vector& rhs) {
|
||||
if (diagonal.Size() != rhs.Size())
|
||||
throw std::invalid_argument{"Diagonal product dimensions differ."};
|
||||
@@ -122,11 +331,19 @@ Matrix MultiplyTransposeLeft(const Matrix& left, const Matrix& right) {
|
||||
if (left.Rows() != right.Rows()) {
|
||||
throw std::invalid_argument{"Transpose product dimensions differ."};
|
||||
}
|
||||
Matrix transposed{left.Columns(), left.Rows()};
|
||||
for (std::size_t row = 0; row < left.Rows(); ++row)
|
||||
for (std::size_t column = 0; column < left.Columns(); ++column)
|
||||
transposed(column, row) = left(row, column);
|
||||
return transposed.Multiply(right);
|
||||
RequireFinite(left.Data(), left.Rows() * left.Columns());
|
||||
RequireFinite(right.Data(), right.Rows() * right.Columns());
|
||||
Matrix result{left.Columns(), right.Columns()};
|
||||
if (left.Columns() == 0U || left.Rows() == 0U || right.Columns() == 0U)
|
||||
return result;
|
||||
const auto rows = MatrixSizeOrThrow(left.Columns());
|
||||
const auto columns = MatrixSizeOrThrow(right.Columns());
|
||||
const auto inner = MatrixSizeOrThrow(left.Rows());
|
||||
// Row-major A is stored inner-by-rows even when GEMM consumes A-transpose.
|
||||
cblas_dgemm(CblasRowMajor, CblasTrans, CblasNoTrans, rows, columns, inner,
|
||||
1.0, left.Data(), rows, right.Data(), columns, 0.0,
|
||||
result.Data(), columns);
|
||||
return result;
|
||||
}
|
||||
|
||||
bool OuterProduct(const double* left, const std::size_t rows,
|
||||
|
||||
Reference in New Issue
Block a user