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

函数
void	append_finite_union (FiniteSolutions &finite, FiniteSolutions &prior)
void	append_parametric_union (FiniteSolutions *finite, ParametricSolutions *families, FiniteSolutions *prior, SolutionSet &output)
void	append_solutions (SolutionSet solved, SolutionSet &output, const ExprPtr &original, const std::string &var)
Result< void >	coalesce_periodic_families (SolutionSet &solutions, ComputationContext &context)
Result< bool >	coalesce_periodic_pair (ParametricSolution &left, const ParametricSolution &right, ComputationContext &context)
bool	compatible_periodic_conditions (const ParametricSolution &left, const ParametricSolution &right)
SolveResult	inconclusive (const char *message)
Result< std::optional< ExprPtr > >	merged_half_period_value (const detail::AffineForm &first, const detail::AffineForm &second, const std::string &parameter, ComputationContext &context)
SolveResult	solve_function_pattern (const InversePattern &pattern, const ExprPtr &original, const std::string &var, ComputationContext &context, const SolveOptions &options, int depth)
SolveResult	solve_inner_equation (const ExprPtr &original, const ExprPtr &inner, const ExprPtr &value, const std::string &var, ComputationContext &context, const SolveOptions &options, int depth)
SolveResult	solve_inverted_values (const ExprPtr &original, const ExprPtr &inner, const std::vector< ExprPtr > &values, const std::string &var, ComputationContext &context, const SolveOptions &options, int depth)
SolveResult	solve_substitution (const ExprPtr &original, const SubstitutionResult &substitution, const std::string &var, ComputationContext &context, const SolveOptions &options, int depth)
SolveResult	solve_transcendental_constant (const ExprPtr &original, const ExprPtr &expr, const std::string &var, ComputationContext &context)
SolveResult	solve_transcendental_impl (const ExprPtr &original, const ExprPtr &expr, const std::string &var, ComputationContext &context, const SolveOptions &options, int depth)
Result< bool >	zero_difference (const ExprPtr &left, const ExprPtr &right, ComputationContext &context)

变量
constexpr int	maximum_transcendental_depth = 5

函数说明

append_finite_union()

void LMCAS::anonymous_namespace{solve_transcendental.cpp}::append_finite_union	(	FiniteSolutions &	finite,
		FiniteSolutions &	prior )

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

                                                                          {
    for (auto& candidate : finite.values) {
        auto duplicate = std::find_if(prior.values.begin(), prior.values.end(),
            [&](const FiniteSolution& previous) {
                return candidate.conditions.empty() && previous.conditions.empty() &&
                    detail::node(candidate.value)->equals(*detail::node(previous.value));
            });
        if (duplicate == prior.values.end()) { prior.values.push_back(std::move(candidate)); }
    }
}

引用了 append_finite_union() , 以及 LMCAS::FiniteSolutions::values.

被这些函数引用 append_finite_union() , 以及 append_solutions().

函数调用图:

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

append_parametric_union()

void LMCAS::anonymous_namespace{solve_transcendental.cpp}::append_parametric_union	(	FiniteSolutions *	finite,
		ParametricSolutions *	families,
		FiniteSolutions *	prior,
		SolutionSet &	output )

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

                                                 {
    if (prior) {
        ParametricSolutions promoted;
        for (auto& point : prior->values) {
            promoted.values.push_back({std::move(point.value), {}, std::move(point.conditions)});
        }
        output = std::move(promoted);
    }
    auto& result = std::get<ParametricSolutions>(output).values;
    if (finite) {
        for (auto& point : finite->values) {
            result.push_back({std::move(point.value), {}, std::move(point.conditions)});
        }
    } else {
        for (auto& family : families->values) { result.push_back(std::move(family)); }
    }
}

引用了 append_parametric_union(), LMCAS::point, LMCAS::FiniteSolutions::values , 以及 LMCAS::ParametricSolutions::values.

被这些函数引用 append_parametric_union() , 以及 append_solutions().

函数调用图:

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

append_solutions()

void LMCAS::anonymous_namespace{solve_transcendental.cpp}::append_solutions	(	SolutionSet	solved,
		SolutionSet &	output,
		const ExprPtr &	original,
		const std::string &	var )

