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

类
struct	CancellationFraction

类型定义
using	CancellationExpr = std::shared_ptr<SymbolicExpr>
using	CancellationNode = std::shared_ptr<const SymbolicNode>

函数
static CancellationExpr	build_product (const std::vector< CancellationNode > &factors)
template<typename Coefficient>
static void	cancel_polynomial_gcd (const Polynomial< Coefficient > &numerator, const Polynomial< Coefficient > &denominator, CancellationExpr &cur_num, CancellationExpr &cur_den, ComputationContext &context)
static CancellationExpr	cancel_variable (CancellationExpr &cur_num, CancellationExpr &cur_den, const std::string &var, const CancellationExpr &simp, ComputationContext &context)
static void	classify_fraction_factor (const CancellationNode &factor, std::vector< CancellationNode > &numerator, std::vector< CancellationNode > &denominator)
static bool	collect_fraction_terms (const AddNode &addition, std::vector< CancellationFraction > &terms, ComputationContext &context)
static CancellationFraction	combine_fraction_terms (const std::vector< CancellationFraction > &terms, ComputationContext &context)
static CancellationExpr	distinct_denominator_product (const std::vector< CancellationFraction > &terms, ComputationContext &context)
static CancellationExpr	finish_cancellation (const CancellationExpr &cur_num, const CancellationExpr &cur_den, ComputationContext &context)
static CancellationNode	positive_denominator_exponent (const NumberNode &exponent)
static CancellationExpr	reduce_fraction (CancellationFraction fraction, const CancellationExpr &simp, bool from_sum, ComputationContext &context)
static bool	same_denominators (const std::vector< CancellationFraction > &terms)
static void	separate_num_den (const CancellationNode &node, std::vector< CancellationNode > &numerator, std::vector< CancellationNode > &denominator)

---

类说明

LMCAS::anonymous_namespace{symbolic_cancel.cpp}::CancellationFraction

struct LMCAS::anonymous_namespace{symbolic_cancel.cpp}::CancellationFraction

在文件 symbolic_cancel.cpp 第 64 行定义.

LMCAS::anonymous_namespace{symbolic_cancel.cpp}::CancellationFraction 的协作图:

类成员
CancellationExpr	denominator
CancellationExpr	numerator

类型定义说明

CancellationExpr

using LMCAS::anonymous_namespace{symbolic_cancel.cpp}::CancellationExpr = std::shared_ptr<SymbolicExpr>

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

CancellationNode

using LMCAS::anonymous_namespace{symbolic_cancel.cpp}::CancellationNode = std::shared_ptr<const SymbolicNode>

在文件 symbolic_cancel.cpp 第 12 行定义.

函数说明

build_product()

CancellationExpr LMCAS::anonymous_namespace{symbolic_cancel.cpp}::build_product ( const std::vector< CancellationNode > & factors )

static

在文件 symbolic_cancel.cpp 第 58 行定义.

                                                                                  {
    if (factors.empty()) { return SymbolicExpr::number(1); }
    if (factors.size() == 1) { return detail::make_expression_ptr(factors[0]); }
    return detail::make_expression_ptr(detail::make_node<MultiplyNode>(factors));
}

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

被这些函数引用 build_product() , 以及 collect_fraction_terms().

函数调用图:

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

cancel_polynomial_gcd()

template<typename Coefficient>

void LMCAS::anonymous_namespace{symbolic_cancel.cpp}::cancel_polynomial_gcd ( const Polynomial< Coefficient > & numerator, const Polynomial< Coefficient > & denominator, CancellationExpr & cur_num, CancellationExpr & cur_den, ComputationContext & context )

static

在文件 symbolic_cancel.cpp 第 152 行定义.

                                                            {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (denominator.is_zero()) return;
    auto gcd = Polynomial<Coefficient>::gcd(numerator, denominator);
    if (gcd.degree() >= 1) {
        auto [q_num, r_num] = numerator.div_mod(gcd);
        auto [q_den, r_den] = denominator.div_mod(gcd);
        if (!r_num.is_zero() || !r_den.is_zero()) return;
        cur_num = detail::make_expression_ptr(detail::normalize_node(detail::node(poly_to_symbolic(q_num)), transform_budget));
        cur_den = detail::make_expression_ptr(detail::normalize_node(detail::node(poly_to_symbolic(q_den)), transform_budget));
    }
}

