LMCAS::anonymous_namespace{matrix_decomposition_qr.cpp} 命名空间参考

函数
Result< void >	prove_exact_full_column_rank_qr_support (const std::shared_ptr< const MatrixNode > &matrix, ComputationContext &context, const std::string &operation)
static bool	qr_decomposition_impl (const std::shared_ptr< SymbolicExpr > &A, std::shared_ptr< SymbolicExpr > &Q, std::shared_ptr< SymbolicExpr > &R)

函数说明

prove_exact_full_column_rank_qr_support()

Result< void > LMCAS::anonymous_namespace{matrix_decomposition_qr.cpp}::prove_exact_full_column_rank_qr_support	(	const std::shared_ptr< const MatrixNode > &	matrix,
		ComputationContext &	context,
		const std::string &	operation )

在文件 matrix_decomposition_qr.cpp 第 11 行定义.

                                {
    auto values = exact_rational_matrix(matrix, context);
    if (!values) {
        return Result<void>::failure(
            CasErrc::Inconclusive,
            "QR input is outside the exact rational full-column-rank support domain",
            operation);
    }
    const size_t rows = values->size();
    const size_t cols = rows == 0 ? 0 : (*values)[0].size();
    if (rows < cols) {
        return Result<void>::failure(
            CasErrc::Inconclusive,
            "QR decomposition requires at least as many rows as columns in the supported domain",
            operation);
    }
    std::vector<std::vector<Rational>> gram(
        cols, std::vector<Rational>(cols, Rational(0)));
    for (size_t i = 0; i < cols; ++i) {
        for (size_t j = 0; j < cols; ++j) {
            Rational sum(0);
            for (size_t row = 0; row < rows; ++row) {
                sum = sum + (*values)[row][i] * (*values)[row][j];
            }
            gram[i][j] = sum;
        }
    }
    for (size_t order = 1; order <= cols; ++order) {
        std::vector<Rational> leading;
        leading.reserve(order * order);
        for (size_t row = 0; row < order; ++row) {
            for (size_t col = 0; col < order; ++col) {
                leading.push_back(gram[row][col]);
            }
        }
        auto determinant = detail::rational_determinant_exact(
            order, std::move(leading), context, operation);
        if (!determinant) return Result<void>::failure(determinant.error());
        if (determinant.value() <= Rational(0)) {
            return Result<void>::failure(
                CasErrc::Inconclusive,
                "QR decomposition requires proven full column rank",
                operation);
        }
    }
    return Result<void>::success();
}

引用了 LMCAS::context, LMCAS::detail::matrix_decomposition::exact_rational_matrix(), LMCAS::Result< T >::failure(), LMCAS::Inconclusive, LMCAS::order, prove_exact_full_column_rank_qr_support(), LMCAS::detail::rational_determinant_exact() , 以及 LMCAS::Result< T >::success().

被这些函数引用 prove_exact_full_column_rank_qr_support().

函数调用图:

这是这个函数的调用关系图:

qr_decomposition_impl()

bool LMCAS::anonymous_namespace{matrix_decomposition_qr.cpp}::qr_decomposition_impl ( const std::shared_ptr< SymbolicExpr > & A, std::shared_ptr< SymbolicExpr > & Q, std::shared_ptr< SymbolicExpr > & R )

static

在文件 matrix_decomposition_qr.cpp 第 61 行定义.

                                    {
    auto mat = std::dynamic_pointer_cast<const MatrixNode>(LMCAS::detail::node(A));
    if (!mat) return false;
    size_t m = mat->rows();
    size_t n = mat->cols();
 
    std::vector<std::vector<std::shared_ptr<SymbolicExpr>>> Q_grid(m, std::vector<std::shared_ptr<SymbolicExpr>>(n, SymbolicExpr::number(0)));
    std::vector<std::vector<std::shared_ptr<SymbolicExpr>>> R_grid(n, std::vector<std::shared_ptr<SymbolicExpr>>(n, SymbolicExpr::number(0)));
 
    std::vector<std::vector<std::shared_ptr<SymbolicExpr>>> A_cols(n, std::vector<std::shared_ptr<SymbolicExpr>>(m));
    for (size_t j = 0; j < n; j++) {
        for (size_t i = 0; i < m; i++) A_cols[j][i] = LMCAS::detail::make_expression_ptr(mat->get(i, j));
    }
 
    for (size_t j = 0; j < n; j++) {
        std::vector<std::shared_ptr<SymbolicExpr>> u_j = A_cols[j];
        for (size_t i = 0; i < j; i++) {
            auto dot = SymbolicExpr::number(0);
            for (size_t k = 0; k < m; k++) dot = SymbolicExpr::add(dot, SymbolicExpr::multiply(Q_grid[k][i], A_cols[j][k]));
            R_grid[i][j] = dot;
 
            for (size_t k = 0; k < m; k++) {
                u_j[k] = SymbolicExpr::add(u_j[k], SymbolicExpr::multiply(SymbolicExpr::number(-1), SymbolicExpr::multiply(R_grid[i][j], Q_grid[k][i])));
            }
        }
 
        auto norm_sq = SymbolicExpr::number(0);
        for (size_t k = 0; k < m; k++) norm_sq = SymbolicExpr::add(norm_sq, SymbolicExpr::multiply(u_j[k], u_j[k]));
        R_grid[j][j] = SymbolicExpr::sqrt(norm_sq);
 
        for (size_t k = 0; k < m; k++) Q_grid[k][j] = SymbolicExpr::divide(u_j[k], R_grid[j][j]);
    }
 
    Q = SymbolicExpr::matrix(Q_grid);
    R = SymbolicExpr::matrix(R_grid);
    return true;
}

引用了 LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 qr_decomposition_impl().

被这些函数引用 qr_decomposition_impl().

函数调用图:

这是这个函数的调用关系图: