LMCAS::InferenceEngine::Impl结构体 参考

#include </home/runner/work/docs/docs/LMCAS/src/internal/inference_engine_impl.hpp>

LMCAS::InferenceEngine::Impl 的协作图:

Public 成员函数
	Impl (const AssumptionContext &context)
InferenceTriboolResult	absolute_domain (const InferenceEngine &engine, const SymbolicExpr &arg_expr, Domain target, ComputationContext &context) const
InferenceTriboolResult	absolute_sign (const InferenceEngine &engine, const SymbolicExpr &arg_expr, Sign target, ComputationContext &context) const
InferenceTriboolResult	accumulate_product_sign (const InferenceEngine &engine, const std::shared_ptr< const SymbolicNode > &operand, std::uint8_t &possible, ComputationContext &context) const
Result< void >	accumulate_sum_relation_sign (const std::shared_ptr< const SymbolicNode > &operand, const SymbolicExpr &zero_expr, bool &all_gt_zero, bool &all_geq_zero, ComputationContext &context) const
Result< void >	add_deduced (InferenceEngine &engine, const SymbolicExpr &new_lhs, const SymbolicExpr &new_rhs, RelationStore &store, PropertyStore &prop_store, int depth) const
InferenceTriboolResult	arctangent_domain (const InferenceEngine &engine, const SymbolicExpr &arg_expr, Domain target, ComputationContext &context) const
InferenceTriboolResult	composite_integer (const InferenceEngine &engine, const SymbolicExpr &expr, ComputationContext &context) const
InferenceTriboolResult	composite_negative (const InferenceEngine &engine, const SymbolicExpr &expr, ComputationContext &context) const
InferenceTriboolResult	composite_nonnegative (const InferenceEngine &engine, const SymbolicExpr &expr, ComputationContext &context) const
InferenceTriboolResult	composite_nonpositive (const InferenceEngine &engine, const SymbolicExpr &expr, ComputationContext &context) const
InferenceTriboolResult	composite_nonzero (const InferenceEngine &engine, const SymbolicExpr &expr, ComputationContext &context) const
InferenceTriboolResult	composite_positive (const InferenceEngine &engine, const SymbolicExpr &expr, ComputationContext &context) const
InferenceTriboolResult	composite_real (const InferenceEngine &engine, const SymbolicExpr &expr, ComputationContext &context) const
Result< void >	deduce_function_relation (InferenceEngine &engine, const VariableNode &lhs, const VariableNode &rhs, FunctionNode::FuncType type, RelationStore &store, PropertyStore &prop_store, int depth) const
Result< void >	deduce_power_relations (InferenceEngine &engine, const VariableNode &lhs, const VariableNode &rhs, RelationStore &store, PropertyStore &prop_store, int depth) const
InferenceTriboolResult	even_power_sign (const InferenceEngine &engine, const SymbolicExpr &base_expr, const NumberNode &exponent, Sign target, ComputationContext &context) const
InferenceTriboolResult	exponential_domain (const InferenceEngine &engine, const SymbolicExpr &arg_expr, Domain target, ComputationContext &context) const
InferenceTriboolResult	exponential_sign (const InferenceEngine &engine, const SymbolicExpr &arg_expr, Sign target, ComputationContext &context) const
InferenceTriboolResult	function_domain (const InferenceEngine &engine, FunctionNode::FuncType type, const SymbolicExpr &argument, Domain target, ComputationContext &context) const
InferenceTriboolResult	function_sign (const InferenceEngine &engine, FunctionNode::FuncType type, const SymbolicExpr &argument, Sign target, ComputationContext &context) const
InferenceTriboolResult	integer_power_sign (const InferenceEngine &engine, const SymbolicExpr &base_expr, const NumberNode &exponent, Sign target, ComputationContext &context) const
InferenceTriboolResult	logarithm_domain (const InferenceEngine &engine, const SymbolicExpr &arg_expr, Domain target, ComputationContext &context) const
InferenceTriboolResult	logarithm_sign (const InferenceEngine &engine, const SymbolicExpr &arg_expr, Sign target, ComputationContext &context) const
InferenceTriboolResult	multiply_domain (const InferenceEngine &engine, const MultiplyNode &node, Domain target, ComputationContext &context) const
InferenceTriboolResult	nonzero_power_sign (const InferenceEngine &engine, const SymbolicExpr &base_expr, const NumberNode &exponent, Sign target, ComputationContext &context) const
bool	operand_sign (const std::shared_ptr< const SymbolicNode > &operand, Sign target, ComputationContext &context) const
InferenceTriboolResult	positive_integer_power_sign (const InferenceEngine &engine, const SymbolicExpr &base_expr, const NumberNode &exponent, Sign target, ComputationContext &context) const
InferenceTriboolResult	positive_power_sign (const InferenceEngine &engine, const SymbolicExpr &base_expr, const SymbolicExpr &exp_expr, Sign target, ComputationContext &context) const
InferenceTriboolResult	positive_relation_chain (const SymbolicExpr &expr, const SymbolicExpr &zero_expr, ComputationContext &context) const
InferenceTriboolResult	product_relation_sign (const MultiplyNode &mul, const SymbolicExpr &zero_expr, Sign target, ComputationContext &context) const
InferenceTriboolResult	product_sign (const InferenceEngine &engine, const MultiplyNode &node, Sign target, ComputationContext &context) const
InferenceTriboolResult	query_natural (const SymbolicExpr &expr, ComputationContext &context) const
InferenceTriboolResult	query_rational (const InferenceEngine &engine, const SymbolicExpr &expr, ComputationContext &context) const
InferenceTriboolResult	query_zero (const InferenceEngine &engine, const SymbolicExpr &expr, ComputationContext &context) const
InferenceTriboolResult	quotient_sign (const InferenceEngine &engine, const SymbolicExpr &num_expr, const SymbolicExpr &den_expr, Sign target, ComputationContext &context) const
InferenceTriboolResult	real_or_integer (const InferenceEngine &engine, const SymbolicExpr &arg_expr, ComputationContext &context) const
Result< bool >	relation_rhs_nonnegative (const Relation &rel, const SymbolicExpr &zero_expr, ComputationContext &context) const
InferenceTriboolResult	square_root_domain (const InferenceEngine &engine, const SymbolicExpr &arg_expr, Domain target, ComputationContext &context) const
InferenceTriboolResult	square_root_sign (const InferenceEngine &engine, const SymbolicExpr &arg_expr, Sign target, ComputationContext &context) const
InferenceTriboolResult	subtraction_sign (const InferenceEngine &engine, const SymbolicExpr &minuend_expr, const SymbolicExpr &subtrahend_expr, Sign target, ComputationContext &context) const
InferenceTriboolResult	sum_nonzero (const InferenceEngine &engine, const AddNode &add, ComputationContext &context) const
InferenceTriboolResult	sum_relation_sign (const AddNode &add, const SymbolicExpr &zero_expr, Sign target, ComputationContext &context) const
InferenceTriboolResult	sum_sign (const InferenceEngine &engine, const AddNode &node, Sign target, ComputationContext &context) const
InferenceTriboolResult	trigonometric_sign (const InferenceEngine &engine, const SymbolicExpr &arg_expr, ComputationContext &context) const
InferenceTriboolResult	weak_subtraction_sign (const InferenceEngine &engine, const SymbolicExpr &minuend_expr, const SymbolicExpr &subtrahend_expr, Sign target, ComputationContext &context) const
InferenceTriboolResult	zero_power_sign (const InferenceEngine &engine, const SymbolicExpr &base_expr, const NumberNode *exp_num, Sign target, ComputationContext &context) const

静态 Public 成员函数
static void	collect_node_exponent (const std::shared_ptr< const SymbolicNode > &node, const std::string &lhs_name, const std::string &rhs_name, std::unordered_set< int > &exponents)
static std::vector< int >	collect_power_exponents (const RelationStore &store, const std::string &lhs_name, const std::string &rhs_name)
static Monotonicity	function_monotonicity (const FunctionNode &func, const std::string &var, const Interval &interval)
static bool	has_negated_operand (const AddNode &node, ComputationContext &context)
static InferenceTriboolResult	integral_power_domain (const InferenceEngine &engine, const SymbolicExpr &base, const NumberNode &exponent, Domain target, ComputationContext &context)
static Tribool	known_sign (int value, Sign target)
static Monotonicity	logarithm_monotonicity (const Interval &interval)
static Tribool	natural_number (const NumberNode &num)
static Tribool	nonnegative_sign (Sign target)
static Tribool	number_integer (const NumberNode &num)
static Tribool	number_negative (const NumberNode &num)
static Tribool	number_nonnegative (const NumberNode &num)
static Tribool	number_nonpositive (const NumberNode &num)
static Tribool	number_nonzero (const NumberNode &num)
static Tribool	number_positive (const NumberNode &num)
static InferenceTriboolResult	product_parity_sign (std::uint8_t possible, Sign target)
static InferenceTriboolResult	real_definedness (const InferenceEngine &engine, const SymbolicNode &node, ComputationContext &context)
static std::optional< int >	small_positive_exponent (const std::shared_ptr< const NumberNode > &number)
static std::shared_ptr< const SymbolicNode >	subtrahend (const std::shared_ptr< const SymbolicNode > &operand, ComputationContext &context)

Public 属性
const AssumptionContext &	ctx
int	current_depth = 0
int	max_depth
std::unordered_set< const SymbolicNode * >	visited

详细描述

在文件 inference_engine_impl.hpp 第 93 行定义.

构造及析构函数说明

Impl()

LMCAS::InferenceEngine::Impl::Impl ( const AssumptionContext & context )

inlineexplicit

在文件 inference_engine_impl.hpp 第 94 行定义.

        : ctx(context), max_depth(context.get_max_query_depth()) {}

引用了 LMCAS::context, ctx , 以及 max_depth.

成员函数说明

absolute_domain()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::absolute_domain	(	const InferenceEngine &	engine,
		const SymbolicExpr &	arg_expr,
		Domain	target,
		ComputationContext &	context ) const

在文件 inference_engine_functions.cpp 第 187 行定义.

                                                      {
    if (target == Domain::Real) {
        return real_or_integer(engine, arg_expr, context);
    }
    if (target == Domain::Integer) {
        auto integer = engine.query_integer_checked(arg_expr, context);
        if (!integer) {
            return integer;
        }
        if (integer.value() == Tribool::True) {
            return Tribool::True;
        }
    }
    return Tribool::Unknown;
}

引用了 LMCAS::context, LMCAS::Integer, LMCAS::integer, LMCAS::Real, real_or_integer(), LMCAS::target, LMCAS::True, LMCAS::Unknown , 以及 LMCAS::Result< T >::value().

被这些函数引用 function_domain().

函数调用图:

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