引用了 cancel_polynomial_gcd(), LMCAS::context, LMCAS::denominator, LMCAS::Polynomial< CoeffType >::div_mod(), LMCAS::Polynomial< CoeffType >::gcd(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 cancel_polynomial_gcd() , 以及 cancel_variable().

函数调用图:

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

cancel_variable()

CancellationExpr LMCAS::anonymous_namespace{symbolic_cancel.cpp}::cancel_variable ( CancellationExpr & cur_num, CancellationExpr & cur_den, const std::string & var, const CancellationExpr & simp, ComputationContext & context )

static

在文件 symbolic_cancel.cpp 第 169 行定义.

                                                                                                                {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto num_expanded = detail::make_expression_ptr(detail::expand_node(detail::node(cur_num), transform_budget));
    auto den_expanded = detail::make_expression_ptr(detail::expand_node(detail::node(cur_den), transform_budget));
    auto rational_num = symbolic_to_poly<Rational>(num_expanded, var);
    auto rational_den = symbolic_to_poly<Rational>(den_expanded, var);
    if (rational_num && rational_den) {
        if (rational_den.value().is_zero()) { return simp; }
        if (rational_num.value().is_zero()) { return SymbolicExpr::number(0); }
        cancel_polynomial_gcd(rational_num.value(), rational_den.value(), cur_num, cur_den, context);
        return nullptr;
    }
    auto symbolic_num = symbolic_to_poly<SymbolicPolyCoeff>(num_expanded, var);
    auto symbolic_den = symbolic_to_poly<SymbolicPolyCoeff>(den_expanded, var);
    if (!symbolic_num || !symbolic_den) { return nullptr; }
    if (symbolic_den.value().is_zero()) { return simp; }
    if (symbolic_num.value().is_zero()) { return SymbolicExpr::number(0); }
    cancel_polynomial_gcd(symbolic_num.value(), symbolic_den.value(), cur_num, cur_den, context);
    return nullptr;
}

引用了 cancel_polynomial_gcd(), cancel_variable(), LMCAS::context, LMCAS::detail::expand_node(), LMCAS::detail::make_expression_ptr() , 以及 LMCAS::detail::node().

被这些函数引用 cancel_variable() , 以及 reduce_fraction().

函数调用图:

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

classify_fraction_factor()

void LMCAS::anonymous_namespace{symbolic_cancel.cpp}::classify_fraction_factor ( const CancellationNode & factor, std::vector< CancellationNode > & numerator, std::vector< CancellationNode > & denominator )

static

在文件 symbolic_cancel.cpp 第 28 行定义.

                                                                                      {
    auto power = std::dynamic_pointer_cast<const PowerNode>(factor);
    if (power) {
        auto exponent = std::dynamic_pointer_cast<const NumberNode>(power->exponent());
        auto positive = exponent ? positive_denominator_exponent(*exponent) : nullptr;
        if (positive) {
            auto number = std::dynamic_pointer_cast<const NumberNode>(positive);
            if (number && number->is_one()) {
                denominator.push_back(power->base());
            } else {
                denominator.push_back(detail::make_node<PowerNode>(power->base(), positive));
            }
            return;
        }
    }
    numerator.push_back(factor);
}

引用了 classify_fraction_factor(), LMCAS::denominator, LMCAS::exponent, LMCAS::detail::make_node() , 以及 positive_denominator_exponent().

被这些函数引用 classify_fraction_factor() , 以及 separate_num_den().

函数调用图:

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

collect_fraction_terms()

bool LMCAS::anonymous_namespace{symbolic_cancel.cpp}::collect_fraction_terms ( const AddNode & addition, std::vector< CancellationFraction > & terms, ComputationContext & context )

static

在文件 symbolic_cancel.cpp 第 69 行定义.

                                                                                                        {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    bool has_denominator = false;
    for (const auto& term : addition.operands()) {
        std::vector<CancellationNode> numerator, denominator;
        separate_num_den(term, numerator, denominator);
        auto num_expr = detail::make_expression_ptr(detail::normalize_node(detail::node(build_product(numerator)), transform_budget));
        auto den_expr = detail::make_expression_ptr(detail::normalize_node(detail::node(build_product(denominator)), transform_budget));
        if (!den_expr->is_one()) { has_denominator = true; }
        terms.push_back({num_expr, den_expr});
    }
    return has_denominator;
}

引用了 build_product(), collect_fraction_terms(), LMCAS::context, LMCAS::denominator, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::AddNode::operands() , 以及 separate_num_den().

被这些函数引用 collect_fraction_terms().

函数调用图:

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

combine_fraction_terms()

CancellationFraction LMCAS::anonymous_namespace{symbolic_cancel.cpp}::combine_fraction_terms ( const std::vector< CancellationFraction > & terms, ComputationContext & context )

static

在文件 symbolic_cancel.cpp 第 118 行定义.

                                                                               {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const bool same = same_denominators(terms);
    auto denominator = same ? terms[0].denominator : distinct_denominator_product(terms, context);
    std::vector<CancellationNode> operands;
    for (const auto& term : terms) {
        auto numerator = term.numerator;
        if (!same) {
            const auto& total_node = detail::node(denominator);
            const auto& term_node = detail::node(term.denominator);
            auto factor = total_node && term_node &&
                    total_node->compare(*term_node) == 0
                ? SymbolicExpr::number(1)
                : detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(
                      denominator, term.denominator)), transform_budget));
            numerator = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(
                term.numerator, factor)), transform_budget));
        }
        if (numerator && detail::node(numerator)) {
            operands.push_back(detail::node(numerator));
        }
    }
    if (operands.empty()) { return {SymbolicExpr::number(0), nullptr}; }
    auto numerator = operands.size() == 1 ? detail::make_expression_ptr(operands[0])
        : detail::make_expression_ptr(detail::make_node<AddNode>(operands));
    numerator = same ? detail::make_expression_ptr(detail::normalize_node(detail::node(numerator), transform_budget)) : detail::make_expression_ptr(detail::expand_node(detail::node(numerator), transform_budget));
    return {numerator, denominator};
}

