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

类
class	FormalResidual
	在原公共定义域上证明形式有理恒等式。 将不透明标量子式视为不定元，保留其点值可能为零的情况； 交叉相乘免去因式分解及符号系数 GCD。 更多...
class	ResidualBranch
struct	ResidualProfiles
class	ResidualRecursionScope

类型定义
using	RootReplacementResult

函数
Result< void >	check_residual_coefficient (const Rational &value, ComputationContext &context, const std::string &operation)
ResidualCheckResult	classify_residual (const ExprPtr &expression, detail::RewriteBudget &budget, const std::string &operation)
void	collect_function_profile (const FunctionNode &function, ResidualProfiles &profiles)
void	collect_residual_profile_children (const std::vector< detail::SymbolicNodePtr > &children, ResidualProfiles &profiles)
void	collect_residual_profiles (const detail::SymbolicNodePtr &node, ResidualProfiles &profiles)
Result< bool >	has_zero_root_remainder (Polynomial< Rational > remainder, const Polynomial< Rational > &defining, ComputationContext &context, const std::string &operation)
bool	is_decided (const ResidualCheck &result)
ResidualCheckResult	prove_exact_root_residual (const ExprPtr &expression, detail::RewriteBudget &budget, const std::string &operation)
ResidualCheckResult	prove_normalized_residual (const ExprPtr &residual, detail::RewriteBudget &budget, const EqvOptions &options, const std::string &operation)
std::optional< ResidualCheckResult >	prove_piecewise_residual (const ExprPtr &residual, detail::RewriteBudget &budget, const EqvOptions &options)
ResidualCheckResult	prove_with_profiles (const ExprPtr &current, ComputationContext &context, const EqvOptions &options)
RootReplacementResult	replace_exact_root (const detail::SymbolicNodePtr &node, const detail::ExactRootId *&identity, detail::RewriteBudget &budget, const std::string &operation)
RootReplacementResult	replace_root_operands (const detail::SymbolicNodePtr &node, const std::vector< detail::SymbolicNodePtr > &operands, bool sum, const detail::ExactRootId *&identity, detail::RewriteBudget &budget, const std::string &operation)
RootReplacementResult	replace_root_power (const detail::SymbolicNodePtr &node, const PowerNode &power, const detail::ExactRootId *&identity, detail::RewriteBudget &budget, const std::string &operation)
const PiecewiseNode *	residual_piecewise (const detail::SymbolicNodePtr &node, detail::RewriteBudget &budget)

---

类说明

LMCAS::anonymous_namespace{residual_verification.cpp}::ResidualProfiles

struct LMCAS::anonymous_namespace{residual_verification.cpp}::ResidualProfiles

在文件 residual_verification.cpp 第 849 行定义.

LMCAS::anonymous_namespace{residual_verification.cpp}::ResidualProfiles 的协作图:

类成员
bool	exp_log = false
bool	trig = false

类型定义说明

RootReplacementResult

using LMCAS::anonymous_namespace{residual_verification.cpp}::RootReplacementResult

初始值:

 
Result<std::optional<detail::SymbolicNodePtr>>

在文件 residual_verification.cpp 第 27 行定义.

函数说明

check_residual_coefficient()

Result< void > LMCAS::anonymous_namespace{residual_verification.cpp}::check_residual_coefficient	(	const Rational &	value,
		ComputationContext &	context,
		const std::string &	operation )

在文件 residual_verification.cpp 第 737 行定义.

                                {
    return context.require_integer_bits(std::max(
        value.get_numerator().bit_length(),
        value.get_denominator().bit_length()), operation);
}

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

被这些函数引用 check_residual_coefficient() , 以及 has_zero_root_remainder().

函数调用图:

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

classify_residual()

ResidualCheckResult LMCAS::anonymous_namespace{residual_verification.cpp}::classify_residual	(	const ExprPtr &	expression,
		detail::RewriteBudget &	budget,
		const std::string &	operation )