在文件 solve_transcendental.cpp 第 103 行定义.

                                                                     {
    if (std::holds_alternative<EmptySolutions>(solved) ||
        std::holds_alternative<UniversalSolutions>(output)) { return; }
    if (std::holds_alternative<EmptySolutions>(output) ||
        std::holds_alternative<UniversalSolutions>(solved)) {
        output = std::move(solved);
        return;
    }
    auto* finite = std::get_if<FiniteSolutions>(&solved);
    auto* prior = std::get_if<FiniteSolutions>(&output);
    if (finite && prior) {
        append_finite_union(*finite, *prior);
        return;
    }
    auto* families = std::get_if<ParametricSolutions>(&solved);
    if ((finite || families) && (prior || std::holds_alternative<ParametricSolutions>(output))) {
        append_parametric_union(finite, families, prior, output);
        return;
    }
    output = conditional_preimage(original, var);
}

引用了 append_finite_union(), append_parametric_union(), append_solutions() , 以及 LMCAS::detail::transcendental::conditional_preimage().

被这些函数引用 append_solutions(), solve_function_pattern(), solve_inverted_values() , 以及 solve_substitution().

函数调用图:

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

coalesce_periodic_families()

Result< void > LMCAS::anonymous_namespace{solve_transcendental.cpp}::coalesce_periodic_families	(	SolutionSet &	solutions,
		ComputationContext &	context )

在文件 solve_transcendental.cpp 第 199 行定义.

                                                                                             {
    auto* parametric = std::get_if<ParametricSolutions>(&solutions);
    if (!parametric) { return Result<void>::success(); }
    auto& families = parametric->values;
    for (std::size_t i = 0; i < families.size(); ++i) {
        if (families[i].integer_parameters.size() != 1) { continue; }
        for (std::size_t j = i + 1; j < families.size();) {
            auto merged = coalesce_periodic_pair(families[i], families[j], context);
            if (!merged) { return Result<void>::failure(merged.error()); }
            if (!merged.value()) { ++j; continue; }
            families.erase(families.begin() + j);
            j = i + 1;
        }
    }
    return Result<void>::success();
}

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

被这些函数引用 coalesce_periodic_families().

函数调用图:

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

coalesce_periodic_pair()

Result< bool > LMCAS::anonymous_namespace{solve_transcendental.cpp}::coalesce_periodic_pair	(	ParametricSolution &	left,
		const ParametricSolution &	right,
		ComputationContext &	context )

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

                                 {
    if (!compatible_periodic_conditions(left, right)) { return false; }
    auto first = detail::recognize_affine(*left.value, left.integer_parameters.front(), context);
    if (!first) { return Result<bool>::failure(first.error()); }
    auto second = detail::recognize_affine(*right.value, right.integer_parameters.front(), context);
    if (!second) { return Result<bool>::failure(second.error()); }
    if (!first.value() || !second.value()) { return false; }
    for (auto* coefficient : {&first.value()->slope, &first.value()->offset,
                              &second.value()->slope, &second.value()->offset}) {
        auto normalized = detail::simplify_expression(*coefficient, context);
        if (!normalized) { return Result<bool>::failure(normalized.error()); }
        *coefficient = std::move(normalized.value());
    }
    auto equal_slopes = zero_difference(first.value()->slope, second.value()->slope, context);
    if (!equal_slopes) { return Result<bool>::failure(equal_slopes.error()); }
    if (!equal_slopes.value()) { return false; }
    auto merged = merged_half_period_value(
        *first.value(), *second.value(), left.integer_parameters.front(), context);
    if (!merged) { return Result<bool>::failure(merged.error()); }
    if (!merged.value()) { return false; }
    left.value = std::move(*merged.value());
    return true;
}

引用了 coalesce_periodic_pair(), compatible_periodic_conditions(), LMCAS::context, LMCAS::Result< T >::failure(), LMCAS::ParametricSolution::integer_parameters, merged_half_period_value(), LMCAS::detail::recognize_affine(), LMCAS::right, LMCAS::detail::simplify_expression(), LMCAS::ParametricSolution::value , 以及 zero_difference().