引用了 combine_fraction_terms(), LMCAS::SymbolicNode::compare(), LMCAS::context, LMCAS::denominator, distinct_denominator_product(), LMCAS::detail::expand_node(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 same_denominators().

被这些函数引用 combine_fraction_terms().

函数调用图:

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

distinct_denominator_product()

CancellationExpr LMCAS::anonymous_namespace{symbolic_cancel.cpp}::distinct_denominator_product ( const std::vector< CancellationFraction > & terms, ComputationContext & context )

static

在文件 symbolic_cancel.cpp 第 94 行定义.

                                                                               {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto total_den = SymbolicExpr::number(1);
    std::vector<CancellationExpr> unique_dens;
    for (const auto& term : terms) {
        if (term.denominator->is_one()) { continue; }
        bool found = false;
        for (const auto& denominator : unique_dens) {
            if (denominator->to_string() == term.denominator->to_string()) {
                found = true;
                break;
            }
        }
        if (!found) { unique_dens.push_back(term.denominator); }
    }
    for (const auto& denominator : unique_dens) {
        total_den = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(total_den, denominator)), transform_budget));
    }
    return total_den;
}

引用了 LMCAS::context, LMCAS::denominator, distinct_denominator_product(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 combine_fraction_terms() , 以及 distinct_denominator_product().

函数调用图:

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

finish_cancellation()

CancellationExpr LMCAS::anonymous_namespace{symbolic_cancel.cpp}::finish_cancellation ( const CancellationExpr & cur_num, const CancellationExpr & cur_den, ComputationContext & context )

static

在文件 symbolic_cancel.cpp 第 193 行定义.

                                                                                                           {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (cur_den->is_one()) { return cur_num; }
    if (detail::node(cur_den)) {
        auto diff = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(detail::make_expression_ptr(detail::node(cur_den)),
            SymbolicExpr::number(-1))), transform_budget));
        if (diff->is_zero()) {
            return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(SymbolicExpr::number(-1), cur_num)), transform_budget));
        }
    }
    return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(cur_num, cur_den)), transform_budget));
}

