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

类型定义
using	RationalRows = std::vector<std::vector<Rational>>

函数
void	eliminate_lu_column (RationalRows &lower, RationalRows &upper, std::size_t column)
Result< void >	factor_lu (RationalRows &lower, RationalRows &upper, RationalRows &permutation, const std::string &operation)
std::shared_ptr< SymbolicExpr >	rational_rows_expression (const RationalRows &input)

类型定义说明

RationalRows

using LMCAS::anonymous_namespace{matrix_decomposition_lu.cpp}::RationalRows = std::vector<std::vector<Rational>>

在文件 matrix_decomposition_lu.cpp 第 9 行定义.

函数说明

eliminate_lu_column()

void LMCAS::anonymous_namespace{matrix_decomposition_lu.cpp}::eliminate_lu_column	(	RationalRows &	lower,
		RationalRows &	upper,
		std::size_t	column )

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

                                           {
    const std::size_t n = upper.size();
            for (std::size_t row = column + 1; row < n; ++row) {
                const Rational multiplier =
                    upper[row][column] / upper[column][column];
                lower[row][column] = multiplier;
                for (std::size_t col = column; col < n; ++col) {
                    upper[row][col] =
                        upper[row][col] -
                        multiplier * upper[column][col];
                }
            }
}

引用了 eliminate_lu_column(), LMCAS::lower , 以及 LMCAS::upper.

被这些函数引用 eliminate_lu_column() , 以及 factor_lu().

函数调用图:

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

factor_lu()

Result< void > LMCAS::anonymous_namespace{matrix_decomposition_lu.cpp}::factor_lu	(	RationalRows &	lower,
		RationalRows &	upper,
		RationalRows &	permutation,
		const std::string &	operation )

在文件 matrix_decomposition_lu.cpp 第 26 行定义.

                                                                              {
    const std::size_t n = upper.size();
        for (std::size_t i = 0; i < n; ++i) {
            lower[i][i] = Rational(1);
            permutation[i][i] = Rational(1);
        }
        for (std::size_t column = 0; column < n; ++column) {
            std::size_t pivot = column;
            while (pivot < n && upper[pivot][column] == Rational(0)) ++pivot;
            if (pivot == n) {
                return Result<void>::failure(
                    CasErrc::DomainError,
                    "PLU decomposition requires a nonsingular matrix",
                    operation);
            }
            if (pivot != column) {
                std::swap(upper[pivot], upper[column]);
                std::swap(permutation[pivot], permutation[column]);
                for (std::size_t prior = 0; prior < column; ++prior) {
                    std::swap(lower[pivot][prior], lower[column][prior]);
                }
            }
            eliminate_lu_column(lower, upper, column);
        }
    return Result<void>::success();
}

引用了 LMCAS::DomainError, eliminate_lu_column(), factor_lu(), LMCAS::Result< T >::failure(), LMCAS::lower, LMCAS::Result< T >::success() , 以及 LMCAS::upper.

被这些函数引用 factor_lu().

函数调用图:

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

rational_rows_expression()

std::shared_ptr< SymbolicExpr > LMCAS::anonymous_namespace{matrix_decomposition_lu.cpp}::rational_rows_expression

(

const RationalRows &

input

)

在文件 matrix_decomposition_lu.cpp 第 54 行定义.

                                                                                {
    const std::size_t n = input.size();
            std::vector<std::vector<std::shared_ptr<SymbolicExpr>>> grid(
                n, std::vector<std::shared_ptr<SymbolicExpr>>(n));
            for (std::size_t row = 0; row < n; ++row) {
                for (std::size_t col = 0; col < n; ++col) {
                    grid[row][col] = exact_number_expr(input[row][col]);
                }
            }
            return SymbolicExpr::matrix(grid);
}

引用了 LMCAS::detail::matrix_decomposition::exact_number_expr() , 以及 rational_rows_expression().

被这些函数引用 rational_rows_expression().

函数调用图:

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