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

类型定义
using	Eigenspaces = std::vector<std::pair<ExprPtr, std::vector<std::vector<ExprPtr>>>>

函数
Result< bool >	eigenvalue_already_collected (const ExprPtr &lambda, const Eigenspaces &spaces, ComputationContext &context, const detail::AssumptionFacts &facts)
MatrixEigenvectorResult	eigenvalue_nullspace (const MatrixNode &matrix, const ExprPtr &lambda, ComputationContext &context)

类型定义说明

Eigenspaces

using LMCAS::anonymous_namespace{symbolic_matrix_eigen.cpp}::Eigenspaces = std::vector<std::pair<ExprPtr, std::vector<std::vector<ExprPtr>>>>

在文件 symbolic_matrix_eigen.cpp 第 132 行定义.

函数说明

eigenvalue_already_collected()

Result< bool > LMCAS::anonymous_namespace{symbolic_matrix_eigen.cpp}::eigenvalue_already_collected	(	const ExprPtr &	lambda,
		const Eigenspaces &	spaces,
		ComputationContext &	context,
		const detail::AssumptionFacts &	facts )

在文件 symbolic_matrix_eigen.cpp 第 134 行定义.

                                            {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    constexpr const char* operation = "matrix_eigenspaces";
    for (const auto& space : spaces) {
        if (detail::node(lambda)->equals(*detail::node(space.first))) { return true; }
        auto difference = SymbolicExpr::add(lambda,
            SymbolicExpr::multiply(SymbolicExpr::number(-1), space.first));
        auto proof = detail::classify_exact_zero(difference, context, operation);
        if (!proof) { return Result<bool>::failure(proof.error()); }
        if (proof.value() == detail::ZeroProof::Zero) { return true; }
        auto nonzero = detail::query_nonzero_value(detail::normalize_node(detail::node(difference), transform_budget), facts, Domain::Complex, context);
        if (!nonzero) { return Result<bool>::failure(nonzero.error()); }
        if (nonzero.value() != Tribool::True) {
            return Result<bool>::failure(CasErrc::Inconclusive,
                "eigenvalues cannot be proved pointwise distinct", operation);
        }
    }
    return false;
} catch (const CasError& error) {
    return Result<bool>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<bool>::failure(CasErrc::ResourceLimit, "allocation failed", "matrix_eigenspaces");
} catch (const std::length_error& error) {
    return Result<bool>::failure(CasErrc::ResourceLimit, error.what(), "matrix_eigenspaces");
} catch (const std::exception& error) {
    return Result<bool>::failure(CasErrc::InternalInvariant, error.what(), "matrix_eigenspaces");
}

引用了 LMCAS::detail::classify_exact_zero(), LMCAS::Complex, LMCAS::context, eigenvalue_already_collected(), LMCAS::Result< T >::failure(), LMCAS::Inconclusive, LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::detail::query_nonzero_value(), LMCAS::True , 以及 LMCAS::detail::Zero.

被这些函数引用 eigenvalue_already_collected().

函数调用图:

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

eigenvalue_nullspace()

MatrixEigenvectorResult LMCAS::anonymous_namespace{symbolic_matrix_eigen.cpp}::eigenvalue_nullspace	(	const MatrixNode &	matrix,
		const ExprPtr &	lambda,
		ComputationContext &	context )

在文件 symbolic_matrix_eigen.cpp 第 165 行定义.

                                                            {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    std::vector<std::vector<std::shared_ptr<SymbolicExpr>>> shifted(
        matrix.rows(),
        std::vector<std::shared_ptr<SymbolicExpr>>(matrix.cols()));
    for (std::size_t row = 0; row < matrix.rows(); ++row) {
        for (std::size_t column = 0; column < matrix.cols(); ++column) {
            auto value = detail::make_expression_ptr(matrix.get(row, column));
            shifted[row][column] = row == column
                ? detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(value, SymbolicExpr::multiply(
                      SymbolicExpr::number(-1), lambda))), transform_budget))
                : std::move(value);
        }
    }
    auto nullspace = matrix_nullspace_checked(SymbolicExpr::matrix(shifted), context);
    if (!nullspace) { return MatrixEigenvectorResult::failure(nullspace.error()); }
    if (nullspace.value().empty()) {
        return MatrixEigenvectorResult::failure(CasErrc::Inconclusive,
            "eigenvalue has no proved nonzero nullspace basis", "matrix_eigenspaces");
    }
    return nullspace;
} catch (const CasError& error) {
    return MatrixEigenvectorResult::failure(error);
} catch (const std::bad_alloc&) {
    return MatrixEigenvectorResult::failure(CasErrc::ResourceLimit, "allocation failed", "eigenvalue_nullspace");
} catch (const std::length_error& error) {
    return MatrixEigenvectorResult::failure(CasErrc::ResourceLimit, error.what(), "eigenvalue_nullspace");
} catch (const std::exception& error) {
    return MatrixEigenvectorResult::failure(CasErrc::InternalInvariant, error.what(), "eigenvalue_nullspace");
}

引用了 LMCAS::MatrixNode::cols(), LMCAS::context, eigenvalue_nullspace(), LMCAS::Result< std::vector< std::vector< std::shared_ptr< SymbolicExpr > > > >::failure(), LMCAS::MatrixNode::get(), LMCAS::Inconclusive, LMCAS::detail::make_expression_ptr(), LMCAS::matrix_nullspace_checked(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::MatrixNode::rows() , 以及 LMCAS::value.

被这些函数引用 eigenvalue_nullspace().

函数调用图:

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