absolute_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::absolute_sign	(	const InferenceEngine &	engine,
		const SymbolicExpr &	arg_expr,
		Sign	target,
		ComputationContext &	context ) const

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

                                                    {
    auto arg_real_result = engine.query_domain_of_checked(arg_expr, Domain::Real, context);
    if (!arg_real_result) {
        return arg_real_result;
    }
    const Tribool arg_real = arg_real_result.value();
    if (arg_real != Tribool::True) {
        return InferenceTriboolResult::success(Tribool::Unknown);
    }
 
    auto arg_pos_result = engine.query_sign_of_checked(arg_expr, Sign::Positive, context);
    if (!arg_pos_result) {
        return arg_pos_result;
    }
    const Tribool arg_pos = arg_pos_result.value();
    auto arg_neg_result = engine.query_sign_of_checked(arg_expr, Sign::Negative, context);
    if (!arg_neg_result) {
        return arg_neg_result;
    }
    const Tribool arg_neg = arg_neg_result.value();
    auto arg_nz_result = engine.query_sign_of_checked(arg_expr, Sign::NonZero, context);
    if (!arg_nz_result) {
        return arg_nz_result;
    }
    const Tribool arg_nz = arg_nz_result.value();
    bool abs_is_positive = (arg_pos == Tribool::True) ||
                           (arg_neg == Tribool::True) ||
                           (arg_nz == Tribool::True);
 
    if (abs_is_positive) {
        return known_sign(1, target);
    }
    return nonnegative_sign(target);
}

引用了 LMCAS::context, known_sign(), LMCAS::Negative, nonnegative_sign(), LMCAS::NonZero, LMCAS::Positive, LMCAS::Real, LMCAS::Result< Tribool >::success(), LMCAS::target, LMCAS::True , 以及 LMCAS::Unknown.

被这些函数引用 function_sign().

函数调用图:

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

accumulate_product_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::accumulate_product_sign	(	const InferenceEngine &	engine,
		const std::shared_ptr< const SymbolicNode > &	operand,
		std::uint8_t &	possible,
		ComputationContext &	context ) const

在文件 inference_engine_product.cpp 第 38 行定义.

                                                             {
    const auto expression = detail::expression_from_node(operand);
    std::uint8_t operand_signs = all_signs;
    for (Sign sign : {Sign::Positive, Sign::Negative, Sign::Zero,
                      Sign::NonNegative, Sign::NonPositive, Sign::NonZero}) {
        auto fact = engine.query_sign_of_checked(expression, sign, context);
        if (!fact) return fact;
        if (fact.value() == Tribool::True) operand_signs &= sign_set(sign);
    }
    possible = multiply_sign_sets(possible, operand_signs);
    return Tribool::True;
}

引用了 LMCAS::context, LMCAS::detail::expression_from_node(), LMCAS::Negative, LMCAS::NonNegative, LMCAS::NonPositive, LMCAS::NonZero, LMCAS::Positive, LMCAS::True , 以及 LMCAS::Zero.

被这些函数引用 product_sign() , 以及 quotient_sign().

函数调用图:

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

accumulate_sum_relation_sign()

Result< void > LMCAS::InferenceEngine::Impl::accumulate_sum_relation_sign	(	const std::shared_ptr< const SymbolicNode > &	operand,
		const SymbolicExpr &	zero_expr,
		bool &	all_gt_zero,
		bool &	all_geq_zero,
		ComputationContext &	context ) const

在文件 inference_engine_relations.cpp 第 25 行定义.

                                                                              {
    auto step = context.consume_steps(1, "inference.relations");
    if (!step) {
        throw step.error();
    }
    auto op_expr = detail::expression_from_node(operand);
    auto gt = ctx.has_relation_checked(
        op_expr, zero_expr, RelationalNode::Op::GT, context);
    if (!gt) {
        return Result<void>::failure(gt.error());
    }
    auto geq = ctx.has_relation_checked(
        op_expr, zero_expr, RelationalNode::Op::GEQ, context);
    if (!geq) {
        return Result<void>::failure(geq.error());
    }
    bool op_gt = gt.value();
    bool op_geq = geq.value();
    if (!op_gt) {
        op_gt = operand_sign(operand, Sign::Positive, context);
    }
    if (!op_geq && !op_gt) {
        op_geq = operand_sign(operand, Sign::NonNegative, context);
    }
    if (!op_gt) {
        all_gt_zero = false;
    }
    if (!op_gt && !op_geq) {
        all_geq_zero = false;
    }
    return Result<void>::success();
}

引用了 LMCAS::context, ctx, LMCAS::Result< T >::error(), LMCAS::detail::expression_from_node(), LMCAS::Result< T >::failure(), LMCAS::gt(), LMCAS::NonNegative, operand_sign(), LMCAS::Positive, LMCAS::Result< T >::success() , 以及 LMCAS::Result< T >::value().

被这些函数引用 sum_relation_sign().

函数调用图:

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

add_deduced()

Result< void > LMCAS::InferenceEngine::Impl::add_deduced	(	InferenceEngine &	engine,
		const SymbolicExpr &	new_lhs,
		const SymbolicExpr &	new_rhs,
		RelationStore &	store,
		PropertyStore &	prop_store,
		int	depth ) const

在文件 inference_engine_monotonicity.cpp 第 105 行定义.

                     {
    if (store.has_relation(new_lhs, new_rhs, RelationalNode::Op::GT)) {
        return Result<void>::success();
    }
 
    auto inserted = store.add_relation_checked(
        new_lhs, new_rhs, RelationalNode::Op::GT, prop_store);
    if (!inserted.has_value()) {
        return Result<void>::failure(inserted.error());
    }
 
    Relation new_rel{new_lhs, new_rhs, RelationalNode::Op::GT};
    return engine.apply_monotonicity_rules_checked(new_rel, store, prop_store, depth + 1);
}

引用了 LMCAS::depth, LMCAS::Result< T >::failure() , 以及 LMCAS::Result< T >::success().

被这些函数引用 deduce_function_relation() , 以及 deduce_power_relations().

函数调用图:

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

arctangent_domain()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::arctangent_domain	(	const InferenceEngine &	engine,
		const SymbolicExpr &	arg_expr,
		Domain	target,
		ComputationContext &	context ) const

在文件 inference_engine_functions.cpp 第 234 行定义.

                                                      {
    if (target == Domain::Real) {
        auto arg_real_result = engine.query_real_checked(arg_expr, context);
        if (!arg_real_result) {
            return arg_real_result;
        }
        const Tribool arg_real = arg_real_result.value();
        if (arg_real == Tribool::True) {
            return InferenceTriboolResult::success(Tribool::True);
        }
    }
    return InferenceTriboolResult::success(Tribool::Unknown);
}

引用了 LMCAS::context, LMCAS::Real, LMCAS::Result< Tribool >::success(), LMCAS::target, LMCAS::True , 以及 LMCAS::Unknown.

被这些函数引用 function_domain().

函数调用图:

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

collect_node_exponent()

void LMCAS::InferenceEngine::Impl::collect_node_exponent ( const std::shared_ptr< const SymbolicNode > & node, const std::string & lhs_name, const std::string & rhs_name, std::unordered_set< int > & exponents )

static

在文件 inference_engine_monotonicity.cpp 第 62 行定义.

                                      {
    if (!node) {
        return;
    }
    auto pow_node = std::dynamic_pointer_cast<const PowerNode>(node);
    if (!pow_node) {
        return;
    }
 
    auto base_var = std::dynamic_pointer_cast<const VariableNode>(pow_node->base());
    if (!base_var || base_var->is_constant()) {
        return;
    }
    if (base_var->name() != lhs_name && base_var->name() != rhs_name) {
        return;
    }
 
    auto exp_num = std::dynamic_pointer_cast<const NumberNode>(pow_node->exponent());
    if (!exp_num) {
        return;
    }
    const auto exponent = small_positive_exponent(exp_num);
    if (exponent) {
        exponents.insert(*exponent);
    }
}

引用了 LMCAS::exponent , 以及 small_positive_exponent().

被这些函数引用 collect_power_exponents().

函数调用图:

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

collect_power_exponents()

std::vector< int > LMCAS::InferenceEngine::Impl::collect_power_exponents ( const RelationStore & store, const std::string & lhs_name, const std::string & rhs_name )

static

在文件 inference_engine_monotonicity.cpp 第 93 行定义.

                               {
    std::unordered_set<int> exponents;
    for (const auto& rel : store.get_relations()) {
        collect_node_exponent(detail::node(rel.lhs), lhs_name, rhs_name, exponents);
        collect_node_exponent(detail::node(rel.rhs), lhs_name, rhs_name, exponents);
    }
    return std::vector<int>(exponents.begin(), exponents.end());
}

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

被这些函数引用 deduce_power_relations().

函数调用图:

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

composite_integer()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::composite_integer	(	const InferenceEngine &	engine,
		const SymbolicExpr &	expr,
		ComputationContext &	context ) const

在文件 inference_engine_core.cpp 第 197 行定义.

                                                                 {
    if (auto add = std::dynamic_pointer_cast<const AddNode>(LMCAS::detail::node(expr))) {
        return engine.infer_add_domain_checked(*add, Domain::Integer, context);
    }
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(LMCAS::detail::node(expr))) {
        return engine.infer_multiply_domain_checked(*mul, Domain::Integer, context);
    }
    if (auto pow = std::dynamic_pointer_cast<const PowerNode>(LMCAS::detail::node(expr))) {
        return engine.infer_power_domain_checked(*pow, Domain::Integer, context);
    }
    if (auto func = std::dynamic_pointer_cast<const FunctionNode>(LMCAS::detail::node(expr))) {
        return engine.infer_function_domain_checked(*func, Domain::Integer, context);
    }
    return Tribool::Unknown;
}

引用了 LMCAS::add(), LMCAS::context, LMCAS::Integer, LMCAS::mul(), LMCAS::detail::node(), LMCAS::pow() , 以及 LMCAS::Unknown.

函数调用图:

composite_negative()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::composite_negative	(	const InferenceEngine &	engine,
		const SymbolicExpr &	expr,
		ComputationContext &	context ) const

在文件 inference_engine_core.cpp 第 109 行定义.

                                                                 {
    if (auto add = std::dynamic_pointer_cast<const AddNode>(LMCAS::detail::node(expr))) {
        return engine.infer_add_sign_checked(*add, Sign::Negative, context);
    }
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(LMCAS::detail::node(expr))) {
        return engine.infer_multiply_sign_checked(*mul, Sign::Negative, context);
    }
    if (auto pow = std::dynamic_pointer_cast<const PowerNode>(LMCAS::detail::node(expr))) {
        return engine.infer_power_property_checked(*pow, Sign::Negative, context);
    }
    if (auto func = std::dynamic_pointer_cast<const FunctionNode>(LMCAS::detail::node(expr))) {
        return engine.infer_function_property_checked(*func, Sign::Negative, context);
    }
    return Tribool::Unknown;
}

引用了 LMCAS::add(), LMCAS::context, LMCAS::mul(), LMCAS::Negative, LMCAS::detail::node(), LMCAS::pow() , 以及 LMCAS::Unknown.

