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

类型定义
using	ConditionSet = QueryInterface::ConditionSet
using	ConditionSets = std::vector<ConditionSet>

函数
ConditionSets	difference_conditions (const std::shared_ptr< const SymbolicNode > &pos_operand, const std::shared_ptr< const SymbolicNode > &neg_operand, Sign target)
ConditionSets	product_conditions (const MultiplyNode &mul, Sign target)
ConditionSets	quotient_conditions (const std::shared_ptr< const SymbolicNode > &numerator, const std::shared_ptr< const SymbolicNode > &denominator, Sign target)
std::shared_ptr< const SymbolicNode >	subtracted_operand (const std::shared_ptr< const SymbolicNode > &node)
ConditionSets	sum_conditions (const AddNode &add, Sign target)
ConditionSets	variable_operand_conditions (const std::vector< std::shared_ptr< const SymbolicNode > > &operands, Sign target)

类型定义说明

ConditionSet

using LMCAS::anonymous_namespace{query_conditions.cpp}::ConditionSet = QueryInterface::ConditionSet

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

ConditionSets

using LMCAS::anonymous_namespace{query_conditions.cpp}::ConditionSets = std::vector<ConditionSet>

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

函数说明

difference_conditions()

ConditionSets LMCAS::anonymous_namespace{query_conditions.cpp}::difference_conditions	(	const std::shared_ptr< const SymbolicNode > &	pos_operand,
		const std::shared_ptr< const SymbolicNode > &	neg_operand,
		Sign	target )

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

                                                                       {
    const auto lhs_var = std::dynamic_pointer_cast<const VariableNode>(pos_operand);
    const auto rhs_var = std::dynamic_pointer_cast<const VariableNode>(neg_operand);
    if (!lhs_var || lhs_var->is_constant() ||
        !rhs_var || rhs_var->is_constant()) return {};
    if (target == Sign::Positive) {
        ConditionSet cs1;
        cs1.sign_conditions.emplace_back(lhs_var->name(), Sign::Positive);
        cs1.sign_conditions.emplace_back(rhs_var->name(), Sign::Negative);
        ConditionSet cs2;
        auto lhs_expr = LMCAS::detail::expression_from_node(pos_operand);
        auto rhs_expr = LMCAS::detail::expression_from_node(neg_operand);
        Relation rel{lhs_expr, rhs_expr, RelationalNode::Op::GT};
        cs2.relational_conditions.push_back(rel);
        cs2.sign_conditions.emplace_back(rhs_var->name(), Sign::NonNegative);
 
        return {cs1, cs2};
    } else if (target == Sign::Negative) {
        ConditionSet cs1;
        cs1.sign_conditions.emplace_back(lhs_var->name(), Sign::Negative);
        cs1.sign_conditions.emplace_back(rhs_var->name(), Sign::Positive);
 
        ConditionSet cs2;
        auto lhs_expr = LMCAS::detail::expression_from_node(pos_operand);
        auto rhs_expr = LMCAS::detail::expression_from_node(neg_operand);
        Relation rel{rhs_expr, lhs_expr, RelationalNode::Op::GT};
        cs2.relational_conditions.push_back(rel);
        cs2.sign_conditions.emplace_back(lhs_var->name(), Sign::NonNegative);
 
        return {cs1, cs2};
    } else if (target == Sign::NonNegative) {
        ConditionSet cs1;
        cs1.sign_conditions.emplace_back(lhs_var->name(), Sign::NonNegative);
        cs1.sign_conditions.emplace_back(rhs_var->name(), Sign::NonPositive);
 
        ConditionSet cs2;
        auto lhs_expr = LMCAS::detail::expression_from_node(pos_operand);
        auto rhs_expr = LMCAS::detail::expression_from_node(neg_operand);
        Relation rel{lhs_expr, rhs_expr, RelationalNode::Op::GEQ};
        cs2.relational_conditions.push_back(rel);
 
        return {cs1, cs2};
    }
    return {};
}

引用了 difference_conditions(), LMCAS::detail::expression_from_node(), LMCAS::Negative, LMCAS::NonNegative, LMCAS::NonPositive, LMCAS::Positive , 以及 LMCAS::target.

被这些函数引用 difference_conditions() , 以及 sum_conditions().

函数调用图:

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

product_conditions()

ConditionSets LMCAS::anonymous_namespace{query_conditions.cpp}::product_conditions	(	const MultiplyNode &	mul,
		Sign	target )

在文件 query_conditions.cpp 第 131 行定义.

                                                                       {
    if (mul.operands().size() == 2) {
        for (std::size_t i = 0; i < 2; ++i) {
            const auto power = std::dynamic_pointer_cast<const PowerNode>(mul.operands()[i]);
            const auto exponent =
                power ? std::dynamic_pointer_cast<const NumberNode>(
                            power->exponent())
                      : nullptr;
            if (exponent && exponent->is_negative_one()) {
                return quotient_conditions(mul.operands()[1 - i], power->base(), target);
            }
        }
    }
    if (target == Sign::Positive) {
        return variable_operand_conditions(mul.operands(), Sign::Positive);
    }
    return {};
}