被这些函数引用 coalesce_periodic_families() , 以及 coalesce_periodic_pair().

函数调用图:

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

compatible_periodic_conditions()

bool LMCAS::anonymous_namespace{solve_transcendental.cpp}::compatible_periodic_conditions	(	const ParametricSolution &	left,
		const ParametricSolution &	right )

在文件 solve_transcendental.cpp 第 135 行定义.

                                                                                                     {
    if (right.integer_parameters.size() != 1 || left.conditions.size() != right.conditions.size()) {
        return false;
    }
    for (std::size_t c = 0; c < left.conditions.size(); ++c) {
        if (expression_depends_on_variable(detail::node(left.conditions[c]),
                                          left.integer_parameters.front()) ||
            expression_depends_on_variable(detail::node(right.conditions[c]),
                                          right.integer_parameters.front()) ||
            !detail::node(left.conditions[c])->equals(*detail::node(right.conditions[c]))) {
            return false;
        }
    }
    return true;
}

引用了 LMCAS::c, compatible_periodic_conditions(), LMCAS::ParametricSolution::conditions, LMCAS::expression_depends_on_variable(), LMCAS::ParametricSolution::integer_parameters, LMCAS::detail::node() , 以及 LMCAS::right.

被这些函数引用 coalesce_periodic_pair() , 以及 compatible_periodic_conditions().

函数调用图:

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

inconclusive()

SolveResult LMCAS::anonymous_namespace{solve_transcendental.cpp}::inconclusive

(

const char *

message

)

在文件 solve_transcendental.cpp 第 20 行定义.

                                              {
    return SolveResult::failure(CasErrc::Inconclusive, message, "solve.transcendental");
}

引用了 LMCAS::Result< SolutionSet >::failure(), LMCAS::Inconclusive , 以及 inconclusive().

被这些函数引用 inconclusive(), solve_inverted_values(), solve_substitution() , 以及 solve_transcendental_impl().

函数调用图:

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

merged_half_period_value()

Result< std::optional< ExprPtr > > LMCAS::anonymous_namespace{solve_transcendental.cpp}::merged_half_period_value	(	const detail::AffineForm &	first,
		const detail::AffineForm &	second,
		const std::string &	parameter,
		ComputationContext &	context )

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

                                                                                             {
    using MergeResult = Result<std::optional<ExprPtr>>;
    auto half = detail::simplify_expression(SymbolicExpr::multiply(
        SymbolicExpr::number(Rational(1, 2)), first.slope), context);
    if (!half) { return MergeResult::failure(half.error()); }
    const auto& half_period = half.value();
    auto next_offset = SymbolicExpr::add(first.offset, half_period);
    auto prior_offset = SymbolicExpr::add(second.offset, half_period);
    ExprPtr offset;
    auto forward = zero_difference(next_offset, second.offset, context);
    if (!forward) { return MergeResult::failure(forward.error()); }
    auto backward = zero_difference(prior_offset, first.offset, context);
    if (!backward) { return MergeResult::failure(backward.error()); }
    if (forward.value()) { offset = second.offset; }
    else if (backward.value()) { offset = first.offset; }
    else { return std::optional<ExprPtr>{}; }
    auto merged = detail::simplify_expression(SymbolicExpr::add(offset,
        SymbolicExpr::multiply(half_period, SymbolicExpr::variable(parameter))), context);
    if (!merged) { return MergeResult::failure(merged.error()); }
    return std::optional<ExprPtr>{std::move(merged.value())};
}

引用了 LMCAS::context, merged_half_period_value(), LMCAS::detail::AffineForm::offset, LMCAS::detail::simplify_expression(), LMCAS::detail::AffineForm::slope , 以及 zero_difference().

被这些函数引用 coalesce_periodic_pair() , 以及 merged_half_period_value().

函数调用图:

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

solve_function_pattern()