函数调用图:

composite_nonnegative()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::composite_nonnegative	(	const InferenceEngine &	engine,
		const SymbolicExpr &	expr,
		ComputationContext &	context ) const

在文件 inference_engine_core.cpp 第 127 行定义.

                                                                 {
    if (auto add = std::dynamic_pointer_cast<const AddNode>(LMCAS::detail::node(expr))) {
        auto result =
            engine.infer_add_sign_checked(*add, Sign::NonNegative, context);
        if (!result) {
            return result;
        }
        if (result.value() != Tribool::Unknown) {
            return result;
        }
        return engine.infer_sign_from_relations_checked(expr, Sign::NonNegative, context);
    }
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(LMCAS::detail::node(expr))) {
        auto result =
            engine.infer_multiply_sign_checked(*mul, Sign::NonNegative, context);
        if (!result) {
            return result;
        }
        if (result.value() != Tribool::Unknown) {
            return result;
        }
        return engine.infer_sign_from_relations_checked(expr, Sign::NonNegative, context);
    }
    if (auto pow = std::dynamic_pointer_cast<const PowerNode>(LMCAS::detail::node(expr))) {
        return engine.infer_power_property_checked(*pow, Sign::NonNegative, context);
    }
    if (auto func = std::dynamic_pointer_cast<const FunctionNode>(LMCAS::detail::node(expr))) {
        return engine.infer_function_property_checked(*func, Sign::NonNegative, context);
    }
    return Tribool::Unknown;
}

引用了 LMCAS::add(), LMCAS::context, LMCAS::mul(), LMCAS::detail::node(), LMCAS::NonNegative, LMCAS::pow() , 以及 LMCAS::Unknown.

函数调用图:

composite_nonpositive()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::composite_nonpositive	(	const InferenceEngine &	engine,
		const SymbolicExpr &	expr,
		ComputationContext &	context ) const

在文件 inference_engine_core.cpp 第 161 行定义.

                                                                 {
    if (auto add = std::dynamic_pointer_cast<const AddNode>(LMCAS::detail::node(expr))) {
        return engine.infer_add_sign_checked(*add, Sign::NonPositive, context);
    }
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(LMCAS::detail::node(expr))) {
        return engine.infer_multiply_sign_checked(*mul, Sign::NonPositive, context);
    }
    if (auto pow = std::dynamic_pointer_cast<const PowerNode>(LMCAS::detail::node(expr))) {
        return engine.infer_power_property_checked(*pow, Sign::NonPositive, context);
    }
    if (auto func = std::dynamic_pointer_cast<const FunctionNode>(LMCAS::detail::node(expr))) {
        return engine.infer_function_property_checked(*func, Sign::NonPositive, context);
    }
    return Tribool::Unknown;
}

引用了 LMCAS::add(), LMCAS::context, LMCAS::mul(), LMCAS::detail::node(), LMCAS::NonPositive, LMCAS::pow() , 以及 LMCAS::Unknown.

函数调用图:

composite_nonzero()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::composite_nonzero	(	const InferenceEngine &	engine,
		const SymbolicExpr &	expr,
		ComputationContext &	context ) const

在文件 inference_engine_core.cpp 第 237 行定义.

                                                                 {
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(LMCAS::detail::node(expr))) {
        return engine.infer_multiply_sign_checked(*mul, Sign::NonZero, context);
    }
    if (auto pow = std::dynamic_pointer_cast<const PowerNode>(LMCAS::detail::node(expr))) {
        return engine.infer_power_property_checked(*pow, Sign::NonZero, context);
    }
    if (auto func = std::dynamic_pointer_cast<const FunctionNode>(LMCAS::detail::node(expr))) {
        return engine.infer_function_property_checked(*func, Sign::NonZero, context);
    }
    if (auto add = std::dynamic_pointer_cast<const AddNode>(LMCAS::detail::node(expr))) {
        return sum_nonzero(engine, *add, context);
    }
    return Tribool::Unknown;
}

引用了 LMCAS::add(), LMCAS::context, LMCAS::mul(), LMCAS::detail::node(), LMCAS::NonZero, LMCAS::pow(), sum_nonzero() , 以及 LMCAS::Unknown.

函数调用图:

composite_positive()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::composite_positive	(	const InferenceEngine &	engine,
		const SymbolicExpr &	expr,
		ComputationContext &	context ) const

在文件 inference_engine_core.cpp 第 75 行定义.

                                                                 {
    if (auto add = std::dynamic_pointer_cast<const AddNode>(LMCAS::detail::node(expr))) {
        auto result =
            engine.infer_add_sign_checked(*add, Sign::Positive, context);
        if (!result) {
            return result;
        }
        if (result.value() != Tribool::Unknown) {
            return result;
        }
        return engine.infer_sign_from_relations_checked(expr, Sign::Positive, context);
    }
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(LMCAS::detail::node(expr))) {
        auto result =
            engine.infer_multiply_sign_checked(*mul, Sign::Positive, context);
        if (!result) {
            return result;
        }
        if (result.value() != Tribool::Unknown) {
            return result;
        }
        return engine.infer_sign_from_relations_checked(expr, Sign::Positive, context);
    }
    if (auto pow = std::dynamic_pointer_cast<const PowerNode>(LMCAS::detail::node(expr))) {
        return engine.infer_power_property_checked(*pow, Sign::Positive, context);
    }
    if (auto func = std::dynamic_pointer_cast<const FunctionNode>(LMCAS::detail::node(expr))) {
        return engine.infer_function_property_checked(*func, Sign::Positive, context);
    }
    return engine.infer_sign_from_relations_checked(expr, Sign::Positive, context);
}

引用了 LMCAS::add(), LMCAS::context, LMCAS::mul(), LMCAS::detail::node(), LMCAS::Positive, LMCAS::pow() , 以及 LMCAS::Unknown.

函数调用图:

composite_real()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::composite_real	(	const InferenceEngine &	engine,
		const SymbolicExpr &	expr,
		ComputationContext &	context ) const

在文件 inference_engine_core.cpp 第 179 行定义.

                                                                 {
    if (auto add = std::dynamic_pointer_cast<const AddNode>(LMCAS::detail::node(expr))) {
        return engine.infer_add_domain_checked(*add, Domain::Real, context);
    }
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(LMCAS::detail::node(expr))) {
        return engine.infer_multiply_domain_checked(*mul, Domain::Real, context);
    }
    if (auto pow = std::dynamic_pointer_cast<const PowerNode>(LMCAS::detail::node(expr))) {
        return engine.infer_power_domain_checked(*pow, Domain::Real, context);
    }
    if (auto func = std::dynamic_pointer_cast<const FunctionNode>(LMCAS::detail::node(expr))) {
        return engine.infer_function_domain_checked(*func, Domain::Real, context);
    }
    return Tribool::Unknown;
}

引用了 LMCAS::add(), LMCAS::context, LMCAS::mul(), LMCAS::detail::node(), LMCAS::pow(), LMCAS::Real , 以及 LMCAS::Unknown.

函数调用图:

deduce_function_relation()

Result< void > LMCAS::InferenceEngine::Impl::deduce_function_relation	(	InferenceEngine &	engine,
		const VariableNode &	lhs,
		const VariableNode &	rhs,
		FunctionNode::FuncType	type,
		RelationStore &	store,
		PropertyStore &	prop_store,
		int	depth ) const

在文件 inference_engine_monotonicity.cpp 第 126 行定义.

                     {
    auto lhs_node = detail::make_node<FunctionNode>(
        type, std::vector<std::shared_ptr<const SymbolicNode>>{lhs.clone()});
    auto rhs_node = detail::make_node<FunctionNode>(
        type, std::vector<std::shared_ptr<const SymbolicNode>>{rhs.clone()});
    auto lhs_expr = detail::expression_from_node(lhs_node);
    auto rhs_expr = detail::expression_from_node(rhs_node);
    return add_deduced(engine, lhs_expr, rhs_expr, store, prop_store, depth);
}

引用了 add_deduced(), LMCAS::VariableNode::clone(), LMCAS::depth, LMCAS::detail::expression_from_node(), LMCAS::detail::make_node() , 以及 LMCAS::rhs.

函数调用图:

deduce_power_relations()

Result< void > LMCAS::InferenceEngine::Impl::deduce_power_relations	(	InferenceEngine &	engine,
		const VariableNode &	lhs,
		const VariableNode &	rhs,
		RelationStore &	store,
		PropertyStore &	prop_store,
		int	depth ) const

在文件 inference_engine_monotonicity.cpp 第 143 行定义.

                     {
    std::vector<int> exponents = collect_power_exponents(store, lhs.name(), rhs.name());
 
    for (int n : exponents) {
        auto exp_node = LMCAS::detail::make_node<NumberNode>(BigInt(n));
        auto pow_x_node = LMCAS::detail::make_node<PowerNode>(lhs.clone(), exp_node->clone());
        auto pow_y_node = LMCAS::detail::make_node<PowerNode>(rhs.clone(), exp_node->clone());
 
        auto pow_x = LMCAS::detail::expression_from_node(pow_x_node);
        auto pow_y = LMCAS::detail::expression_from_node(pow_y_node);
        auto deduced = add_deduced(engine, pow_x, pow_y, store, prop_store, depth);
        if (!deduced.has_value()) {
            return deduced;
        }
    }
    return Result<void>::success();
}

引用了 add_deduced(), LMCAS::VariableNode::clone(), collect_power_exponents(), LMCAS::depth, LMCAS::detail::expression_from_node(), LMCAS::detail::make_node(), LMCAS::VariableNode::name(), LMCAS::rhs , 以及 LMCAS::Result< T >::success().

函数调用图:

even_power_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::even_power_sign	(	const InferenceEngine &	engine,
		const SymbolicExpr &	base_expr,
		const NumberNode &	exponent,
		Sign	target,
		ComputationContext &	context ) const

在文件 inference_engine_power.cpp 第 47 行定义.

                                                    {
    if (!is_even_integer_number(exponent)) {
        return Tribool::Unknown;
    }
    const detail::AssumptionFacts facts(engine);
    auto base = detail::query_real_value(detail::node(base_expr), facts, context);
    if (!base) {
        return base;
    }
    if (base.value() == Tribool::True) {
        auto nonzero = detail::query_nonzero_value(detail::node(base_expr), facts, Domain::Real, context);
        if (!nonzero) return nonzero;
        if (nonzero.value() == Tribool::True) return known_sign(1, target);
        if (nonzero.value() == Tribool::False) return known_sign(0, target);
        return nonnegative_sign(target);
    }
    return Tribool::Unknown;
}

引用了 LMCAS::context, LMCAS::exponent, LMCAS::False, LMCAS::is_even_integer_number(), known_sign(), LMCAS::detail::node(), nonnegative_sign(), LMCAS::detail::query_nonzero_value(), LMCAS::detail::query_real_value(), LMCAS::Real, LMCAS::target, LMCAS::True , 以及 LMCAS::Unknown.

