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

类
class	SolutionFinalizer

函数
void	append_condition (std::vector< ExprPtr > &conditions, const ExprPtr &condition)
Result< void >	apply_root_representation_policy (ExprPtr &root, const SolveOptions &options)
Result< Tribool >	equality_condition_truth (const ExprPtr &difference, Tribool nonzero, RelationOp op, ComputationContext &context)
ExprPtr	equation_predicate (const ExprPtr &expression)
ExprPtr	equation_residual (const ExprPtr &expression)
Result< Tribool >	logical_condition_truth (const LogicalNode &logic, const FactsQuery &facts, ComputationContext &context)
Tribool	negate_truth (Tribool value)
Result< Tribool >	relational_condition_truth (const ExprPtr &expression, const RelationalNode &relation, const FactsQuery &facts, ComputationContext &context)
Result< Tribool >	solve_condition_truth (const ExprPtr &expression, const FactsQuery &facts, ComputationContext &context)
ExprPtr	substitute_raw (const ExprPtr &expression, const std::string &variable, const ExprPtr &value)

函数说明

append_condition()

void LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::append_condition	(	std::vector< ExprPtr > &	conditions,
		const ExprPtr &	condition )

在文件 solve_solution_finalization.cpp 第 52 行定义.

                                                                                {
    for (const auto& existing : conditions) {
        if (detail::node(existing)->equals(*detail::node(condition))) { return; }
    }
    conditions.push_back(condition);
}

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

被这些函数引用 append_condition(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::SolutionFinalizer::finalize_value(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::SolutionFinalizer::finish() , 以及 LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::SolutionFinalizer::finish_conditions().

函数调用图:

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

apply_root_representation_policy()

Result< void > LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::apply_root_representation_policy	(	ExprPtr &	root,
		const SolveOptions &	options )

在文件 solve_solution_finalization.cpp 第 30 行定义.

                                                                                          {
    if (!options.return_rootof) {
        if (std::dynamic_pointer_cast<const RootOfNode>(detail::node(root))) {
            root = rootof_simplify(root);
        }
        if (!root || detail::contains_node_type<RootOfNode>(detail::node(root))) {
            return Result<void>::failure(CasErrc::Inconclusive,
                "complete roots require RootOf representation", "solve.representation");
        }
    }
    return Result<void>::success();
}

引用了 apply_root_representation_policy(), LMCAS::detail::contains_node_type(), LMCAS::Result< T >::failure(), LMCAS::Inconclusive, LMCAS::detail::node(), LMCAS::options, LMCAS::rootof_simplify() , 以及 LMCAS::Result< T >::success().

被这些函数引用 apply_root_representation_policy() , 以及 LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::SolutionFinalizer::filter_values().

函数调用图:

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

equality_condition_truth()

Result< Tribool > LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::equality_condition_truth	(	const ExprPtr &	difference,
		Tribool	nonzero,
		RelationOp	op,
		ComputationContext &	context )

在文件 solve_solution_finalization.cpp 第 85 行定义.

                                                {
    if (nonzero == Tribool::Unknown) {
        auto residual = check_zero_residual(difference, context);
        if (!residual) { return Result<Tribool>::failure(residual.error()); }
        if (std::holds_alternative<ProvedZeroResidual>(residual.value())) { nonzero = Tribool::False; }
    }
    if (op == RelationOp::NEQ) { return nonzero; }
    return negate_truth(nonzero);
}

引用了 LMCAS::check_zero_residual(), LMCAS::context, equality_condition_truth(), LMCAS::Result< T >::failure(), LMCAS::False, negate_truth(), LMCAS::NEQ, LMCAS::op , 以及 LMCAS::Unknown.

被这些函数引用 equality_condition_truth() , 以及 relational_condition_truth().

函数调用图:

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

equation_predicate()

ExprPtr LMCAS::detail::equation_predicate

(

const ExprPtr &

expression

)

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

                                                            {
    if (std::dynamic_pointer_cast<const RelationalNode>(detail::node(expression))) {
        return expression;
    }
    return detail::make_expression_ptr(detail::make_node<RelationalNode>(
        detail::node(expression), detail::node(SymbolicExpr::number(0)), RelationOp::EQ));
}

被这些函数引用 LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::SolutionFinalizer::finalize_value() , 以及 LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::SolutionFinalizer::finish().

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

equation_residual()

ExprPtr LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::equation_residual

(

const ExprPtr &

expression

)

在文件 solve_solution_finalization.cpp 第 43 行定义.

                                                     {
    if (auto relation = std::dynamic_pointer_cast<const RelationalNode>(detail::node(expression))) {
        return SymbolicExpr::add(detail::make_expression_ptr(relation->left()),
            SymbolicExpr::multiply(SymbolicExpr::number(-1),
                detail::make_expression_ptr(relation->right())));
    }
    return expression;
}

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

被这些函数引用 equation_residual(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::SolutionFinalizer::finalize_value() , 以及 relational_condition_truth().

函数调用图:

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

logical_condition_truth()

Result< Tribool > LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::logical_condition_truth	(	const LogicalNode &	logic,
		const FactsQuery &	facts,
		ComputationContext &	context )

在文件 solve_solution_finalization.cpp 第 67 行定义.

                                                          {
    auto left = solve_condition_truth(detail::make_expression_ptr(logic.left()), facts, context);
    if (!left) { return left; }
    if (logic.op() == LogicalNode::Op::Not) { return negate_truth(left.value()); }
    auto right = solve_condition_truth(detail::make_expression_ptr(logic.right()), facts, context);
    if (!right) { return right; }
    auto l = left.value();
    auto r = right.value();
    if (logic.op() == LogicalNode::Op::Implies) { l = negate_truth(l); }
    if (logic.op() == LogicalNode::Op::And) {
        if (l == Tribool::False || r == Tribool::False) { return Tribool::False; }
        return l == Tribool::True && r == Tribool::True ? Tribool::True : Tribool::Unknown;
    }
    if (l == Tribool::True || r == Tribool::True) { return Tribool::True; }
    return l == Tribool::False && r == Tribool::False ? Tribool::False : Tribool::Unknown;
}

引用了 LMCAS::LogicalNode::And, LMCAS::context, LMCAS::False, LMCAS::LogicalNode::Implies, LMCAS::LogicalNode::left(), logical_condition_truth(), LMCAS::detail::make_expression_ptr(), negate_truth(), LMCAS::LogicalNode::Not, LMCAS::LogicalNode::op(), LMCAS::r, LMCAS::LogicalNode::right(), LMCAS::right, solve_condition_truth(), LMCAS::True , 以及 LMCAS::Unknown.

被这些函数引用 logical_condition_truth() , 以及 solve_condition_truth().

函数调用图:

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

negate_truth()

Tribool LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::negate_truth

(

Tribool

value

)

在文件 solve_solution_finalization.cpp 第 59 行定义.

                                    {
    return value == Tribool::True ? Tribool::False :
        value == Tribool::False ? Tribool::True : Tribool::Unknown;
}

引用了 LMCAS::False, negate_truth(), LMCAS::True, LMCAS::Unknown , 以及 LMCAS::value.

被这些函数引用 equality_condition_truth(), logical_condition_truth() , 以及 negate_truth().

函数调用图:

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

relational_condition_truth()

Result< Tribool > LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::relational_condition_truth	(	const ExprPtr &	expression,
		const RelationalNode &	relation,
		const FactsQuery &	facts,
		ComputationContext &	context )

在文件 solve_solution_finalization.cpp 第 96 行定义.

                                                                                              {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto defined = detail::query_definedness(detail::node(expression), facts, Domain::Complex, context);
    if (!defined) { return Result<Tribool>::failure(defined.error()); }
    if (defined.value() != Tribool::True) { return Tribool::Unknown; }
    auto difference = detail::make_expression_ptr(detail::normalize_node(detail::node(equation_residual(expression)), transform_budget));
    auto nz = detail::query_nonzero_value(detail::node(difference), facts, Domain::Complex, context);
    if (!nz) { return nz; }
    if (relation.op() == RelationOp::EQ || relation.op() == RelationOp::NEQ) {
        return equality_condition_truth(difference, nz.value(), relation.op(), context);
    }
    if (relation.op() == RelationOp::LT || relation.op() == RelationOp::LEQ) {
        difference = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(SymbolicExpr::number(-1), difference)), transform_budget));
    }
    if (relation.op() == RelationOp::GEQ || relation.op() == RelationOp::LEQ) {
        return detail::query_nonnegative_value(detail::node(difference), facts, context);
    }
    return detail::query_positive_value(detail::node(difference), facts, context);
} catch (const CasError& error) {
    return Result<Tribool>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<Tribool>::failure(CasErrc::ResourceLimit, "allocation failed", "relational_condition_truth");
} catch (const std::length_error& error) {
    return Result<Tribool>::failure(CasErrc::ResourceLimit, error.what(), "relational_condition_truth");
} catch (const std::exception& error) {
    return Result<Tribool>::failure(CasErrc::InternalInvariant, error.what(), "relational_condition_truth");
}