在文件 residual_verification.cpp 第 809 行定义.

                                {
    auto& context = budget.context();
    auto root_proof = prove_exact_root_residual(expression, budget, operation);
    if (!root_proof ||
        std::holds_alternative<ProvedZeroResidual>(root_proof.value())) {
        return root_proof;
    }
    auto proof = detail::classify_exact_zero(
        expression, context, operation);
    if (!proof) { return ResidualCheckResult::failure(proof.error()); }
    if (proof.value() == detail::ZeroProof::Zero) {
        return ResidualCheckResult::success(ProvedZeroResidual{
            ExactNormalizationProof{expression}});
    }
    const auto variables = free_variables(detail::node(expression), &budget);
    if (variables.size() == 1) {
        auto polynomial = recognize_rational_polynomial(
            *expression, *variables.begin(), context);
        if (!polynomial) {
            return ResidualCheckResult::failure(polynomial.error());
        }
        if (polynomial.value() && !polynomial.value()->is_zero()) {
            return ResidualCheckResult::success(
                ProvedNonIdentityResidual{expression});
        }
    }
    if (proof.value() == detail::ZeroProof::NonZero) {
        return ResidualCheckResult::success(
            ProvedNonIdentityResidual{expression});
    }
    return ResidualCheckResult::success(UnprovedResidual{expression});
}

引用了 LMCAS::detail::classify_exact_zero(), classify_residual(), LMCAS::context, LMCAS::detail::RewriteBudget::context(), LMCAS::Result< ResidualCheck >::failure(), LMCAS::free_variables(), LMCAS::detail::node(), LMCAS::detail::NonZero, prove_exact_root_residual(), LMCAS::recognize_rational_polynomial(), LMCAS::Result< ResidualCheck >::success() , 以及 LMCAS::detail::Zero.

被这些函数引用 classify_residual() , 以及 prove_normalized_residual().

函数调用图:

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

collect_function_profile()

void LMCAS::anonymous_namespace{residual_verification.cpp}::collect_function_profile	(	const FunctionNode &	function,
		ResidualProfiles &	profiles )

在文件 residual_verification.cpp 第 865 行定义.

                                                              {
    profiles.trig = profiles.trig ||
        function.type() == FunctionNode::FuncType::Sin ||
        function.type() == FunctionNode::FuncType::Cos;
    profiles.exp_log = profiles.exp_log ||
        function.type() == FunctionNode::FuncType::Exp ||
        function.type() == FunctionNode::FuncType::Ln;
    collect_residual_profile_children(function.arguments(), profiles);
}

引用了 collect_function_profile(), collect_residual_profile_children(), LMCAS::FunctionNode::Cos, LMCAS::FunctionNode::Exp, LMCAS::anonymous_namespace{residual_verification.cpp}::ResidualProfiles::exp_log, LMCAS::function(), LMCAS::FunctionNode::Ln, LMCAS::FunctionNode::Sin , 以及 LMCAS::anonymous_namespace{residual_verification.cpp}::ResidualProfiles::trig.

被这些函数引用 collect_function_profile() , 以及 collect_residual_profiles().

函数调用图:

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

collect_residual_profile_children()

void LMCAS::anonymous_namespace{residual_verification.cpp}::collect_residual_profile_children	(	const std::vector< detail::SymbolicNodePtr > &	children,
		ResidualProfiles &	profiles )

在文件 residual_verification.cpp 第 857 行定义.

                                {
    for (const auto& child : children) {
        collect_residual_profiles(child, profiles);
    }
}

引用了 collect_residual_profile_children() , 以及 collect_residual_profiles().

被这些函数引用 collect_function_profile(), collect_residual_profile_children() , 以及 collect_residual_profiles().

函数调用图:

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

collect_residual_profiles()

void LMCAS::anonymous_namespace{residual_verification.cpp}::collect_residual_profiles	(	const detail::SymbolicNodePtr &	node,
		ResidualProfiles &	profiles )

在文件 residual_verification.cpp 第 876 行定义.

                                                                   {
    if (!node || (profiles.trig && profiles.exp_log)) {
        return;
    }
    if (const auto function =
            std::dynamic_pointer_cast<const FunctionNode>(node)) {
        collect_function_profile(*function, profiles);
        return;
    }
    if (const auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        collect_residual_profile_children(add->operands(), profiles);
        return;
    }
    if (const auto multiply =
            std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        collect_residual_profile_children(multiply->operands(), profiles);
        return;
    }
    if (const auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        collect_residual_profiles(power->base(), profiles);
        collect_residual_profiles(power->exponent(), profiles);
        return;
    }
    if (const auto complex =
            std::dynamic_pointer_cast<const ComplexNode>(node)) {
        collect_residual_profiles(complex->real(), profiles);
        collect_residual_profiles(complex->imag(), profiles);
    }
}