被这些函数引用 integer_power_sign().

函数调用图:

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

exponential_domain()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::exponential_domain	(	const InferenceEngine &	engine,
		const SymbolicExpr &	arg_expr,
		Domain	target,
		ComputationContext &	context ) const

在文件 inference_engine_functions.cpp 第 174 行定义.

                                                      {
    if (target != Domain::Real) {
        return Tribool::Unknown;
    }
    const detail::AssumptionFacts facts(engine);
    auto real = detail::query_real_value(detail::node(arg_expr), facts, context);
    if (!real) return real;
    return real.value() == Tribool::True ? Tribool::True : Tribool::Unknown;
}

引用了 LMCAS::context, LMCAS::detail::node(), LMCAS::detail::query_real_value(), LMCAS::Real, LMCAS::real(), LMCAS::target, LMCAS::True, LMCAS::Unknown , 以及 LMCAS::Result< T >::value().

被这些函数引用 function_domain().

函数调用图:

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

exponential_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::exponential_sign	(	const InferenceEngine &	engine,
		const SymbolicExpr &	arg_expr,
		Sign	target,
		ComputationContext &	context ) const

在文件 inference_engine_functions.cpp 第 34 行定义.

                                                    {
    const detail::AssumptionFacts facts(engine);
    auto real = detail::query_real_value(detail::node(arg_expr), facts, context);
    if (!real) {
        return real;
    }
    if (real.value() == Tribool::True) {
        return known_sign(1, target);
    }
    return Tribool::Unknown;
}

引用了 LMCAS::context, known_sign(), LMCAS::detail::node(), LMCAS::detail::query_real_value(), LMCAS::real(), LMCAS::target, LMCAS::True, LMCAS::Unknown , 以及 LMCAS::Result< T >::value().

被这些函数引用 function_sign().

函数调用图:

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

function_domain()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::function_domain	(	const InferenceEngine &	engine,
		FunctionNode::FuncType	type,
		const SymbolicExpr &	argument,
		Domain	target,
		ComputationContext &	context ) const

在文件 inference_engine_functions.cpp 第 338 行定义.

                                                                                    {
    switch (type) {
        case FunctionNode::FuncType::Exp: {
            return exponential_domain(engine, arg_expr, target, context);
        }
        case FunctionNode::FuncType::Sin:
        case FunctionNode::FuncType::Cos:
        case FunctionNode::FuncType::Tan: {
            if (target == Domain::Real) {
                return real_or_integer(engine, arg_expr, context);
            }
            return InferenceTriboolResult::success(Tribool::Unknown);
        }
        case FunctionNode::FuncType::Abs: {
            return absolute_domain(engine, arg_expr, target, context);
        }
        case FunctionNode::FuncType::Ln: {
            return logarithm_domain(engine, arg_expr, target, context);
        }
        case FunctionNode::FuncType::Sqrt: {
            return square_root_domain(engine, arg_expr, target, context);
        }
        case FunctionNode::FuncType::ArcTan: {
            return arctangent_domain(engine, arg_expr, target, context);
        }
        default:
            return InferenceTriboolResult::success(Tribool::Unknown);
    }
}

引用了 LMCAS::FunctionNode::Abs, absolute_domain(), LMCAS::FunctionNode::ArcTan, arctangent_domain(), LMCAS::context, LMCAS::FunctionNode::Cos, LMCAS::FunctionNode::Exp, exponential_domain(), LMCAS::FunctionNode::Ln, logarithm_domain(), LMCAS::Real, real_or_integer(), LMCAS::FunctionNode::Sin, LMCAS::FunctionNode::Sqrt, square_root_domain(), LMCAS::Result< Tribool >::success(), LMCAS::FunctionNode::Tan, LMCAS::target , 以及 LMCAS::Unknown.

函数调用图:

function_monotonicity()

Monotonicity LMCAS::InferenceEngine::Impl::function_monotonicity ( const FunctionNode & func, const std::string & var, const Interval & interval )

static

在文件 inference_engine_monotonicity.cpp 第 23 行定义.

                              {
    if (func.arguments().empty()) {
        return Monotonicity::Unknown;
    }
    auto arg_var = std::dynamic_pointer_cast<const VariableNode>(func.arguments()[0]);
    if (!arg_var || arg_var->is_constant() || arg_var->name() != var) {
        return Monotonicity::Unknown;
    }
 
    switch (func.type()) {
        case FunctionNode::FuncType::Exp:
            return Monotonicity::Increasing;
 
        case FunctionNode::FuncType::ArcTan:
            return Monotonicity::Increasing;
 
        case FunctionNode::FuncType::Ln: {
            return logarithm_monotonicity(interval);
        }
 
        default:
            break;
    }
    return Monotonicity::Unknown;
}

引用了 LMCAS::FunctionNode::ArcTan, LMCAS::FunctionNode::arguments(), LMCAS::FunctionNode::Exp, LMCAS::Increasing, LMCAS::interval(), LMCAS::FunctionNode::Ln, logarithm_monotonicity(), LMCAS::FunctionNode::type() , 以及 LMCAS::Unknown.

函数调用图:

function_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::function_sign	(	const InferenceEngine &	engine,
		FunctionNode::FuncType	type,
		const SymbolicExpr &	argument,
		Sign	target,
		ComputationContext &	context ) const

在文件 inference_engine_functions.cpp 第 280 行定义.

                                                                                  {
    switch (type) {
        case FunctionNode::FuncType::Exp: {
            return exponential_sign(engine, arg_expr, target, context);
        }
        case FunctionNode::FuncType::Sin:
        case FunctionNode::FuncType::Cos:
        case FunctionNode::FuncType::Tan: {
            return trigonometric_sign(engine, arg_expr, context);
        }
        case FunctionNode::FuncType::Abs: {
            return absolute_sign(engine, arg_expr, target, context);
        }
        case FunctionNode::FuncType::Ln: {
            return logarithm_sign(engine, arg_expr, target, context);
        }
        case FunctionNode::FuncType::Sqrt: {
            return square_root_sign(engine, arg_expr, target, context);
        }
        case FunctionNode::FuncType::ArcTan: {
            return engine.query_sign_of_checked(arg_expr, target, context);
        }
        default:
            return InferenceTriboolResult::success(Tribool::Unknown);
    }
}

引用了 LMCAS::FunctionNode::Abs, absolute_sign(), LMCAS::FunctionNode::ArcTan, LMCAS::context, LMCAS::FunctionNode::Cos, LMCAS::FunctionNode::Exp, exponential_sign(), LMCAS::FunctionNode::Ln, logarithm_sign(), LMCAS::FunctionNode::Sin, LMCAS::FunctionNode::Sqrt, square_root_sign(), LMCAS::Result< Tribool >::success(), LMCAS::FunctionNode::Tan, LMCAS::target, trigonometric_sign() , 以及 LMCAS::Unknown.

函数调用图:

has_negated_operand()

bool LMCAS::InferenceEngine::Impl::has_negated_operand ( const AddNode & node, ComputationContext & context )

static

在文件 inference_engine_arithmetic.cpp 第 62 行定义.

                                                                                              {
    if (node.operands().size() != 2) {
        return false;
    }
    for (const auto& operand : node.operands()) {
        auto step = context.consume_steps(1, "inference.arithmetic");
        if (!step) throw step.error();
        auto mul = std::dynamic_pointer_cast<const MultiplyNode>(operand);
        if (!mul || mul->operands().size() != 2) {
            continue;
        }
        for (const auto& factor : mul->operands()) {
            auto step = context.consume_steps(1, "inference.arithmetic");
            if (!step) throw step.error();
            const auto number =
                std::dynamic_pointer_cast<const NumberNode>(factor);
            if (number && number->is_negative_one()) {
                return true;
            }
        }
    }
    return false;
}

引用了 LMCAS::context , 以及 LMCAS::mul().

函数调用图:

integer_power_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::integer_power_sign	(	const InferenceEngine &	engine,
		const SymbolicExpr &	base_expr,
		const NumberNode &	exponent,
		Sign	target,
		ComputationContext &	context ) const

在文件 inference_engine_power.cpp 第 106 行定义.

                                                    {
    if (is_integer_number(exponent) && !is_even_integer_number(exponent)) {
        const detail::AssumptionFacts facts(engine);
        auto real = detail::query_real_value(detail::node(base_expr), facts, context);
        if (!real) return real;
        if (real.value() != Tribool::True)
            return nonzero_power_sign(engine, base_expr, exponent, target, context);
        return engine.query_sign_of_checked(base_expr, target, context);
    }
    auto even = even_power_sign(engine, base_expr, exponent, target, context);
    if (!even) {
        return even;
    }
    if (even.value() != Tribool::Unknown) {
        return even;
    }
    auto positive = positive_integer_power_sign(engine, base_expr, exponent, target, context);
    if (!positive) {
        return positive;
    }
    if (positive.value() != Tribool::Unknown) {
        return positive;
    }
    return nonzero_power_sign(engine, base_expr, exponent, target, context);
}

引用了 LMCAS::context, even_power_sign(), LMCAS::exponent, LMCAS::is_even_integer_number(), LMCAS::is_integer_number(), LMCAS::detail::node(), nonzero_power_sign(), positive_integer_power_sign(), LMCAS::detail::query_real_value(), LMCAS::real(), LMCAS::target, LMCAS::True, LMCAS::Unknown , 以及 LMCAS::Result< T >::value().

函数调用图:

integral_power_domain()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::integral_power_domain ( const InferenceEngine & engine, const SymbolicExpr & base, const NumberNode & exponent, Domain target, ComputationContext & context )

static

在文件 inference_engine_domains.cpp 第 143 行定义.

                                                                            {
    if (target == Domain::Integer) {
        auto base_int_result = engine.query_integer_checked(base, context);
        if (!base_int_result) {
            return base_int_result;
        }
        const Tribool base_int = base_int_result.value();
        if (base_int == Tribool::True && is_positive_integer_number(exponent)) {
            return InferenceTriboolResult::success(Tribool::True);
        }
        if (base_int == Tribool::True && is_zero_number(exponent)) {
            return InferenceTriboolResult::success(Tribool::True);
        }
    }
    return Tribool::Unknown;
}

引用了 LMCAS::context, LMCAS::exponent, LMCAS::Integer, LMCAS::is_positive_integer_number(), LMCAS::is_zero_number(), LMCAS::Result< Tribool >::success(), LMCAS::target, LMCAS::True , 以及 LMCAS::Unknown.

函数调用图:

known_sign()

Tribool LMCAS::InferenceEngine::Impl::known_sign ( int value, Sign target )