SolveResult LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_function_pattern	(	const InversePattern &	pattern,
		const ExprPtr &	original,
		const std::string &	var,
		ComputationContext &	context,
		const SolveOptions &	options,
		int	depth )

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

                                                                                               {
    auto inverted = invert_function(pattern, original, var, context, options);
    if (!inverted) { return inverted; }
    auto finite = std::get_if<FiniteSolutions>(&inverted.value());
    if (!finite) { return inverted; }
    SolutionSet results = EmptySolutions{};
    for (const auto& value : finite->values) {
        if (!value.conditions.empty()) { return conditional_preimage(original, var); }
        auto solved = solve_inner_equation(original, pattern.inner, value.value,
            var, context, options, depth);
        if (!solved) { return solved; }
        append_solutions(std::move(solved).value(), results, original, var);
    }
    return results;
}

引用了 append_solutions(), LMCAS::detail::transcendental::conditional_preimage(), LMCAS::context, LMCAS::depth, LMCAS::detail::transcendental::InversePattern::inner, LMCAS::detail::transcendental::invert_function(), LMCAS::options, solve_function_pattern(), solve_inner_equation() , 以及 LMCAS::value.

被这些函数引用 solve_function_pattern() , 以及 solve_transcendental_impl().

函数调用图:

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

solve_inner_equation()

SolveResult LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_inner_equation	(	const ExprPtr &	original,
		const ExprPtr &	inner,
		const ExprPtr &	value,
		const std::string &	var,
		ComputationContext &	context,
		const SolveOptions &	options,
		int	depth )

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

                                                {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto variable = std::dynamic_pointer_cast<const VariableNode>(detail::node(inner));
    if (variable && !variable->is_constant() && variable->name() == var) {
        return SolutionSet{FiniteSolutions{{FiniteSolution{value, 1, {}}}}};
    }
    const auto product =
        std::dynamic_pointer_cast<const MultiplyNode>(detail::node(inner));
    if (product && product->operands().size() == 2) {
        const auto& first = product->operands()[0];
        const auto& second = product->operands()[1];
        const auto coefficient =
            std::dynamic_pointer_cast<const NumberNode>(first);
        const auto product_variable =
            std::dynamic_pointer_cast<const VariableNode>(second);
        if (coefficient && coefficient->is_negative_one() &&
            product_variable && !product_variable->is_constant() &&
            product_variable->name() == var) {
            auto inverted = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(
                SymbolicExpr::number(-1), value)), transform_budget));
            return SolutionSet{FiniteSolutions{{
                FiniteSolution{std::move(inverted), 1, {}}}}};
        }
    }
    auto equation = SymbolicExpr::add(inner,
        SymbolicExpr::multiply(value, SymbolicExpr::number(-1)));
    auto polynomial = symbolic_to_poly<SymbolicPolyCoeff>(equation, var);
    if (polynomial) return solve_equation(equation, var, context, options);
    if (polynomial.error().code != CasErrc::UnsupportedExpression) {
        return SolveResult::failure(polynomial.error());
    }
    return solve_transcendental_impl(original, equation, var, context, options, depth + 1);
} catch (const CasError& error) {
    return SolveResult::failure(error);
} catch (const std::bad_alloc&) {
    return SolveResult::failure(CasErrc::ResourceLimit, "allocation failed", "solve_inner_equation");
} catch (const std::length_error& error) {
    return SolveResult::failure(CasErrc::ResourceLimit, error.what(), "solve_inner_equation");
} catch (const std::exception& error) {
    return SolveResult::failure(CasErrc::InternalInvariant, error.what(), "solve_inner_equation");
}

引用了 LMCAS::context, LMCAS::depth, LMCAS::Result< SolutionSet >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::options, LMCAS::solve_equation(), solve_inner_equation(), solve_transcendental_impl(), LMCAS::UnsupportedExpression, LMCAS::value , 以及 LMCAS::variable.

被这些函数引用 solve_function_pattern(), solve_inner_equation(), solve_inverted_values() , 以及 solve_substitution().

函数调用图:

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

solve_inverted_values()

SolveResult LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_inverted_values	(	const ExprPtr &	original,
		const ExprPtr &	inner,
		const std::vector< ExprPtr > &	values,
		const std::string &	var,
		ComputationContext &	context,
		const SolveOptions &	options,
		int	depth )