引用了 LMCAS::Complex, LMCAS::context, LMCAS::EQ, equality_condition_truth(), equation_residual(), LMCAS::Result< T >::failure(), LMCAS::GEQ, LMCAS::LEQ, LMCAS::LT, LMCAS::detail::make_expression_ptr(), LMCAS::NEQ, LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::detail::query_definedness(), LMCAS::detail::query_nonnegative_value(), LMCAS::detail::query_nonzero_value(), LMCAS::detail::query_positive_value(), LMCAS::relation(), relational_condition_truth(), LMCAS::True , 以及 LMCAS::Unknown.

被这些函数引用 relational_condition_truth() , 以及 solve_condition_truth().

函数调用图:

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

solve_condition_truth()

Result< Tribool > LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::solve_condition_truth	(	const ExprPtr &	expression,
		const FactsQuery &	facts,
		ComputationContext &	context )

在文件 solve_solution_finalization.cpp 第 125 行定义.

                                                          {
    auto step = context.consume_steps(1, "solve.conditions");
    if (!step) { return Result<Tribool>::failure(step.error()); }
    const auto node = detail::node(expression);
    if (auto logic = std::dynamic_pointer_cast<const LogicalNode>(node)) {
        return logical_condition_truth(*logic, facts, context);
    }
    auto relation = std::dynamic_pointer_cast<const RelationalNode>(node);
    if (!relation) { return Tribool::Unknown; }
    return relational_condition_truth(expression, *relation, facts, context);
}

引用了 LMCAS::context, LMCAS::Result< T >::failure(), logical_condition_truth(), LMCAS::detail::node(), LMCAS::relation(), relational_condition_truth(), solve_condition_truth() , 以及 LMCAS::Unknown.

被这些函数引用 LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::SolutionFinalizer::finish_conditions(), logical_condition_truth() , 以及 solve_condition_truth().

函数调用图:

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

substitute_raw()

ExprPtr LMCAS::detail::substitute_raw	(	const ExprPtr &	expression,
		const std::string &	variable,
		const ExprPtr &	value )

在文件 solve_solution_finalization.cpp 第 10 行定义.

                                                     {
    return detail::make_expression_ptr(substitute_free(
        detail::node(expression), variable, detail::node(value)));
}

被这些函数引用 LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::SolutionFinalizer::finalize_value().

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