static

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

                                                              {
    switch (target) {
        case Sign::Positive: {
            return value > 0 ? Tribool::True : Tribool::False;
        }
        case Sign::Negative: {
            return value < 0 ? Tribool::True : Tribool::False;
        }
        case Sign::NonNegative: {
            return value >= 0 ? Tribool::True : Tribool::False;
        }
        case Sign::NonPositive: {
            return value <= 0 ? Tribool::True : Tribool::False;
        }
        case Sign::Zero: {
            return value == 0 ? Tribool::True : Tribool::False;
        }
        case Sign::NonZero: {
            return value != 0 ? Tribool::True : Tribool::False;
        }
    }
    return Tribool::Unknown;
}

引用了 LMCAS::False, LMCAS::Negative, LMCAS::NonNegative, LMCAS::NonPositive, LMCAS::NonZero, LMCAS::Positive, LMCAS::target, LMCAS::True, LMCAS::Unknown, LMCAS::value , 以及 LMCAS::Zero.

被这些函数引用 absolute_sign(), even_power_sign(), exponential_sign(), logarithm_sign(), positive_power_sign(), subtraction_sign() , 以及 zero_power_sign().

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

logarithm_domain()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::logarithm_domain	(	const InferenceEngine &	engine,
		const SymbolicExpr &	arg_expr,
		Domain	target,
		ComputationContext &	context ) const

在文件 inference_engine_functions.cpp 第 206 行定义.

                                                      {
    if (target != Domain::Real) return Tribool::Unknown;
    const detail::AssumptionFacts facts(engine);
    auto positive = detail::query_positive_value(detail::node(arg_expr), facts, context);
    if (!positive) return positive;
    return positive.value() == Tribool::True ? Tribool::True : Tribool::Unknown;
}

引用了 LMCAS::context, LMCAS::detail::node(), LMCAS::detail::query_positive_value(), LMCAS::Real, LMCAS::target, LMCAS::True , 以及 LMCAS::Unknown.

被这些函数引用 function_domain().

函数调用图:

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

logarithm_monotonicity()

Monotonicity LMCAS::InferenceEngine::Impl::logarithm_monotonicity ( const Interval & interval )

static

在文件 inference_engine_monotonicity.cpp 第 8 行定义.

                                                                                 {
    ComputationContext context;
    auto lower = detail::comparable_endpoint(
        interval.lower, context, "inference.logarithm_monotonicity");
    if (!lower) return Monotonicity::Unknown;
    auto comparison = detail::compare_comparable(
        lower.value(), detail::ComparableEndpoint{}, context);
    if (!comparison) return Monotonicity::Unknown;
    if (comparison.value() > 0 ||
        (comparison.value() == 0 && interval.lower.is_open)) {
        return Monotonicity::Increasing;
    }
    return Monotonicity::Unknown;
}

引用了 LMCAS::detail::comparable_endpoint(), LMCAS::detail::compare_comparable(), LMCAS::context, LMCAS::Increasing, LMCAS::interval(), LMCAS::lower , 以及 LMCAS::Unknown.

被这些函数引用 function_monotonicity().

函数调用图:

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

logarithm_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::logarithm_sign	(	const InferenceEngine &	engine,
		const SymbolicExpr &	arg_expr,
		Sign	target,
		ComputationContext &	context ) const

在文件 inference_engine_functions.cpp 第 97 行定义.

                                                    {
    if (const auto* number = dynamic_cast<const NumberNode*>(detail::node(arg_expr).get())) {
        const int sign = std::visit([](const auto& value) {
            using T = std::decay_t<decltype(value)>;
            return value > T(1) ? 1 : value < T(1) ? -1 : 0;
        }, number->value());
        return known_sign(sign, target);
    }
    auto step = context.consume_steps(1, "inference.logarithm");
    if (!step) {
        return InferenceTriboolResult::failure(step.error());
    }
    const auto one = detail::expression_from_node(detail::make_node<NumberNode>(BigInt(1)));
    auto greater = ctx.has_relation_checked(arg_expr, one, RelationOp::GT, context);
    if (!greater) {
        return InferenceTriboolResult::failure(greater.error());
    }
    if (greater.value()) {
        return known_sign(1, target);
    }
    auto equal = ctx.has_relation_checked(arg_expr, one, RelationOp::EQ, context);
    if (!equal) {
        return InferenceTriboolResult::failure(equal.error());
    }
    if (equal.value()) {
        return known_sign(0, target);
    }
    auto less = ctx.has_relation_checked(arg_expr, one, RelationOp::LT, context);
    if (!less) {
        return InferenceTriboolResult::failure(less.error());
    }
    if (less.value()) {
        return known_sign(-1, target);
    }
    return Tribool::Unknown;
}

引用了 LMCAS::context, ctx, LMCAS::EQ, LMCAS::detail::expression_from_node(), LMCAS::Result< Tribool >::failure(), LMCAS::GT, known_sign(), LMCAS::LT, LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::target, LMCAS::Unknown , 以及 LMCAS::value.

被这些函数引用 function_sign().

函数调用图:

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

multiply_domain()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::multiply_domain	(	const InferenceEngine &	engine,
		const MultiplyNode &	node,
		Domain	target,
		ComputationContext &	context ) const

在文件 inference_engine_domains.cpp 第 95 行定义.

                                                                                                               {
    if (target != Domain::Integer && target != Domain::Real) { return Tribool::Unknown; }
    for (const auto& operand : node.operands()) {
        const auto expression = detail::expression_from_node(operand);
        auto result = target == Domain::Integer ? engine.query_integer_checked(expression, context)
                                                : real_or_integer(engine, expression, context);
        if (!result) { return result; }
        if (result.value() != Tribool::True) { return Tribool::Unknown; }
    }
    return Tribool::True;
}

引用了 LMCAS::context, LMCAS::detail::expression_from_node(), LMCAS::Integer, LMCAS::Real, real_or_integer(), LMCAS::target, LMCAS::True , 以及 LMCAS::Unknown.

函数调用图:

natural_number()

Tribool LMCAS::InferenceEngine::Impl::natural_number ( const NumberNode & num )

static

在文件 inference_engine_facts.cpp 第 91 行定义.

                                                                 {
    return is_integer_number(num) && (num.is_positive() || num.is_zero())
        ? Tribool::True : Tribool::False;
}

引用了 LMCAS::False, LMCAS::is_integer_number(), LMCAS::polynomial_solver_detail::num() , 以及 LMCAS::True.

被这些函数引用 query_natural().

函数调用图:

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

nonnegative_sign()

Tribool LMCAS::InferenceEngine::Impl::nonnegative_sign ( Sign target )

static

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

                                                         {
    if (target == Sign::NonNegative) {
        return Tribool::True;
    }
    if (target == Sign::Negative) {
        return Tribool::False;
    }
    return Tribool::Unknown;
}

引用了 LMCAS::False, LMCAS::Negative, LMCAS::NonNegative, LMCAS::target, LMCAS::True , 以及 LMCAS::Unknown.

被这些函数引用 absolute_sign(), even_power_sign(), positive_integer_power_sign() , 以及 square_root_sign().

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

nonzero_power_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::nonzero_power_sign	(	const InferenceEngine &	engine,
		const SymbolicExpr &	base_expr,
		const NumberNode &	exponent,
		Sign	target,
		ComputationContext &	context ) const

在文件 inference_engine_power.cpp 第 88 行定义.

                                                    {
    if (!is_integer_number(exponent)) {
        return Tribool::Unknown;
    }
    auto base = engine.query_sign_of_checked(base_expr, Sign::NonZero, context);
    if (!base) {
        return base;
    }
    if (base.value() == Tribool::True) {
        return target == Sign::NonZero ? Tribool::True : target == Sign::Zero ? Tribool::False : Tribool::Unknown;
    }
    return Tribool::Unknown;
}

引用了 LMCAS::context, LMCAS::exponent, LMCAS::False, LMCAS::is_integer_number(), LMCAS::NonZero, LMCAS::target, LMCAS::True, LMCAS::Unknown , 以及 LMCAS::Zero.

被这些函数引用 integer_power_sign().

函数调用图:

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

number_integer()

Tribool LMCAS::InferenceEngine::Impl::number_integer ( const NumberNode & num )

static

在文件 inference_engine_facts.cpp 第 21 行定义.

                                                                 {
    return is_integer_number(num) ? Tribool::True : Tribool::False;
}

引用了 LMCAS::False, LMCAS::is_integer_number(), LMCAS::polynomial_solver_detail::num() , 以及 LMCAS::True.

函数调用图:

number_negative()

Tribool LMCAS::InferenceEngine::Impl::number_negative ( const NumberNode & num )

static

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

                                                                  {
    return !num.is_positive() && !num.is_zero() ? Tribool::True : Tribool::False;
}

引用了 LMCAS::False, LMCAS::polynomial_solver_detail::num() , 以及 LMCAS::True.

函数调用图:

number_nonnegative()

Tribool LMCAS::InferenceEngine::Impl::number_nonnegative ( const NumberNode & num )

static

在文件 inference_engine_facts.cpp 第 13 行定义.

                                                                     {
    return num.is_positive() || num.is_zero() ? Tribool::True : Tribool::False;
}

引用了 LMCAS::False, LMCAS::polynomial_solver_detail::num() , 以及 LMCAS::True.

函数调用图:

number_nonpositive()

Tribool LMCAS::InferenceEngine::Impl::number_nonpositive ( const NumberNode & num )

static

在文件 inference_engine_facts.cpp 第 17 行定义.

                                                                     {
    return num.is_positive() ? Tribool::False : Tribool::True;
}

引用了 LMCAS::False, LMCAS::polynomial_solver_detail::num() , 以及 LMCAS::True.

函数调用图:

number_nonzero()

Tribool LMCAS::InferenceEngine::Impl::number_nonzero ( const NumberNode & num )

static

在文件 inference_engine_facts.cpp 第 25 行定义.

                                                                 {
    return num.is_zero() ? Tribool::False : Tribool::True;
}

引用了 LMCAS::False, LMCAS::polynomial_solver_detail::num() , 以及 LMCAS::True.

函数调用图:

number_positive()

Tribool LMCAS::InferenceEngine::Impl::number_positive ( const NumberNode & num )

static

在文件 inference_engine_facts.cpp 第 5 行定义.

                                                                  {
    return num.is_positive() ? Tribool::True : Tribool::False;
}

引用了 LMCAS::False, LMCAS::polynomial_solver_detail::num() , 以及 LMCAS::True.

函数调用图:

operand_sign()

bool LMCAS::InferenceEngine::Impl::operand_sign	(	const std::shared_ptr< const SymbolicNode > &	operand,
		Sign	target,
		ComputationContext &	context ) const

在文件 inference_engine_relations.cpp 第 8 行定义.

                                                                                                                                       {
    auto step = context.consume_steps(0, "inference.relations");
    if (!step) throw step.error();
    if (auto var = std::dynamic_pointer_cast<const VariableNode>(operand)) {
        return var->is_constant()
            ? (target == Sign::Positive || target == Sign::NonNegative)
            : ctx.has_sign(var->name(), target);
    }
    if (auto num = std::dynamic_pointer_cast<const NumberNode>(operand)) {
        if (target == Sign::Positive) {
            return num->is_positive();
        }
        return num->is_zero() || num->is_positive();
    }
    return false;
}