在文件 solve_transcendental.cpp 第 216 行定义.

                                                                         {
    if (values.empty()) return inconclusive("Inverse did not establish a complete value set");
    SolutionSet results = EmptySolutions{};
    for (const auto& value : values) {
        auto solved = solve_inner_equation(original, inner, value, var, context, options, depth);
        if (!solved) return solved;
        append_solutions(std::move(solved).value(), results, original, var);
    }
    return results;
}

引用了 append_solutions(), LMCAS::context, LMCAS::depth, inconclusive(), LMCAS::options, solve_inner_equation(), solve_inverted_values() , 以及 LMCAS::value.

被这些函数引用 solve_inverted_values() , 以及 solve_transcendental_impl().

函数调用图:

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

solve_substitution()

SolveResult LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_substitution	(	const ExprPtr &	original,
		const SubstitutionResult &	substitution,
		const std::string &	var,
		ComputationContext &	context,
		const SolveOptions &	options,
		int	depth )

在文件 solve_transcendental.cpp 第 230 行定义.

                                                                         {
    auto polynomial = symbolic_to_poly<SymbolicPolyCoeff>(
        substitution.poly_in_u, substitution.u_var);
    if (!polynomial) {
        if (polynomial.error().code == CasErrc::UnsupportedExpression) {
            return inconclusive("Substitution is not a supported polynomial");
        }
        return SolveResult::failure(polynomial.error());
    }
    auto solved = solve_equation(substitution.poly_in_u, substitution.u_var, context, options);
    if (!solved) return solved;
    if (std::holds_alternative<EmptySolutions>(solved.value())) return solved;
    auto finite = std::get_if<FiniteSolutions>(&solved.value());
    if (!finite) return conditional_preimage(original, var);
    SolutionSet results = EmptySolutions{};
    for (const auto& value : finite->values) {
        if (!value.conditions.empty()) return conditional_preimage(original, var);
        auto inverted = solve_inner_equation(
            original, substitution.u_expr, value.value, var, context, options, depth);
        if (!inverted) return inverted;
        append_solutions(std::move(inverted).value(), results, original, var);
    }
    return results;
}

引用了 append_solutions(), LMCAS::detail::transcendental::conditional_preimage(), LMCAS::context, LMCAS::depth, LMCAS::Result< SolutionSet >::failure(), inconclusive(), LMCAS::options, LMCAS::SubstitutionResult::poly_in_u, LMCAS::solve_equation(), solve_inner_equation(), solve_substitution(), LMCAS::SubstitutionResult::u_expr, LMCAS::SubstitutionResult::u_var, LMCAS::UnsupportedExpression , 以及 LMCAS::value.

被这些函数引用 solve_substitution() , 以及 solve_transcendental_impl().

函数调用图:

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

solve_transcendental_constant()

SolveResult LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_transcendental_constant	(	const ExprPtr &	original,
		const ExprPtr &	expr,
		const std::string &	var,
		ComputationContext &	context )

在文件 solve_transcendental.cpp 第 257 行定义.

                                                           {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    std::optional<detail::AssumptionFacts> assumptions;
    if (context.assumptions()) { assumptions.emplace(*context.assumptions()); }
    const LMCAS::FactsQuery& facts = assumptions ?
        static_cast<const LMCAS::FactsQuery&>(*assumptions) : detail::no_facts();
    auto nonzero = detail::query_nonzero_value(detail::normalize_node(detail::node(expr), transform_budget), facts, Domain::Real, context);
    if (!nonzero) { return SolveResult::failure(nonzero.error()); }
    if (nonzero.value() == Tribool::True) { return SolutionSet{EmptySolutions{}}; }
    if (nonzero.value() == Tribool::False) { return SolutionSet{UniversalSolutions{}}; }
    return conditional_preimage(original, var);
} catch (const CasError& error) {
    return SolveResult::failure(error);
} catch (const std::bad_alloc&) {
    return SolveResult::failure(CasErrc::ResourceLimit, "allocation failed", "solve_transcendental_constant");
} catch (const std::length_error& error) {
    return SolveResult::failure(CasErrc::ResourceLimit, error.what(), "solve_transcendental_constant");
} catch (const std::exception& error) {
    return SolveResult::failure(CasErrc::InternalInvariant, error.what(), "solve_transcendental_constant");
}