引用了 LMCAS::exponent, LMCAS::mul(), LMCAS::Positive, product_conditions(), quotient_conditions(), LMCAS::target , 以及 variable_operand_conditions().

被这些函数引用 product_conditions().

函数调用图:

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

quotient_conditions()

ConditionSets LMCAS::anonymous_namespace{query_conditions.cpp}::quotient_conditions	(	const std::shared_ptr< const SymbolicNode > &	numerator,
		const std::shared_ptr< const SymbolicNode > &	denominator,
		Sign	target )

在文件 query_conditions.cpp 第 100 行定义.

                                                                       {
    const auto num_var = std::dynamic_pointer_cast<const VariableNode>(numerator);
    const auto den_var = std::dynamic_pointer_cast<const VariableNode>(denominator);
    if (!num_var || num_var->is_constant() ||
        !den_var || den_var->is_constant()) return {};
    if (target == Sign::Positive) {
        ConditionSet cs1;
        cs1.sign_conditions.emplace_back(num_var->name(), Sign::Positive);
        cs1.sign_conditions.emplace_back(den_var->name(), Sign::Positive);
 
        ConditionSet cs2;
        cs2.sign_conditions.emplace_back(num_var->name(), Sign::Negative);
        cs2.sign_conditions.emplace_back(den_var->name(), Sign::Negative);
 
        return {cs1, cs2};
    } else if (target == Sign::Negative) {
        ConditionSet cs1;
        cs1.sign_conditions.emplace_back(num_var->name(), Sign::Positive);
        cs1.sign_conditions.emplace_back(den_var->name(), Sign::Negative);
 
        ConditionSet cs2;
        cs2.sign_conditions.emplace_back(num_var->name(), Sign::Negative);
        cs2.sign_conditions.emplace_back(den_var->name(), Sign::Positive);
 
        return {cs1, cs2};
    }
    return {};
}

引用了 LMCAS::denominator, LMCAS::Negative, LMCAS::Positive, quotient_conditions() , 以及 LMCAS::target.

被这些函数引用 product_conditions() , 以及 quotient_conditions().

函数调用图:

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

subtracted_operand()

std::shared_ptr< const SymbolicNode > LMCAS::anonymous_namespace{query_conditions.cpp}::subtracted_operand

(

const std::shared_ptr< const SymbolicNode > &

node

)

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

                                                   {
    const auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node);
    if (!mul || mul->operands().size() != 2) return nullptr;
    for (std::size_t j = 0; j < 2; ++j) {
        const auto coefficient =
            std::dynamic_pointer_cast<const NumberNode>(mul->operands()[j]);
        if (coefficient && coefficient->is_negative_one()) {
            return mul->operands()[1 - j];
        }
    }
    return nullptr;
}

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

被这些函数引用 subtracted_operand() , 以及 sum_conditions().

函数调用图:

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

sum_conditions()

ConditionSets LMCAS::anonymous_namespace{query_conditions.cpp}::sum_conditions	(	const AddNode &	add,
		Sign	target )

在文件 query_conditions.cpp 第 84 行定义.

                                                              {
    if (add.operands().size() == 2) {
        for (std::size_t i = 0; i < 2; ++i) {
            const auto negative = subtracted_operand(add.operands()[i]);
            if (!negative) continue;
            auto result = difference_conditions(add.operands()[1 - i], negative, target);
            if (!result.empty()) return result;
            break;
        }
    }
    if (target == Sign::Positive || target == Sign::NonNegative) {
        return variable_operand_conditions(add.operands(), target);
    }
    return {};
}

引用了 LMCAS::add(), difference_conditions(), LMCAS::NonNegative, LMCAS::Positive, subtracted_operand(), sum_conditions(), LMCAS::target , 以及 variable_operand_conditions().

被这些函数引用 sum_conditions().

函数调用图:

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

variable_operand_conditions()

ConditionSets LMCAS::anonymous_namespace{query_conditions.cpp}::variable_operand_conditions	(	const std::vector< std::shared_ptr< const SymbolicNode > > &	operands,
		Sign	target )

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

                                                                               {
    ConditionSet cs;
    for (const auto& operand : operands) {
        const auto variable = std::dynamic_pointer_cast<const VariableNode>(operand);
        if (!variable || variable->is_constant()) return {};
        cs.sign_conditions.emplace_back(variable->name(), target);
    }
    if (cs.sign_conditions.empty()) return {};
    return {cs};
}

引用了 LMCAS::target, LMCAS::variable , 以及 variable_operand_conditions().

被这些函数引用 product_conditions(), sum_conditions() , 以及 variable_operand_conditions().

函数调用图:

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