LMCAS::detail::matrix_decomposition 命名空间参考

命名空间
namespace	anonymous_namespace{matrix_decomposition_support.cpp}

函数
std::optional< std::vector< Rational > >	exact_diagonal_entries (const std::shared_ptr< const MatrixNode > &matrix, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	exact_number_expr (const Rational &value)
std::optional< Rational >	exact_rational_expr (const std::shared_ptr< const SymbolicNode > &node)
std::optional< Rational >	exact_rational_expr (const std::shared_ptr< SymbolicExpr > &expr, ComputationContext &context)
std::optional< std::vector< std::vector< Rational > > >	exact_rational_matrix (const std::shared_ptr< const MatrixNode > &matrix, ComputationContext &context)
std::optional< std::vector< Rational > >	exact_rectangular_diagonal_entries (const std::shared_ptr< const MatrixNode > &matrix, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	identity_matrix_expr (size_t n)
std::shared_ptr< SymbolicExpr >	identity_matrix_expr (std::size_t n)
std::shared_ptr< SymbolicExpr >	rectangular_diagonal_expr (size_t rows, size_t cols, const std::vector< Rational > &diagonal)
std::shared_ptr< SymbolicExpr >	rectangular_diagonal_expr (std::size_t rows, std::size_t cols, const std::vector< Rational > &diagonal)
Result< std::shared_ptr< const MatrixNode > >	validate_decomposition_matrix (const std::shared_ptr< SymbolicExpr > &A, bool require_square, ComputationContext &context, const std::string &operation)
Result< void >	validate_decomposition_output (const std::shared_ptr< SymbolicExpr > &expr, const std::string &name, const std::string &operation)

函数说明

exact_diagonal_entries()

std::optional< std::vector< Rational > > LMCAS::detail::matrix_decomposition::exact_diagonal_entries	(	const std::shared_ptr< const MatrixNode > &	matrix,
		ComputationContext &	context )

在文件 matrix_decomposition_support.cpp 第 172 行定义.

                                                                                {
    auto values = exact_rational_matrix(matrix, context);
    if (!values) return std::nullopt;
    const size_t rows = values->size();
    const size_t cols = rows == 0 ? 0 : (*values)[0].size();
    if (rows != cols) return std::nullopt;
    std::vector<Rational> diagonal(rows, Rational(0));
    for (size_t row = 0; row < rows; ++row) {
        for (size_t col = 0; col < cols; ++col) {
            if (row == col) {
                diagonal[row] = (*values)[row][col];
            } else if ((*values)[row][col] != Rational(0)) {
                return std::nullopt;
            }
        }
    }
    return diagonal;
}

引用了 LMCAS::detail::context, exact_diagonal_entries() , 以及 exact_rational_matrix().

被这些函数引用 LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::diagonalization_checked(), exact_diagonal_entries(), identity_matrix_expr() , 以及 LMCAS::jordan_form_checked().

函数调用图:

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

exact_number_expr()

std::shared_ptr< SymbolicExpr > LMCAS::detail::matrix_decomposition::exact_number_expr

(

const Rational &

value

)

在文件 matrix_decomposition_support.cpp 第 114 行定义.

                                                                     {
    if (value.get_denominator() == BigInt(1)) {
        return LMCAS::detail::make_expression_ptr(
            LMCAS::detail::make_node<NumberNode>(value.get_numerator()));
    }
    return LMCAS::detail::make_expression_ptr(
        LMCAS::detail::make_node<NumberNode>(value));
}

引用了 exact_number_expr(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node() , 以及 LMCAS::value.

被这些函数引用 exact_number_expr(), LMCAS::jordan_form_checked(), LMCAS::anonymous_namespace{matrix_decomposition.cpp}::maximum_axis_sum(), LMCAS::anonymous_namespace{matrix_decomposition_lu.cpp}::rational_rows_expression() , 以及 rectangular_diagonal_expr().

函数调用图:

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

exact_rational_expr() [1/2]

std::optional< Rational > LMCAS::detail::matrix_decomposition::exact_rational_expr

(

const std::shared_ptr< const SymbolicNode > &

node

)

在文件 matrix_decomposition_support.cpp 第 72 行定义.

                                                                                         {
    if (!node) return std::nullopt;
    if (auto number = std::dynamic_pointer_cast<const NumberNode>(node)) {
        return LMCAS::detail::exact_rational_value(*number);
    }
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        return exact_rational_sum(*add);
    }
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        return exact_rational_product(*mul);
    }
    if (auto fn = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        if (fn->type() == FunctionNode::FuncType::Abs && fn->arguments().size() == 1) {
            auto value = exact_rational_expr(fn->arguments()[0]);
            if (!value) return std::nullopt;
            return (*value < Rational(0)) ? (Rational(0) - *value) : *value;
        }
    }
    return std::nullopt;
}

引用了 LMCAS::FunctionNode::Abs, LMCAS::add(), exact_rational_expr(), LMCAS::detail::exact_rational_value(), LMCAS::mul(), LMCAS::detail::node() , 以及 LMCAS::value.

被这些函数引用 exact_rational_expr(), exact_rational_expr(), exact_rational_matrix(), LMCAS::detail::matrix_decomposition::anonymous_namespace{matrix_decomposition_support.cpp}::exact_rational_product(), LMCAS::detail::matrix_decomposition::anonymous_namespace{matrix_decomposition_support.cpp}::exact_rational_sum(), LMCAS::anonymous_namespace{matrix_decomposition.cpp}::matrix_axis_sum(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::quadratic_eigenvalue_sign() , 以及 LMCAS::detail::matrix_decomposition::anonymous_namespace{matrix_decomposition_support.cpp}::simplify_exact_rational_expr().

函数调用图:

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

exact_rational_expr() [2/2]

std::optional< Rational > LMCAS::detail::matrix_decomposition::exact_rational_expr	(	const std::shared_ptr< SymbolicExpr > &	expr,
		ComputationContext &	context )

在文件 matrix_decomposition_support.cpp 第 107 行定义.

                                                                                                                {
    if (!expr || !LMCAS::detail::node(expr)) return std::nullopt;
    const auto& node = LMCAS::detail::node(expr);
    if (auto direct = exact_rational_expr(node)) return direct;
    return simplify_exact_rational_expr(node, context);
}

引用了 LMCAS::detail::context, exact_rational_expr() , 以及 LMCAS::detail::node().

函数调用图:

exact_rational_matrix()

std::optional< std::vector< std::vector< Rational > > > LMCAS::detail::matrix_decomposition::exact_rational_matrix	(	const std::shared_ptr< const MatrixNode > &	matrix,
		ComputationContext &	context )

在文件 matrix_decomposition_support.cpp 第 123 行定义.

                                                                                {
    if (!matrix) return std::nullopt;
    std::vector<std::vector<Rational>> values(
        matrix->rows(), std::vector<Rational>(matrix->cols(), Rational(0)));
    for (size_t row = 0; row < matrix->rows(); ++row) {
        for (size_t col = 0; col < matrix->cols(); ++col) {
            const auto& node = matrix->get(row, col);
            auto value = exact_rational_expr(node);
            if (!value) {
                value = simplify_exact_rational_expr(node, context);
            }
            if (!value) return std::nullopt;
            values[row][col] = *value;
        }
    }
    return values;
}

引用了 LMCAS::detail::context, exact_rational_expr(), exact_rational_matrix(), LMCAS::detail::node() , 以及 LMCAS::value.

被这些函数引用 exact_diagonal_entries(), exact_rational_matrix(), exact_rectangular_diagonal_entries(), LMCAS::jordan_form_checked(), LMCAS::lu_decomposition_checked(), LMCAS::anonymous_namespace{matrix_decomposition_qr.cpp}::prove_exact_full_column_rank_qr_support() , 以及 LMCAS::anonymous_namespace{matrix_decomposition_cholesky.cpp}::prove_exact_spd().

函数调用图:

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

exact_rectangular_diagonal_entries()

std::optional< std::vector< Rational > > LMCAS::detail::matrix_decomposition::exact_rectangular_diagonal_entries	(	const std::shared_ptr< const MatrixNode > &	matrix,
		ComputationContext &	context )

在文件 matrix_decomposition_support.cpp 第 150 行定义.

                                                                                {
    auto values = exact_rational_matrix(matrix, context);
    if (!values) return std::nullopt;
    const size_t rows = values->size();
    const size_t cols = rows == 0 ? 0 : (*values)[0].size();
    const size_t diag_count = std::min(rows, cols);
    std::vector<Rational> diagonal(diag_count, Rational(0));
    for (size_t row = 0; row < rows; ++row) {
        for (size_t col = 0; col < cols; ++col) {
            const bool is_diag = row == col && row < diag_count;
            if (!is_diag && (*values)[row][col] != Rational(0)) {
                return std::nullopt;
            }
            if (is_diag) {
                diagonal[row] = (*values)[row][col];
            }
        }
    }
    return diagonal;
}

引用了 LMCAS::detail::context, exact_rational_matrix() , 以及 exact_rectangular_diagonal_entries().

被这些函数引用 exact_rectangular_diagonal_entries(), identity_matrix_expr() , 以及 LMCAS::svd_decomposition_checked().

函数调用图:

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

identity_matrix_expr() [1/2]

std::shared_ptr< SymbolicExpr > LMCAS::detail::matrix_decomposition::identity_matrix_expr

(

size_t

n

)

在文件 matrix_decomposition_support.cpp 第 141 行定义.

                                                           {
    std::vector<std::vector<std::shared_ptr<SymbolicExpr>>> grid(
        n, std::vector<std::shared_ptr<SymbolicExpr>>(n, SymbolicExpr::number(0)));
    for (size_t i = 0; i < n; ++i) {
        grid[i][i] = SymbolicExpr::number(1);
    }
    return SymbolicExpr::matrix(grid);
}

引用了 identity_matrix_expr().

函数调用图:

identity_matrix_expr() [2/2]

std::shared_ptr< SymbolicExpr > LMCAS::detail::matrix_decomposition::identity_matrix_expr

(

std::size_t

n

)

引用了 LMCAS::detail::context, exact_diagonal_entries(), exact_rectangular_diagonal_entries() , 以及 identity_matrix_expr().

被这些函数引用 LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::diagonalization_checked(), identity_matrix_expr(), identity_matrix_expr(), LMCAS::jordan_form_checked() , 以及 LMCAS::svd_decomposition_checked().

函数调用图:

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

rectangular_diagonal_expr() [1/2]

std::shared_ptr< SymbolicExpr > LMCAS::detail::matrix_decomposition::rectangular_diagonal_expr	(	size_t	rows,
		size_t	cols,
		const std::vector< Rational > &	diagonal )

在文件 matrix_decomposition_support.cpp 第 192 行定义.

                                         {
    std::vector<std::vector<std::shared_ptr<SymbolicExpr>>> grid(
        rows, std::vector<std::shared_ptr<SymbolicExpr>>(cols, SymbolicExpr::number(0)));
    for (size_t i = 0; i < diagonal.size(); ++i) {
        grid[i][i] = exact_number_expr(diagonal[i]);
    }
    return SymbolicExpr::matrix(grid);
}

引用了 exact_number_expr() , 以及 rectangular_diagonal_expr().

函数调用图:

rectangular_diagonal_expr() [2/2]

std::shared_ptr< SymbolicExpr > LMCAS::detail::matrix_decomposition::rectangular_diagonal_expr	(	std::size_t	rows,
		std::size_t	cols,
		const std::vector< Rational > &	diagonal )

引用了 rectangular_diagonal_expr().

被这些函数引用 LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::diagonalization_checked(), LMCAS::jordan_form_checked(), rectangular_diagonal_expr(), rectangular_diagonal_expr() , 以及 LMCAS::svd_decomposition_checked().

函数调用图:

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

validate_decomposition_matrix()

Result< std::shared_ptr< const MatrixNode > > LMCAS::detail::matrix_decomposition::validate_decomposition_matrix	(	const std::shared_ptr< SymbolicExpr > &	A,
		bool	require_square,
		ComputationContext &	context,
		const std::string &	operation )

在文件 matrix_decomposition_support.cpp 第 6 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) return Result<std::shared_ptr<const MatrixNode>>::failure(step.error());
    if (!A || !LMCAS::detail::node(A)) {
        return Result<std::shared_ptr<const MatrixNode>>::failure(
            CasErrc::InvalidArgument,
            "matrix input cannot be null",
            operation);
    }
    auto matrix = std::dynamic_pointer_cast<const MatrixNode>(LMCAS::detail::node(A));
    if (!matrix) {
        return Result<std::shared_ptr<const MatrixNode>>::failure(
            CasErrc::InvalidArgument,
            "input must be a matrix",
            operation);
    }
    if (require_square && matrix->rows() != matrix->cols()) {
        return Result<std::shared_ptr<const MatrixNode>>::failure(
            CasErrc::InvalidArgument,
            "matrix must be square",
            operation);
    }
    return Result<std::shared_ptr<const MatrixNode>>::success(matrix);
}