引用了 LMCAS::add(), collect_function_profile(), collect_residual_profile_children(), collect_residual_profiles(), LMCAS::complex(), LMCAS::anonymous_namespace{residual_verification.cpp}::ResidualProfiles::exp_log, LMCAS::function() , 以及 LMCAS::anonymous_namespace{residual_verification.cpp}::ResidualProfiles::trig.

被这些函数引用 collect_residual_profile_children(), collect_residual_profiles() , 以及 prove_with_profiles().

函数调用图:

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

has_zero_root_remainder()

Result< bool > LMCAS::anonymous_namespace{residual_verification.cpp}::has_zero_root_remainder	(	Polynomial< Rational >	remainder,
		const Polynomial< Rational > &	defining,
		ComputationContext &	context,
		const std::string &	operation )

在文件 residual_verification.cpp 第 745 行定义.

                                {
    auto terms = context.require_expansion_terms(
        std::max(remainder.coeffs.size(), defining.coeffs.size()), operation);
    if (!terms) return Result<bool>::failure(terms.error());
    for (const auto& coefficient : remainder.coeffs) {
        auto checked = check_residual_coefficient(coefficient, context, operation);
        if (!checked) return Result<bool>::failure(checked.error());
    }
    for (const auto& coefficient : defining.coeffs) {
        auto checked = check_residual_coefficient(coefficient, context, operation);
        if (!checked) return Result<bool>::failure(checked.error());
    }
    while (remainder.degree() >= defining.degree()) {
        const auto offset = remainder.coeffs.size() - defining.coeffs.size();
        const auto& factor = remainder.coeffs.back();
        for (std::size_t index = 0; index + 1 < defining.coeffs.size(); ++index) {
            auto step = context.consume_steps(1, operation);
            if (!step) return Result<bool>::failure(step.error());
            auto product = factor * defining.coeffs[index];
            auto checked = check_residual_coefficient(product, context, operation);
            if (!checked) return Result<bool>::failure(checked.error());
            auto& coefficient = remainder.coeffs[offset + index];
            coefficient = coefficient - product;
            checked = check_residual_coefficient(coefficient, context, operation);
            if (!checked) return Result<bool>::failure(checked.error());
        }
        remainder.coeffs.pop_back();
        remainder.trim();
    }
    return Result<bool>::success(remainder.is_zero());
}

引用了 check_residual_coefficient(), LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Result< T >::failure(), has_zero_root_remainder(), LMCAS::Polynomial< CoeffType >::is_zero(), LMCAS::Result< T >::success() , 以及 LMCAS::Polynomial< CoeffType >::trim().

被这些函数引用 has_zero_root_remainder() , 以及 prove_exact_root_residual().

函数调用图:

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

is_decided()

bool LMCAS::anonymous_namespace{residual_verification.cpp}::is_decided

(

const ResidualCheck &

result

)

在文件 residual_verification.cpp 第 845 行定义.

                                             {
    return !std::holds_alternative<UnprovedResidual>(result);
}

引用了 is_decided().

被这些函数引用 is_decided() , 以及 prove_normalized_residual().

函数调用图:

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

prove_exact_root_residual()

ResidualCheckResult LMCAS::anonymous_namespace{residual_verification.cpp}::prove_exact_root_residual	(	const ExprPtr &	expression,
		detail::RewriteBudget &	budget,
		const std::string &	operation )

在文件 residual_verification.cpp 第 781 行定义.

                                {
    auto& context = budget.context();
    const detail::ExactRootId* identity = nullptr;
    auto replaced = replace_exact_root(
        detail::node(expression), identity, budget, operation);
    if (!replaced) return ResidualCheckResult::failure(replaced.error());
    if (!replaced.value() || !identity) {
        return ResidualCheckResult::success(UnprovedResidual{expression});
    }
    auto polynomial = recognize_rational_polynomial(
        *detail::make_expression_ptr(*replaced.value()),
        "_residual_root", context);
    if (!polynomial) return ResidualCheckResult::failure(polynomial.error());
    if (polynomial.value()) {
        auto zero = has_zero_root_remainder(
            std::move(*polynomial.value()), identity->polynomial, context, operation);
        if (!zero) return ResidualCheckResult::failure(zero.error());
        if (zero.value()) {
            return ResidualCheckResult::success(ProvedZeroResidual{
                ExactResidualProof{expression}});
        }
    }
    return ResidualCheckResult::success(UnprovedResidual{expression});
}