引用了 LMCAS::context, finish_cancellation(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 finish_cancellation() , 以及 reduce_fraction().

函数调用图:

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

positive_denominator_exponent()

CancellationNode LMCAS::anonymous_namespace{symbolic_cancel.cpp}::positive_denominator_exponent ( const NumberNode & exponent )

static

在文件 symbolic_cancel.cpp 第 15 行定义.

                                                                                  {
    const auto& value = exponent.value();
    if (std::holds_alternative<BigInt>(value)) {
        const auto& integer = std::get<BigInt>(value);
        if (!integer.is_negative()) { return nullptr; }
        return detail::make_node<NumberNode>(BigInt(0) - integer);
    }
    const auto& rational = std::get<Rational>(value);
    if (!rational.get_numerator().is_negative()) { return nullptr; }
    return detail::make_node<NumberNode>(Rational(
        BigInt(0) - rational.get_numerator(), rational.get_denominator()));
}

引用了 LMCAS::exponent, LMCAS::integer, LMCAS::detail::make_node(), positive_denominator_exponent(), LMCAS::rational() , 以及 LMCAS::value.

被这些函数引用 classify_fraction_factor() , 以及 positive_denominator_exponent().

函数调用图:

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

reduce_fraction()

CancellationExpr LMCAS::anonymous_namespace{symbolic_cancel.cpp}::reduce_fraction ( CancellationFraction fraction, const CancellationExpr & simp, bool from_sum, ComputationContext & context )

static

在文件 symbolic_cancel.cpp 第 209 行定义.

                                                                              {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto rational_variables = free_variables(detail::node(fraction.numerator));
    const auto denominator_variables = free_variables(detail::node(fraction.denominator));
    rational_variables.insert(denominator_variables.begin(), denominator_variables.end());
    if (!from_sum && rational_variables.empty()) {
        return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(fraction.numerator, fraction.denominator)), transform_budget));
    }
    for (const auto& var : rational_variables) {
        try {
            auto terminal = cancel_variable(
                fraction.numerator, fraction.denominator, var, simp, context);
            if (terminal) { return terminal; }
        } catch (const std::invalid_argument&) {
            continue;
        } catch (const std::out_of_range&) {
            continue;
        } catch (const std::runtime_error&) {
            continue;
        }
    }
    return finish_cancellation(fraction.numerator, fraction.denominator, context);
}

引用了 cancel_variable(), LMCAS::context, LMCAS::anonymous_namespace{symbolic_cancel.cpp}::CancellationFraction::denominator, finish_cancellation(), LMCAS::free_variables(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::CancellationFraction::numerator , 以及 reduce_fraction().

被这些函数引用 reduce_fraction().

函数调用图:

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

same_denominators()

bool LMCAS::anonymous_namespace{symbolic_cancel.cpp}::same_denominators ( const std::vector< CancellationFraction > & terms )

static

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

                                                                            {
    auto first = terms[0].denominator->to_string();
    for (size_t i = 1; i < terms.size(); ++i) {
        if (terms[i].denominator->to_string() != first) { return false; }
    }
    return true;
}

引用了 LMCAS::denominator , 以及 same_denominators().

被这些函数引用 combine_fraction_terms() , 以及 same_denominators().

函数调用图:

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

separate_num_den()

void LMCAS::anonymous_namespace{symbolic_cancel.cpp}::separate_num_den ( const CancellationNode & node, std::vector< CancellationNode > & numerator, std::vector< CancellationNode > & denominator )

static

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

                                                                                      {
    if (auto product = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        for (const auto& operand : product->operands()) {
            classify_fraction_factor(operand, numerator, denominator);
        }
    } else {
        classify_fraction_factor(node, numerator, denominator);
    }
}

引用了 classify_fraction_factor(), LMCAS::denominator , 以及 separate_num_den().

被这些函数引用 collect_fraction_terms() , 以及 separate_num_den().

函数调用图:

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