引用了 LMCAS::detail::context, LMCAS::InvalidArgument, LMCAS::detail::node(), LMCAS::detail::operation , 以及 validate_decomposition_matrix().

被这些函数引用 LMCAS::cholesky_decomposition_checked(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::diagonalization_checked(), LMCAS::jordan_form_checked(), LMCAS::lu_decomposition_checked(), LMCAS::qr_decomposition_checked(), LMCAS::svd_decomposition_checked() , 以及 validate_decomposition_matrix().

函数调用图:

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

validate_decomposition_output()

Result< void > LMCAS::detail::matrix_decomposition::validate_decomposition_output	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	name,
		const std::string &	operation )

在文件 matrix_decomposition_support.cpp 第 36 行定义.

{
    if (!expr || !LMCAS::detail::node(expr) ||
        !std::dynamic_pointer_cast<const MatrixNode>(LMCAS::detail::node(expr))) {
        return Result<void>::failure(
            CasErrc::InternalInvariant,
            name + " output is not a matrix",
            operation);
    }
    return Result<void>::success();
}

引用了 LMCAS::Result< T >::failure(), LMCAS::InternalInvariant, LMCAS::name, LMCAS::detail::node(), LMCAS::detail::operation, LMCAS::Result< T >::success() , 以及 validate_decomposition_output().

被这些函数引用 LMCAS::cholesky_decomposition_checked(), LMCAS::qr_decomposition_checked() , 以及 validate_decomposition_output().

函数调用图:

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