引用了 LMCAS::context, LMCAS::detail::RewriteBudget::context(), LMCAS::Result< ResidualCheck >::failure(), has_zero_root_remainder(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::ExactRootId::polynomial, prove_exact_root_residual(), LMCAS::recognize_rational_polynomial(), replace_exact_root() , 以及 LMCAS::Result< ResidualCheck >::success().

被这些函数引用 classify_residual() , 以及 prove_exact_root_residual().

函数调用图:

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

prove_normalized_residual()

ResidualCheckResult LMCAS::anonymous_namespace{residual_verification.cpp}::prove_normalized_residual	(	const ExprPtr &	residual,
		detail::RewriteBudget &	budget,
		const EqvOptions &	options,
		const std::string &	operation )

通分证明受计算预算约束，替代符号系数的 Euclid 及因子搜索。 支持绑定整数名同时出现在参数分母中的解族。

在文件 residual_verification.cpp 第 937 行定义.

                                                                                        {
    auto& context = budget.context();
    std::optional<detail::AssumptionFacts> assumed;
    if (context.assumptions()) { assumed.emplace(*context.assumptions()); }
    const auto& facts = assumed
        ? static_cast<const FactsQuery&>(*assumed) : detail::no_facts();
    auto current = detail::make_expression_ptr(
        detail::normalize_node(detail::node(residual), budget, facts));
    auto first = classify_residual(current, budget, operation);
    if (!first || is_decided(first.value())) { return first; }
    current = detail::make_expression_ptr(
        detail::expand_node(detail::node(current), budget, facts));
    auto expanded = classify_residual(current, budget, operation);
    if (!expanded || is_decided(expanded.value())) { return expanded; }
    /**
     * @brief 通分证明受计算预算约束，替代符号系数的 Euclid 及因子搜索。
     * 支持绑定整数名同时出现在参数分母中的解族。
     */
    auto formal = FormalResidual(budget).prove(detail::node(current));
    if (!formal) { return ResidualCheckResult::failure(formal.error()); }
    if (formal.value()) {
        return ResidualCheckResult::success(ProvedZeroResidual{ExactResidualProof{current}});
    }
    return prove_with_profiles(current, context, options);
}

引用了 classify_residual(), LMCAS::context, LMCAS::detail::RewriteBudget::context(), LMCAS::detail::expand_node(), LMCAS::Result< ResidualCheck >::failure(), is_decided(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::no_facts(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::options, LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::prove(), prove_normalized_residual(), prove_with_profiles() , 以及 LMCAS::Result< ResidualCheck >::success().

被这些函数引用 prove_normalized_residual().

函数调用图:

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

prove_piecewise_residual()

std::optional< ResidualCheckResult > LMCAS::anonymous_namespace{residual_verification.cpp}::prove_piecewise_residual	(	const ExprPtr &	residual,
		detail::RewriteBudget &	budget,
		const EqvOptions &	options )

在文件 residual_verification.cpp 第 1009 行定义.

                               {
    const auto* piecewise = residual_piecewise(detail::node(residual), budget);
    if (!piecewise) { return std::nullopt; }
    auto& context = budget.context();
    auto entered = context.enter_recursion("residual.piecewise");
    if (!entered) { return ResidualCheckResult::failure(entered.error()); }
    ResidualRecursionScope scope(context);
    const auto count = piecewise->branches().size() +
        static_cast<std::size_t>(piecewise->default_expr() != nullptr);
    for (std::size_t index = 0; index < count; ++index) {
        ResidualBranch select(*piecewise, index, budget);
        auto branch = select.rewrite(detail::node(residual));
        budget.measure(branch);
        auto proof = check_zero_residual(detail::make_expression_ptr(branch), context, options);
        if (!proof) { return proof; }
        if (!std::holds_alternative<ProvedZeroResidual>(proof.value())) {
            return ResidualCheckResult::success(UnprovedResidual{residual});
        }
    }
    return ResidualCheckResult::success(
        ProvedZeroResidual{ExactResidualProof{residual}});
}

引用了 LMCAS::check_zero_residual(), LMCAS::context, LMCAS::detail::RewriteBudget::context(), LMCAS::Result< ResidualCheck >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::node(), LMCAS::options, prove_piecewise_residual(), residual_piecewise(), LMCAS::detail::SymbolicRewriter::rewrite() , 以及 LMCAS::Result< ResidualCheck >::success().

被这些函数引用 prove_piecewise_residual().

函数调用图:

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

prove_with_profiles()

ResidualCheckResult LMCAS::anonymous_namespace{residual_verification.cpp}::prove_with_profiles	(	const ExprPtr &	current,
		ComputationContext &	context,
		const EqvOptions &	options )

在文件 residual_verification.cpp 第 907 行定义.

                               {
    ResidualProfiles required;
    collect_residual_profiles(detail::node(current), required);
    const auto zero = SymbolicExpr::number(0);
    for (const auto profile : {
             EqvProfile::Core, EqvProfile::TrigBasic, EqvProfile::ExpLogBasic}) {
        if ((profile == EqvProfile::TrigBasic && !required.trig) ||
            (profile == EqvProfile::ExpLogBasic && !required.exp_log)) {
            continue;
        }
        auto profile_options = options;
        profile_options.profile = profile;
        auto equivalent = detail::equivalent_impl(*current, *zero, context, profile_options);
        if (!equivalent) {
            if (equivalent.error().code == CasErrc::UnsupportedExpression ||
                equivalent.error().code == CasErrc::Inconclusive) {
                continue;
            }
            return ResidualCheckResult::failure(equivalent.error());
        }
        if (equivalent.value()) {
            return ResidualCheckResult::success(ProvedZeroResidual{
                ExactResidualProof{current}});
        }
    }
    return ResidualCheckResult::success(UnprovedResidual{current});
}

引用了 LMCAS::CasError::code, collect_residual_profiles(), LMCAS::context, LMCAS::Core, LMCAS::equivalent(), LMCAS::detail::equivalent_impl(), LMCAS::Result< T >::error(), LMCAS::anonymous_namespace{residual_verification.cpp}::ResidualProfiles::exp_log, LMCAS::ExpLogBasic, LMCAS::Result< ResidualCheck >::failure(), LMCAS::Inconclusive, LMCAS::detail::node(), LMCAS::options, prove_with_profiles(), LMCAS::Result< ResidualCheck >::success(), LMCAS::anonymous_namespace{residual_verification.cpp}::ResidualProfiles::trig, LMCAS::TrigBasic, LMCAS::UnsupportedExpression , 以及 LMCAS::Result< T >::value().

被这些函数引用 prove_normalized_residual() , 以及 prove_with_profiles().

函数调用图:

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

replace_exact_root()

RootReplacementResult LMCAS::anonymous_namespace{residual_verification.cpp}::replace_exact_root	(	const detail::SymbolicNodePtr &	node,
		const detail::ExactRootId *&	identity,
		detail::RewriteBudget &	budget,
		const std::string &	operation )

在文件 residual_verification.cpp 第 704 行定义.

                                {
    auto& context = budget.context();
    auto entered = context.enter_recursion(operation);
    if (!entered) { return RootReplacementResult::failure(entered.error()); }
    ResidualRecursionScope scope(context);
    if (const auto* root = dynamic_cast<const RootOfNode*>(node.get())) {
        if (identity && identity->compare(root->exact_id()) != 0) {
            return RootReplacementResult::success(std::nullopt);
        }
        identity = &root->exact_id();
        budget.require_nodes(1);
        return RootReplacementResult::success(
            SymbolicFactory::create_variable("_residual_root"));
    }
    if (dynamic_cast<const NumberNode*>(node.get())) {
        return RootReplacementResult::success(node);
    }
    const auto* sum = dynamic_cast<const AddNode*>(node.get());
    const auto* product = dynamic_cast<const MultiplyNode*>(node.get());
    if (sum || product) {
        const auto& operands = sum ? sum->operands() : product->operands();
        return replace_root_operands(node, operands, sum != nullptr, identity, budget, operation);
    }
    if (const auto* power = dynamic_cast<const PowerNode*>(node.get())) {
        return replace_root_power(node, *power, identity, budget, operation);
    }
    return RootReplacementResult::success(std::nullopt);
}

引用了 LMCAS::detail::ExactRootId::compare(), LMCAS::context, LMCAS::detail::RewriteBudget::context(), LMCAS::SymbolicFactory::create_variable(), LMCAS::Result< std::optional< detail::SymbolicNodePtr > >::failure(), replace_exact_root(), replace_root_operands(), replace_root_power(), LMCAS::detail::RewriteBudget::require_nodes() , 以及 LMCAS::Result< std::optional< detail::SymbolicNodePtr > >::success().

被这些函数引用 prove_exact_root_residual(), replace_exact_root(), replace_root_operands() , 以及 replace_root_power().

函数调用图:

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

replace_root_operands()

RootReplacementResult LMCAS::anonymous_namespace{residual_verification.cpp}::replace_root_operands	(	const detail::SymbolicNodePtr &	node,
		const std::vector< detail::SymbolicNodePtr > &	operands,
		bool	sum,
		const detail::ExactRootId *&	identity,
		detail::RewriteBudget &	budget,
		const std::string &	operation )

在文件 residual_verification.cpp 第 665 行定义.

                                                                                                 {
    bool changed = false;
    std::vector<detail::SymbolicNodePtr> replaced;
    std::size_t nodes = 1;
    for (auto operand = operands.begin(); operand != operands.end(); ++operand) {
        auto child = replace_exact_root(*operand, identity, budget, operation);
        if (!child || !child.value()) { return child; }
        nodes = budget.append_size(nodes, budget.measure(*child.value()));
        if (!changed && *child.value() != *operand) {
            replaced.reserve(operands.size());
            replaced.insert(replaced.end(), operands.begin(), operand);
            changed = true;
        }
        if (changed) { replaced.push_back(std::move(*child.value())); }
    }
    if (!changed) { return RootReplacementResult::success(node); }
    return RootReplacementResult::success(sum
        ? SymbolicFactory::create_add(std::move(replaced), &budget)
        : SymbolicFactory::create_multiply(std::move(replaced), &budget));
}

引用了 LMCAS::detail::RewriteBudget::append_size(), LMCAS::SymbolicFactory::create_add(), LMCAS::SymbolicFactory::create_multiply(), LMCAS::detail::RewriteBudget::measure(), replace_exact_root(), replace_root_operands() , 以及 LMCAS::Result< std::optional< detail::SymbolicNodePtr > >::success().

被这些函数引用 replace_exact_root() , 以及 replace_root_operands().

函数调用图:

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

replace_root_power()

RootReplacementResult LMCAS::anonymous_namespace{residual_verification.cpp}::replace_root_power	(	const detail::SymbolicNodePtr &	node,
		const PowerNode &	power,
		const detail::ExactRootId *&	identity,
		detail::RewriteBudget &	budget,
		const std::string &	operation )

在文件 residual_verification.cpp 第 688 行定义.

                                                             {
    auto base = replace_exact_root(power.base(), identity, budget, operation);
    if (!base || !base.value()) { return base; }
    auto exponent = replace_exact_root(power.exponent(), identity, budget, operation);
    if (!exponent || !exponent.value()) { return exponent; }
    if (*base.value() == power.base() && *exponent.value() == power.exponent()) {
        return RootReplacementResult::success(node);
    }
    budget.append_size(budget.append_size(1, budget.measure(*base.value())),
                       budget.measure(*exponent.value()));
    return RootReplacementResult::success(
        SymbolicFactory::create_power(*base.value(), *exponent.value()));
}

引用了 LMCAS::detail::RewriteBudget::append_size(), LMCAS::PowerNode::base(), LMCAS::SymbolicFactory::create_power(), LMCAS::exponent, LMCAS::PowerNode::exponent(), LMCAS::detail::RewriteBudget::measure(), replace_exact_root(), replace_root_power() , 以及 LMCAS::Result< std::optional< detail::SymbolicNodePtr > >::success().

被这些函数引用 replace_exact_root() , 以及 replace_root_power().

函数调用图:

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

residual_piecewise()

const PiecewiseNode * LMCAS::anonymous_namespace{residual_verification.cpp}::residual_piecewise	(	const detail::SymbolicNodePtr &	node,
		detail::RewriteBudget &	budget )

在文件 residual_verification.cpp 第 964 行定义.

                                                                    {
    detail::RewriteScope scope(&budget);
    if (const auto* piecewise = dynamic_cast<const PiecewiseNode*>(node.get())) {
        return piecewise;
    }
    const auto* add = dynamic_cast<const AddNode*>(node.get());
    const auto* mul = dynamic_cast<const MultiplyNode*>(node.get());
    if (add || mul) {
        for (const auto& child : add ? add->operands() : mul->operands()) {
            if (auto piecewise = residual_piecewise(child, budget)) { return piecewise; }
        }
    }
    if (const auto* power = dynamic_cast<const PowerNode*>(node.get())) {
        return residual_piecewise(power->base(), budget);
    }
    return nullptr;
}

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

被这些函数引用 prove_piecewise_residual() , 以及 residual_piecewise().

函数调用图:

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