引用了 LMCAS::context, ctx, LMCAS::NonNegative, LMCAS::polynomial_solver_detail::num(), LMCAS::Positive , 以及 LMCAS::target.

被这些函数引用 accumulate_sum_relation_sign() , 以及 product_relation_sign().

函数调用图:

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

positive_integer_power_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::positive_integer_power_sign	(	const InferenceEngine &	engine,
		const SymbolicExpr &	base_expr,
		const NumberNode &	exponent,
		Sign	target,
		ComputationContext &	context ) const

在文件 inference_engine_power.cpp 第 70 行定义.

                                                    {
    if (!is_positive_integer_number(exponent)) {
        return Tribool::Unknown;
    }
    auto base = engine.query_sign_of_checked(base_expr, Sign::NonNegative, context);
    if (!base) {
        return base;
    }
    if (base.value() == Tribool::True) {
        return nonnegative_sign(target);
    }
    return Tribool::Unknown;
}

引用了 LMCAS::context, LMCAS::exponent, LMCAS::is_positive_integer_number(), LMCAS::NonNegative, nonnegative_sign(), LMCAS::target, LMCAS::True , 以及 LMCAS::Unknown.

被这些函数引用 integer_power_sign().

函数调用图:

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

positive_power_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::positive_power_sign	(	const InferenceEngine &	engine,
		const SymbolicExpr &	base_expr,
		const SymbolicExpr &	exp_expr,
		Sign	target,
		ComputationContext &	context ) const

在文件 inference_engine_power.cpp 第 24 行定义.

                                                    {
    const detail::AssumptionFacts facts(engine);
    auto base_pos = detail::query_positive_value(detail::node(base_expr), facts, context);
    if (!base_pos) {
        return base_pos;
    }
    if (base_pos.value() != Tribool::True) {
        return Tribool::Unknown;
    }
    auto exp_real = detail::query_real_value(detail::node(exp_expr), facts, context);
    if (!exp_real) {
        return exp_real;
    }
    if (exp_real.value() == Tribool::True) {
        return known_sign(1, target);
    }
    return Tribool::Unknown;
}

引用了 LMCAS::context, known_sign(), LMCAS::detail::node(), LMCAS::detail::query_positive_value(), LMCAS::detail::query_real_value(), LMCAS::target, LMCAS::True , 以及 LMCAS::Unknown.

函数调用图:

positive_relation_chain()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::positive_relation_chain	(	const SymbolicExpr &	expr,
		const SymbolicExpr &	zero_expr,
		ComputationContext &	context ) const

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

                                                                      {
    auto relations = ctx.get_visible_relations_checked(context);
    if (!relations) return InferenceTriboolResult::failure(relations.error());
    detail::RewriteBudget budget(context, context.limits().max_recursion_depth,
        std::numeric_limits<std::size_t>::max(), "inference.relations");
    budget.measure(detail::node(expr));
    for (const auto& rel : relations.value()) {
        auto step = context.consume_steps(1, "inference.relations");
        if (!step) throw step.error();
        if (rel.op != RelationalNode::Op::GT) {
            continue;
        }
 
        if (!LMCAS::detail::node(rel.lhs) || !LMCAS::detail::node(expr)) {
            continue;
        }
        budget.measure(detail::node(rel.lhs));
        if (!LMCAS::detail::node(rel.lhs)->equals(*LMCAS::detail::node(expr))) {
            continue;
        }
        if (!LMCAS::detail::node(rel.rhs)) {
            continue;
        }
 
        auto nonnegative = relation_rhs_nonnegative(rel, zero_expr, context);
        if (!nonnegative) return InferenceTriboolResult::failure(nonnegative.error());
        if (nonnegative.value()) {
            return InferenceTriboolResult::success(Tribool::True);
        }
    }
    return InferenceTriboolResult::success(Tribool::Unknown);
}