引用了 LMCAS::detail::transcendental::conditional_preimage(), LMCAS::context, LMCAS::Result< SolutionSet >::failure(), LMCAS::False, LMCAS::detail::no_facts(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::detail::query_nonzero_value(), LMCAS::Real, solve_transcendental_constant() , 以及 LMCAS::True.

被这些函数引用 solve_transcendental_constant() , 以及 solve_transcendental_impl().

函数调用图:

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

solve_transcendental_impl()

SolveResult LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_transcendental_impl	(	const ExprPtr &	original,
		const ExprPtr &	expr,
		const std::string &	var,
		ComputationContext &	context,
		const SolveOptions &	options,
		int	depth )

在文件 solve_transcendental.cpp 第 297 行定义.

                                                                         {
    auto step = context.consume_steps(1, "solve.transcendental");
    if (!step) { return SolveResult::failure(step.error()); }
    if (depth > maximum_transcendental_depth) { return inconclusive("Transcendental inversion depth exceeded"); }
    if (!expression_depends_on_variable(detail::node(expr), var)) {
        return solve_transcendental_constant(original, expr, var, context);
    }
    if (auto pattern = decompose_lambert_w_pattern(expr, var, context)) {
        return solve_inverted_values(original, pattern->inner, invert_lambert_w(pattern->rhs, context),
            var, context, options, depth);
    }
    if (auto pattern = decompose_exp_base_pattern(expr, var, context)) {
        return solve_inverted_values(original, pattern->inner,
            invert_exp_base(pattern->base, pattern->rhs, context), var, context, options, depth);
    }
    if (auto pattern = decompose_trig_exp_pattern(expr, var)) {
        return solve_function_pattern(*pattern, original, var, context, options, depth);
    }
    auto substitution = detect_substitution(expr, var);
    if (!substitution) {
        return SolveResult::failure(substitution.error());
    }
    if (substitution.value()) {
        return solve_substitution(original, *substitution.value(), var, context, options, depth);
    }
    return inconclusive("No complete transcendental inversion matched");
}

引用了 LMCAS::context, LMCAS::detail::transcendental::decompose_exp_base_pattern(), LMCAS::detail::transcendental::decompose_lambert_w_pattern(), LMCAS::detail::transcendental::decompose_trig_exp_pattern(), LMCAS::depth, LMCAS::detect_substitution(), LMCAS::expression_depends_on_variable(), LMCAS::Result< SolutionSet >::failure(), inconclusive(), LMCAS::detail::transcendental::invert_exp_base(), LMCAS::detail::transcendental::invert_lambert_w(), maximum_transcendental_depth, LMCAS::detail::node(), LMCAS::options, solve_function_pattern(), solve_inverted_values(), solve_substitution(), solve_transcendental_constant() , 以及 solve_transcendental_impl().

被这些函数引用 solve_inner_equation() , 以及 solve_transcendental_impl().

函数调用图:

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

zero_difference()

Result< bool > LMCAS::anonymous_namespace{solve_transcendental.cpp}::zero_difference	(	const ExprPtr &	left,
		const ExprPtr &	right,
		ComputationContext &	context )

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

                                                                                                     {
    auto difference = detail::simplify_expression(SymbolicExpr::add(left,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), right)), context);
    if (!difference) { return Result<bool>::failure(difference.error()); }
    auto proof = check_zero_residual(difference.value(), context);
    if (!proof) { return Result<bool>::failure(proof.error()); }
    return std::holds_alternative<ProvedZeroResidual>(proof.value());
}

引用了 LMCAS::check_zero_residual(), LMCAS::context, LMCAS::Result< T >::failure(), LMCAS::right, LMCAS::detail::simplify_expression() , 以及 zero_difference().

被这些函数引用 coalesce_periodic_pair(), merged_half_period_value() , 以及 zero_difference().

函数调用图:

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

变量说明

maximum_transcendental_depth

int LMCAS::anonymous_namespace{solve_transcendental.cpp}::maximum_transcendental_depth = 5

constexpr

在文件 solve_transcendental.cpp 第 18 行定义.

被这些函数引用 solve_transcendental_impl().