引用了 LMCAS::context, ctx, LMCAS::Result< Tribool >::failure(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::node(), relation_rhs_nonnegative(), LMCAS::Result< Tribool >::success(), LMCAS::True , 以及 LMCAS::Unknown.

函数调用图:

product_parity_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::product_parity_sign ( std::uint8_t possible, Sign target )

static

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

                                      {
    if (!possible) return Tribool::Unknown;
    const auto wanted = sign_set(target);
    if ((possible & wanted) == possible) return Tribool::True;
    if (!(possible & wanted)) return Tribool::False;
    return Tribool::Unknown;
}

引用了 LMCAS::False, LMCAS::target, LMCAS::True , 以及 LMCAS::Unknown.

被这些函数引用 product_sign() , 以及 quotient_sign().

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

product_relation_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::product_relation_sign	(	const MultiplyNode &	mul,
		const SymbolicExpr &	zero_expr,
		Sign	target,
		ComputationContext &	context ) const

在文件 inference_engine_relations.cpp 第 88 行定义.

                                                    {
    const auto& rel_store = ctx;
    if (mul.operands().empty()) {
        return InferenceTriboolResult::success(Tribool::Unknown);
    }
 
    if (target == Sign::Positive) {
        bool all_gt_zero = true;
 
        for (const auto& operand : mul.operands()) {
            auto step = context.consume_steps(1, "inference.relations");
            if (!step) throw step.error();
            auto op_expr = LMCAS::detail::expression_from_node(operand);
            auto gt = rel_store.has_relation_checked(
                op_expr, zero_expr, RelationalNode::Op::GT, context);
            if (!gt) return InferenceTriboolResult::failure(gt.error());
            bool op_gt = gt.value();
 
            if (!op_gt) {
                op_gt = operand_sign(operand, Sign::Positive, context);
            }
 
            if (!op_gt) {
                all_gt_zero = false;
                break;
            }
        }
 
        if (all_gt_zero) {
            return InferenceTriboolResult::success(Tribool::True);
        }
    }
    return InferenceTriboolResult::success(Tribool::Unknown);
}

引用了 LMCAS::context, ctx, LMCAS::Result< T >::error(), LMCAS::detail::expression_from_node(), LMCAS::Result< Tribool >::failure(), LMCAS::gt(), LMCAS::mul(), operand_sign(), LMCAS::Positive, LMCAS::Result< Tribool >::success(), LMCAS::target, LMCAS::True, LMCAS::Unknown , 以及 LMCAS::Result< T >::value().

函数调用图:

product_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::product_sign	(	const InferenceEngine &	engine,
		const MultiplyNode &	node,
		Sign	target,
		ComputationContext &	context ) const

在文件 inference_engine_product.cpp 第 63 行定义.

                                                                                                             {
    auto defined = real_definedness(engine, node, context);
    if (!defined || defined.value() != Tribool::True) { return defined; }
    const detail::AssumptionFacts facts(engine);
    bool all_real = true;
    for (const auto& operand : node.operands()) {
        auto real = detail::query_real_value(operand, facts, context);
        if (!real) { return real; }
        all_real = all_real && real.value() == Tribool::True;
    }
    if (!all_real) { return Tribool::Unknown; }
    std::uint8_t possible = positive_sign;
    for (const auto& operand : node.operands()) {
        auto result = accumulate_product_sign(engine, operand, possible, context);
        if (!result) { return result; }
    }
    return product_parity_sign(possible, target);
}

引用了 accumulate_product_sign(), LMCAS::context, product_parity_sign(), LMCAS::detail::query_real_value(), LMCAS::real(), real_definedness(), LMCAS::target, LMCAS::True, LMCAS::Unknown , 以及 LMCAS::Result< T >::value().

函数调用图:

query_natural()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::query_natural	(	const SymbolicExpr &	expr,
		ComputationContext &	context ) const

在文件 inference_engine_facts.cpp 第 74 行定义.

                                                                                                                     {
    return checked_inference_result<Tribool>(expr, "query_domain_of_checked", context,
        [&]() -> InferenceTriboolResult {
            if (auto num = std::dynamic_pointer_cast<const NumberNode>(LMCAS::detail::node(expr))) {
                return natural_number(*num);
            }
            if (auto var = std::dynamic_pointer_cast<const VariableNode>(LMCAS::detail::node(expr))) {
                if (var->is_constant()) return Tribool::False;
                const auto& props = ctx;
                if (props.has_domain(var->name(), Domain::Natural)) {
                    return Tribool::True;
                }
            }
            return Tribool::Unknown;
        });
}

引用了 LMCAS::checked_inference_result(), LMCAS::context, ctx, LMCAS::False, LMCAS::Natural, natural_number(), LMCAS::detail::node(), LMCAS::polynomial_solver_detail::num(), LMCAS::True , 以及 LMCAS::Unknown.

函数调用图:

query_rational()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::query_rational	(	const InferenceEngine &	engine,
		const SymbolicExpr &	expr,
		ComputationContext &	context ) const

在文件 inference_engine_facts.cpp 第 29 行定义.

                                                                 {
    if (!LMCAS::detail::node(expr)) {
        return InferenceTriboolResult::failure(
            CasErrc::InvalidArgument,
            "inference expression must not be null",
            "query_domain_of_checked");
    }
    try {
        auto integer = engine.query_integer_checked(expr, context);
        if (!integer) {
            return InferenceTriboolResult::failure(integer.error());
        }
        if (integer.value() == Tribool::True) {
            return InferenceTriboolResult::success(Tribool::True);
        }
        if (auto num = std::dynamic_pointer_cast<const NumberNode>(LMCAS::detail::node(expr))) {
            if (std::holds_alternative<Rational>(num->value())) {
                return InferenceTriboolResult::success(Tribool::True);
            }
        }
        if (auto var = std::dynamic_pointer_cast<const VariableNode>(LMCAS::detail::node(expr))) {
            if (var->is_constant()) return InferenceTriboolResult::success(Tribool::False);
            const auto& props = ctx;
            if (props.has_domain(var->name(), Domain::Rational)) {
                return InferenceTriboolResult::success(Tribool::True);
            }
        }
        return InferenceTriboolResult::success(Tribool::Unknown);
    } catch (const CasError& error) {
        return InferenceTriboolResult::failure(error);
    } catch (const std::bad_alloc&) {
        return InferenceTriboolResult::failure(
            CasErrc::ResourceLimit,
            "inference query allocation failed",
            "query_domain_of_checked");
    } catch (const std::exception& ex) {
        return InferenceTriboolResult::failure(
            CasErrc::InternalInvariant,
            ex.what(),
            "query_domain_of_checked");
    }
}

引用了 LMCAS::context, ctx, LMCAS::Result< T >::error(), LMCAS::Result< Tribool >::failure(), LMCAS::False, LMCAS::integer, LMCAS::InternalInvariant, LMCAS::InvalidArgument, LMCAS::detail::node(), LMCAS::polynomial_solver_detail::num(), LMCAS::Rational, LMCAS::ResourceLimit, LMCAS::Result< Tribool >::success(), LMCAS::True, LMCAS::Unknown , 以及 LMCAS::Result< T >::value().

函数调用图:

query_zero()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::query_zero	(	const InferenceEngine &	engine,
		const SymbolicExpr &	expr,
		ComputationContext &	context ) const

在文件 inference_engine_core.cpp 第 255 行定义.

                                                                 {
    auto nn = engine.query_nonnegative_checked(expr, context);
    if (!nn) {
        return nn;
    }
    auto np = engine.query_nonpositive_checked(expr, context);
    if (!np) {
        return np;
    }
    if (nn.value() == Tribool::True && np.value() == Tribool::True) {
        return InferenceTriboolResult::success(Tribool::True);
    }
    if (nn.value() == Tribool::False || np.value() == Tribool::False) {
        return InferenceTriboolResult::success(Tribool::False);
    }
    auto nonzero = engine.query_nonzero_checked(expr, context);
    if (!nonzero) return nonzero;
    if (nonzero.value() == Tribool::True) return Tribool::False;
    return InferenceTriboolResult::success(Tribool::Unknown);
}

引用了 LMCAS::context, LMCAS::False, LMCAS::Result< Tribool >::success(), LMCAS::True , 以及 LMCAS::Unknown.

函数调用图:

quotient_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::quotient_sign	(	const InferenceEngine &	engine,
		const SymbolicExpr &	num_expr,
		const SymbolicExpr &	den_expr,
		Sign	target,
		ComputationContext &	context ) const

在文件 inference_engine_product.cpp 第 83 行定义.

                                                                                     {
    const detail::AssumptionFacts facts(engine);
    bool all_defined = true;
    bool all_real = true;
    for (const auto* expression : {&numerator, &denominator}) {
        auto defined = real_definedness(engine, *detail::node(*expression), context);
        if (!defined) { return defined; }
        all_defined = all_defined && defined.value() == Tribool::True;
        auto real = detail::query_real_value(detail::node(*expression), facts, context);
        if (!real) { return real; }
        all_real = all_real && real.value() == Tribool::True;
    }
    auto nonzero = detail::query_nonzero_value(detail::node(denominator), facts, Domain::Real, context);
    if (!nonzero) { return nonzero; }
    if (nonzero.value() == Tribool::False) {
        return InferenceTriboolResult::failure(
            CasErrc::DomainError, "division denominator is zero", "inference.division");
    }
    if (!all_defined || !all_real || nonzero.value() != Tribool::True)
        { return Tribool::Unknown; }
    std::uint8_t possible = positive_sign;
    auto first = accumulate_product_sign(engine, detail::node(numerator), possible, context);
    if (!first) { return first; }
    auto second = accumulate_product_sign(engine, detail::node(denominator), possible, context);
    if (!second) { return second; }
    return product_parity_sign(possible, target);
}

引用了 accumulate_product_sign(), LMCAS::context, LMCAS::denominator, LMCAS::DomainError, LMCAS::Result< Tribool >::failure(), LMCAS::False, LMCAS::detail::node(), product_parity_sign(), LMCAS::detail::query_nonzero_value(), LMCAS::detail::query_real_value(), LMCAS::Real, LMCAS::real(), real_definedness(), LMCAS::target, LMCAS::True, LMCAS::Unknown , 以及 LMCAS::Result< T >::value().

函数调用图:

real_definedness()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::real_definedness ( const InferenceEngine & engine, const SymbolicNode & node, ComputationContext & context )

static

在文件 inference_engine_functions.cpp 第 8 行定义.

                                                                                          {
    const detail::AssumptionFacts facts(engine);
    const std::shared_ptr<const SymbolicNode> borrowed(
        std::shared_ptr<const SymbolicNode>{}, &node);
    bool violated_real_restriction = false;
    auto defined = detail::query_definedness(
        borrowed, facts, Domain::Real, context, &violated_real_restriction);
    if (defined && defined.value() == Tribool::False) {
        if (!violated_real_restriction) {
            auto complex_defined =
                detail::query_definedness(borrowed, facts, Domain::Complex, context);
            if (!complex_defined) return InferenceTriboolResult::failure(complex_defined.error());
            if (complex_defined.value() != Tribool::False) {
                auto real_value = detail::query_real_value(borrowed, facts, context);
                if (!real_value) return InferenceTriboolResult::failure(real_value.error());
                if (real_value.value() == Tribool::Unknown) return Tribool::Unknown;
            }
        }
        return InferenceTriboolResult::failure(
            CasErrc::DomainError, "expression is undefined in the real domain",
            "inference.definedness");
    }
    return defined;
}

引用了 LMCAS::Complex, LMCAS::context, LMCAS::DomainError, LMCAS::Result< Tribool >::failure(), LMCAS::False, LMCAS::detail::query_definedness(), LMCAS::detail::query_real_value(), LMCAS::Real , 以及 LMCAS::Unknown.

被这些函数引用 product_sign() , 以及 quotient_sign().

函数调用图:

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

real_or_integer()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::real_or_integer	(	const InferenceEngine &	engine,
		const SymbolicExpr &	arg_expr,
		ComputationContext &	context ) const

在文件 inference_engine_functions.cpp 第 151 行定义.

                                                                     {
    auto arg_real_result = engine.query_real_checked(arg_expr, context);
    if (!arg_real_result) {
        return arg_real_result;
    }
    const Tribool arg_real = arg_real_result.value();
    if (arg_real == Tribool::True) {
        return InferenceTriboolResult::success(Tribool::True);
    }
 
    auto arg_int_result = engine.query_integer_checked(arg_expr, context);
    if (!arg_int_result) {
        return arg_int_result;
    }
    const Tribool arg_int = arg_int_result.value();
    if (arg_int == Tribool::True) {
        return InferenceTriboolResult::success(Tribool::True);
    }
    return InferenceTriboolResult::success(Tribool::Unknown);
}

引用了 LMCAS::context, LMCAS::Result< Tribool >::success(), LMCAS::True , 以及 LMCAS::Unknown.

被这些函数引用 absolute_domain(), function_domain() , 以及 multiply_domain().

函数调用图:

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

relation_rhs_nonnegative()

Result< bool > LMCAS::InferenceEngine::Impl::relation_rhs_nonnegative	(	const Relation &	rel,
		const SymbolicExpr &	zero_expr,
		ComputationContext &	context ) const

在文件 inference_engine_relations.cpp 第 126 行定义.

                                                                                                                                                {
    auto step = context.consume_steps(1, "inference.relations");
    if (!step) return Result<bool>::failure(step.error());
    const auto& rel_store = ctx;
    if (auto rhs_num = std::dynamic_pointer_cast<const NumberNode>(LMCAS::detail::node(rel.rhs))) {
        if (rhs_num->is_zero() || rhs_num->is_positive()) {
            return true;
        }
    }
 
    if (auto rhs_var = std::dynamic_pointer_cast<const VariableNode>(LMCAS::detail::node(rel.rhs))) {
        if (rhs_var->is_constant() ||
            ctx.has_sign(rhs_var->name(), Sign::NonNegative)) {
            return true;
        }
    }
 
    auto geq = rel_store.has_relation_checked(
        rel.rhs, zero_expr, RelationalNode::Op::GEQ, context);
    if (!geq || geq.value()) return geq;
    return rel_store.has_relation_checked(
        rel.rhs, zero_expr, RelationalNode::Op::GT, context);
}

引用了 LMCAS::context, ctx, LMCAS::Result< T >::failure(), LMCAS::detail::node(), LMCAS::NonNegative , 以及 LMCAS::Relation::rhs.

被这些函数引用 positive_relation_chain().

函数调用图:

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

small_positive_exponent()

std::optional< int > LMCAS::InferenceEngine::Impl::small_positive_exponent ( const std::shared_ptr< const NumberNode > & number )

static

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

                                                   {
    BigInt exponent;
    if (!try_get_integer_value(number, exponent) ||
        exponent <= BigInt(0) || exponent > BigInt(100)) {
        return std::nullopt;
    }
    return static_cast<int>(*exponent.try_to_int64());
}

引用了 LMCAS::exponent , 以及 LMCAS::try_get_integer_value().

被这些函数引用 collect_node_exponent().

函数调用图:

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

square_root_domain()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::square_root_domain	(	const InferenceEngine &	engine,
		const SymbolicExpr &	arg_expr,
		Domain	target,
		ComputationContext &	context ) const

在文件 inference_engine_functions.cpp 第 217 行定义.

                                                      {
    if (target == Domain::Real) {
        auto arg_nonneg_result = engine.query_sign_of_checked(arg_expr, Sign::NonNegative, context);
        if (!arg_nonneg_result) {
            return arg_nonneg_result;
        }
        const Tribool arg_nonneg = arg_nonneg_result.value();
        if (arg_nonneg == Tribool::True) {
            return InferenceTriboolResult::success(Tribool::True);
        }
    }
    return InferenceTriboolResult::success(Tribool::Unknown);
}

引用了 LMCAS::context, LMCAS::NonNegative, LMCAS::Real, LMCAS::Result< Tribool >::success(), LMCAS::target, LMCAS::True , 以及 LMCAS::Unknown.

被这些函数引用 function_domain().

函数调用图:

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

square_root_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::square_root_sign	(	const InferenceEngine &	engine,
		const SymbolicExpr &	arg_expr,
		Sign	target,
		ComputationContext &	context ) const

在文件 inference_engine_functions.cpp 第 137 行定义.

                                                    {
    auto nonnegative = engine.query_sign_of_checked(arg_expr, Sign::NonNegative, context);
    if (!nonnegative) {
        return nonnegative;
    }
    if (nonnegative.value() == Tribool::True) {
        return nonnegative_sign(target);
    }
    return Tribool::Unknown;
}

引用了 LMCAS::context, LMCAS::NonNegative, nonnegative_sign(), LMCAS::target, LMCAS::True , 以及 LMCAS::Unknown.

被这些函数引用 function_sign().

函数调用图:

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

subtraction_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::subtraction_sign	(	const InferenceEngine &	engine,
		const SymbolicExpr &	minuend_expr,
		const SymbolicExpr &	subtrahend_expr,
		Sign	target,
		ComputationContext &	context ) const

在文件 inference_engine_arithmetic.cpp 第 122 行定义.

                                                    {
    auto min_pos_result =
        engine.query_sign_of_checked(minuend_expr, Sign::Positive, context);
    if (!min_pos_result) {
        return min_pos_result;
    }
    const Tribool min_pos = min_pos_result.value();
    auto min_neg_result =
        engine.query_sign_of_checked(minuend_expr, Sign::Negative, context);
    if (!min_neg_result) {
        return min_neg_result;
    }
    const Tribool min_neg = min_neg_result.value();
    auto sub_pos_result =
        engine.query_sign_of_checked(subtrahend_expr, Sign::Positive, context);
    if (!sub_pos_result) {
        return sub_pos_result;
    }
    const Tribool sub_pos = sub_pos_result.value();
    auto sub_neg_result =
        engine.query_sign_of_checked(subtrahend_expr, Sign::Negative, context);
    if (!sub_neg_result) {
        return sub_neg_result;
    }
    const Tribool sub_neg = sub_neg_result.value();
 
    if (min_pos == Tribool::True && sub_neg == Tribool::True) {
        return known_sign(1, target);
    }
 
    if (min_neg == Tribool::True && sub_pos == Tribool::True) {
        return known_sign(-1, target);
    }
 
    return weak_subtraction_sign(engine, minuend_expr, subtrahend_expr, target, context);
}

引用了 LMCAS::context, known_sign(), LMCAS::Negative, LMCAS::Positive, LMCAS::target, LMCAS::True , 以及 weak_subtraction_sign().

函数调用图:

subtrahend()

std::shared_ptr< const SymbolicNode > LMCAS::InferenceEngine::Impl::subtrahend ( const std::shared_ptr< const SymbolicNode > & operand, ComputationContext & context )

static

在文件 inference_engine_arithmetic.cpp 第 40 行定义.

                                                                                   {
    auto mul = std::dynamic_pointer_cast<const MultiplyNode>(operand);
    if (!mul || mul->operands().size() != 2) {
        return nullptr;
    }
    bool found_neg_one = false;
    std::shared_ptr<const SymbolicNode> other_operand;
    for (const auto& mul_op : mul->operands()) {
        auto step = context.consume_steps(1, "inference.arithmetic");
        if (!step) throw step.error();
        const auto number =
            std::dynamic_pointer_cast<const NumberNode>(mul_op);
        if (number && number->is_negative_one()) {
            found_neg_one = true;
            continue;
        }
        other_operand = mul_op;
    }
    return found_neg_one ? other_operand : nullptr;
}

引用了 LMCAS::context , 以及 LMCAS::mul().

函数调用图:

sum_nonzero()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::sum_nonzero	(	const InferenceEngine &	engine,
		const AddNode &	add,
		ComputationContext &	context ) const

在文件 inference_engine_core.cpp 第 215 行定义.

                                                           {
    auto positive =
        engine.infer_add_sign_checked(add, Sign::Positive, context);
    if (!positive) {
        return positive;
    }
    if (positive.value() == Tribool::True) {
        return Tribool::True;
    }
    auto negative =
        engine.infer_add_sign_checked(add, Sign::Negative, context);
    if (!negative) {
        return negative;
    }
    if (negative.value() == Tribool::True) {
        return Tribool::True;
    }
    return Tribool::Unknown;
}

引用了 LMCAS::add(), LMCAS::context, LMCAS::Negative, LMCAS::Positive, LMCAS::True , 以及 LMCAS::Unknown.

被这些函数引用 composite_nonzero().

函数调用图:

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

sum_relation_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::sum_relation_sign	(	const AddNode &	add,
		const SymbolicExpr &	zero_expr,
		Sign	target,
		ComputationContext &	context ) const

在文件 inference_engine_relations.cpp 第 60 行定义.

                                                    {
    if (add.operands().empty()) {
        return InferenceTriboolResult::success(Tribool::Unknown);
    }
 
    bool all_gt_zero = true;
    bool all_geq_zero = true;
 
    for (const auto& operand : add.operands()) {
        auto result = accumulate_sum_relation_sign(
            operand, zero_expr, all_gt_zero, all_geq_zero, context);
        if (!result) {
            return InferenceTriboolResult::failure(result.error());
        }
    }
 
    if (target == Sign::Positive && all_gt_zero) {
        return InferenceTriboolResult::success(Tribool::True);
    }
    if (target == Sign::NonNegative && all_geq_zero) {
        return InferenceTriboolResult::success(Tribool::True);
    }
    return InferenceTriboolResult::success(Tribool::Unknown);
}

引用了 accumulate_sum_relation_sign(), LMCAS::add(), LMCAS::context, LMCAS::Result< Tribool >::failure(), LMCAS::NonNegative, LMCAS::Positive, LMCAS::Result< Tribool >::success(), LMCAS::target, LMCAS::True , 以及 LMCAS::Unknown.

函数调用图:

sum_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::sum_sign	(	const InferenceEngine &	engine,
		const AddNode &	node,
		Sign	target,
		ComputationContext &	context ) const

在文件 inference_engine_arithmetic.cpp 第 86 行定义.

                                                    {
    bool all_have_property = true;
 
    for (const auto& operand : node.operands()) {
        auto step = context.consume_steps(1, "inference.arithmetic");
        if (!step) throw step.error();
        auto op_expr = LMCAS::detail::expression_from_node(operand);
        Tribool op_result = Tribool::Unknown;
        if (target != Sign::Positive && target != Sign::Negative &&
            target != Sign::NonNegative && target != Sign::NonPositive) {
            return InferenceTriboolResult::success(Tribool::Unknown);
        }
        auto queried = engine.query_sign_of_checked(op_expr, target, context);
        if (!queried) {
            return queried;
        }
        op_result = queried.value();
 
        if (op_result == Tribool::Unknown) {
            return InferenceTriboolResult::success(Tribool::Unknown);
        }
        if (op_result == Tribool::False) {
            all_have_property = false;
        }
    }
 
    if (all_have_property) {
        return InferenceTriboolResult::success(Tribool::True);
    }
 
    return InferenceTriboolResult::success(Tribool::Unknown);
}

引用了 LMCAS::context, LMCAS::detail::expression_from_node(), LMCAS::False, LMCAS::Negative, LMCAS::NonNegative, LMCAS::NonPositive, LMCAS::Positive, LMCAS::Result< Tribool >::success(), LMCAS::target, LMCAS::True , 以及 LMCAS::Unknown.

函数调用图:

trigonometric_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::trigonometric_sign	(	const InferenceEngine &	engine,
		const SymbolicExpr &	arg_expr,
		ComputationContext &	context ) const

在文件 inference_engine_functions.cpp 第 49 行定义.

                                                                     {
    auto real = engine.query_domain_of_checked(arg_expr, Domain::Real, context);
    if (!real) {
        return real;
    }
    return Tribool::Unknown;
}

引用了 LMCAS::context, LMCAS::Real, LMCAS::real() , 以及 LMCAS::Unknown.

被这些函数引用 function_sign().

函数调用图:

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

weak_subtraction_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::weak_subtraction_sign	(	const InferenceEngine &	engine,
		const SymbolicExpr &	minuend_expr,
		const SymbolicExpr &	subtrahend_expr,
		Sign	target,
		ComputationContext &	context ) const

在文件 inference_engine_arithmetic.cpp 第 163 行定义.

                                                    {
    auto min_nn_result =
        engine.query_sign_of_checked(minuend_expr, Sign::NonNegative, context);
    if (!min_nn_result) {
        return min_nn_result;
    }
    const Tribool min_nn = min_nn_result.value();
    auto sub_np_result =
        engine.query_sign_of_checked(subtrahend_expr, Sign::NonPositive, context);
    if (!sub_np_result) {
        return sub_np_result;
    }
    const Tribool sub_np = sub_np_result.value();
    if (min_nn == Tribool::True && sub_np == Tribool::True) {
        switch (target) {
            case Sign::NonNegative: return InferenceTriboolResult::success(Tribool::True);
            case Sign::Negative:    return InferenceTriboolResult::success(Tribool::False);
            default: break;
        }
    }
 
    auto min_np_result =
        engine.query_sign_of_checked(minuend_expr, Sign::NonPositive, context);
    if (!min_np_result) {
        return min_np_result;
    }
    const Tribool min_np = min_np_result.value();
    auto sub_nn_result =
        engine.query_sign_of_checked(subtrahend_expr, Sign::NonNegative, context);
    if (!sub_nn_result) {
        return sub_nn_result;
    }
    const Tribool sub_nn = sub_nn_result.value();
    if (min_np == Tribool::True && sub_nn == Tribool::True) {
        switch (target) {
            case Sign::NonPositive: return InferenceTriboolResult::success(Tribool::True);
            case Sign::Positive:    return InferenceTriboolResult::success(Tribool::False);
            default: break;
        }
    }
 
    return InferenceTriboolResult::success(Tribool::Unknown);
}

引用了 LMCAS::context, LMCAS::False, LMCAS::Negative, LMCAS::NonNegative, LMCAS::NonPositive, LMCAS::Positive, LMCAS::Result< Tribool >::success(), LMCAS::target, LMCAS::True , 以及 LMCAS::Unknown.

被这些函数引用 subtraction_sign().

函数调用图:

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

zero_power_sign()

InferenceTriboolResult LMCAS::InferenceEngine::Impl::zero_power_sign	(	const InferenceEngine &	engine,
		const SymbolicExpr &	base_expr,
		const NumberNode *	exp_num,
		Sign	target,
		ComputationContext &	context ) const

在文件 inference_engine_power.cpp 第 7 行定义.

                                                    {
    if (!exp_num || !is_zero_number(*exp_num)) {
        return Tribool::Unknown;
    }
    const detail::AssumptionFacts facts(engine);
    auto base_nonzero = detail::query_nonzero_value(detail::node(base_expr), facts, Domain::Real, context);
    if (!base_nonzero) return base_nonzero;
    if (base_nonzero.value() == Tribool::True) {
        return known_sign(1, target);
    }
    return Tribool::Unknown;
}

引用了 LMCAS::context, LMCAS::is_zero_number(), known_sign(), LMCAS::detail::node(), LMCAS::detail::query_nonzero_value(), LMCAS::Real, LMCAS::target, LMCAS::True , 以及 LMCAS::Unknown.

函数调用图:

类成员变量说明

ctx

const AssumptionContext& LMCAS::InferenceEngine::Impl::ctx

在文件 inference_engine_impl.hpp 第 239 行定义.

被这些函数引用 Impl(), accumulate_sum_relation_sign(), logarithm_sign(), operand_sign(), positive_relation_chain(), product_relation_sign(), query_natural(), query_rational() , 以及 relation_rhs_nonnegative().

current_depth

int LMCAS::InferenceEngine::Impl::current_depth = 0

mutable

在文件 inference_engine_impl.hpp 第 242 行定义.

max_depth

int LMCAS::InferenceEngine::Impl::max_depth

在文件 inference_engine_impl.hpp 第 240 行定义.

被这些函数引用 Impl().

visited

std::unordered_set<const SymbolicNode*> LMCAS::InferenceEngine::Impl::visited

mutable

在文件 inference_engine_impl.hpp 第 241 行定义.

---

该结构体的文档由以下文件生成:

• src/internal/inference_engine_impl.hpp
• src/inference_engine_arithmetic.cpp
• src/inference_engine_core.cpp
• src/inference_engine_domains.cpp
• src/inference_engine_facts.cpp
• src/inference_engine_functions.cpp
• src/inference_engine_monotonicity.cpp
• src/inference_engine_power.cpp
• src/inference_engine_product.cpp
• src/inference_engine_relations.cpp