LMCAS::polynomial_solver_detail 命名空间参考

类
struct	SymbolicQuarticDepression

函数
bool	bounded_rational_root_search (const Polynomial< Rational > &polynomial)
bool	convert_to_rational_poly (const Polynomial< SymbolicPolyCoeff > &poly, Polynomial< Rational > &output, ComputationContext &context)
std::vector< std::shared_ptr< SymbolicExpr > >	exact_polynomial_roots (const Polynomial< Rational > &polynomial, ComputationContext &context)
bool	is_purely_numeric (const std::shared_ptr< SymbolicExpr > &expr)
std::shared_ptr< SymbolicExpr >	negate (const std::shared_ptr< SymbolicExpr > &expr)
std::shared_ptr< SymbolicExpr >	num (int value)
std::vector< std::shared_ptr< SymbolicExpr > >	solve_biquadratic_impl (const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, const std::shared_ptr< SymbolicExpr > &c, const std::string &variable, ComputationContext &context)
std::vector< std::shared_ptr< SymbolicExpr > >	solve_by_factoring_impl (const Polynomial< SymbolicPolyCoeff > &polynomial, const std::string &variable, ComputationContext &context)
std::vector< std::shared_ptr< SymbolicExpr > >	solve_cubic_impl (const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, const std::shared_ptr< SymbolicExpr > &c, const std::shared_ptr< SymbolicExpr > &d, const std::string &variable, ComputationContext &context)
std::vector< std::shared_ptr< SymbolicExpr > >	solve_quadratic_internal (const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, const std::shared_ptr< SymbolicExpr > &c, ComputationContext &context)
std::vector< std::shared_ptr< SymbolicExpr > >	solve_quartic_impl (const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, const std::shared_ptr< SymbolicExpr > &c, const std::shared_ptr< SymbolicExpr > &d, const std::shared_ptr< SymbolicExpr > &e, const std::string &variable, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	sub (const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b)
SymbolicQuarticDepression	symbolic_quartic_depression (const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, const std::shared_ptr< SymbolicExpr > &c, const std::shared_ptr< SymbolicExpr > &d, const std::shared_ptr< SymbolicExpr > &e, ComputationContext &context)
std::vector< std::shared_ptr< SymbolicExpr > >	symbolic_quartic_roots (const SymbolicQuarticDepression &depression, const std::string &variable, ComputationContext &context)

---

类说明

LMCAS::polynomial_solver_detail::SymbolicQuarticDepression

struct LMCAS::polynomial_solver_detail::SymbolicQuarticDepression

在文件 polynomial_solver_support.hpp 第 19 行定义.

LMCAS::polynomial_solver_detail::SymbolicQuarticDepression 的协作图:

类成员
shared_ptr< SymbolicExpr >	p
shared_ptr< SymbolicExpr >	q
shared_ptr< SymbolicExpr >	r
shared_ptr< SymbolicExpr >	shift

函数说明

bounded_rational_root_search()

bool LMCAS::polynomial_solver_detail::bounded_rational_root_search

(

const Polynomial< Rational > &

polynomial

)

find_rational_roots 在枚举因子前移除零根。 大小限制针对本原整数多项式的实际首尾系数； 各分母虽小，其最小公倍数仍可能很大。

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

                                            {
    if (polynomial.degree() <= 1) return true;
    if (polynomial.lead_coeff() != Rational(1)) {
        return bounded_rational_root_search(polynomial.make_monic());
    }
    BigInt denominator_lcm(1);
    for (const auto& coefficient : polynomial.coeffs) {
        denominator_lcm = BigInt::lcm(
            denominator_lcm, coefficient.get_denominator());
        if (denominator_lcm.bit_length() > 32) return false;
    }
    /**
     * @brief find_rational_roots 在枚举因子前移除零根。
     * 大小限制针对本原整数多项式的实际首尾系数；
     * 各分母虽小，其最小公倍数仍可能很大。
     */
    for (const auto& coefficient : polynomial.coeffs) {
        if (coefficient != Rational(0)) {
            return (coefficient * Rational(denominator_lcm))
                       .get_numerator().bit_length() <= 32;
        }
    }
    return true;
}

引用了 bounded_rational_root_search(), LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Polynomial< CoeffType >::lead_coeff() , 以及 LMCAS::Polynomial< CoeffType >::make_monic().

被这些函数引用 bounded_rational_root_search(), LMCAS::exact_factor_roots(), solve_by_factoring_impl() , 以及 LMCAS::solve_exact_factor().

函数调用图:

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

convert_to_rational_poly()

bool LMCAS::polynomial_solver_detail::convert_to_rational_poly	(	const Polynomial< SymbolicPolyCoeff > &	poly,
		Polynomial< Rational > &	output,
		ComputationContext &	context )

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

{
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    out_poly = Polynomial<Rational>(sym_poly.variable_name);
    out_poly.coeffs.resize(sym_poly.coeffs.size(), Rational(0));
 
    for (size_t i = 0; i < sym_poly.coeffs.size(); ++i) {
        auto coeff_expr = sym_poly.coeffs[i].val;
        if (!coeff_expr) {
            out_poly.coeffs[i] = Rational(0);
            continue;
        }
 
        auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(coeff_expr), transform_budget));
        auto num_node = std::dynamic_pointer_cast<const NumberNode>(
            LMCAS::detail::node(simplified));
        if (!num_node) {
            return false;
        }
        if (std::holds_alternative<Rational>(num_node->value())) {
            out_poly.coeffs[i] = std::get<Rational>(num_node->value());
        } else {
            out_poly.coeffs[i] =
                Rational(std::get<BigInt>(num_node->value()));
        }
    }
 
    out_poly.trim();
    return true;
}

引用了 LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::context, convert_to_rational_poly(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::Polynomial< CoeffType >::trim() , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 convert_to_rational_poly(), solve_by_factoring_impl(), solve_cubic_impl() , 以及 solve_quartic_impl().

函数调用图:

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

exact_polynomial_roots()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::polynomial_solver_detail::exact_polynomial_roots	(	const Polynomial< Rational > &	polynomial,
		ComputationContext &	context )

在文件 solve_polynomial_cubic.cpp 第 173 行定义.

                                                                         {
    if (polynomial.is_zero()) {
        throw std::invalid_argument(
            "polynomial solver: identically zero equation has no finite root list");
    }
    std::vector<std::shared_ptr<SymbolicExpr>> roots;
    for (const auto& [factor, multiplicity] :
         square_free_factorization(polynomial)) {
        auto factor_roots = exact_factor_roots(factor, context);
        for (int repeat = 0; repeat < multiplicity; ++repeat) {
            roots.insert(roots.end(), factor_roots.begin(), factor_roots.end());
        }
    }
    return roots;
}

引用了 LMCAS::context, LMCAS::exact_factor_roots(), LMCAS::Polynomial< CoeffType >::is_zero(), LMCAS::roots() , 以及 LMCAS::square_free_factorization().

被这些函数引用 solve_cubic_impl() , 以及 solve_quartic_impl().

函数调用图:

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

is_purely_numeric()

bool LMCAS::polynomial_solver_detail::is_purely_numeric

(

const std::shared_ptr< SymbolicExpr > &

expr

)

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

                                                                {
    return !expr || free_variables(LMCAS::detail::node(expr)).empty();
}

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

被这些函数引用 is_purely_numeric(), solve_biquadratic_impl() , 以及 LMCAS::solve_degenerate_cubic().

函数调用图:

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

negate()

std::shared_ptr< SymbolicExpr > LMCAS::polynomial_solver_detail::negate

(

const std::shared_ptr< SymbolicExpr > &

expr

)

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

                                                                         {
    return SymbolicExpr::multiply(SymbolicExpr::number(-1), x);
}

引用了 negate().

被这些函数引用 LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::logical_predicate_truth(), negate(), LMCAS::detail::anonymous_namespace{exact_matrix_solve.cpp}::rational_linear_solve(), solve_biquadratic_impl(), LMCAS::solve_degenerate_cubic(), LMCAS::detail::solve_linear_exact(), solve_quadratic_internal(), sub(), LMCAS::symbolic_cubic_roots() , 以及 symbolic_quartic_roots().

函数调用图:

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

num()

std::shared_ptr< SymbolicExpr > LMCAS::polynomial_solver_detail::num

(

int

value

)

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

{ return SymbolicExpr::number(n); }

引用了 num().

被这些函数引用 LMCAS::berlekamp_detail::bk_reduce_to_mod_coeffs(), LMCAS::detail::inequality_support::determine_leading_sign(), LMCAS::groebner_detail::div_mono(), LMCAS::detail::inequality_support::exact_numeric_sign(), LMCAS::anonymous_namespace{mixed_transcendental_search.cpp}::extract_real_value(), LMCAS::get_integer_value(), LMCAS::is_even_integer_number(), LMCAS::is_integer_number(), LMCAS::is_positive_integer_number(), LMCAS::is_zero_number(), LMCAS::ode_root_detail::anonymous_namespace{ode_characteristic_roots.cpp}::iterate_characteristic_roots(), LMCAS::solver_detail::multiply_no_expand(), LMCAS::InferenceEngine::Impl::natural_number(), num(), LMCAS::InferenceEngine::Impl::number_integer(), LMCAS::InferenceEngine::Impl::number_negative(), LMCAS::InferenceEngine::Impl::number_nonnegative(), LMCAS::InferenceEngine::Impl::number_nonpositive(), LMCAS::InferenceEngine::Impl::number_nonzero(), LMCAS::InferenceEngine::Impl::number_positive(), LMCAS::InferenceEngine::Impl::operand_sign(), LMCAS::InferenceEngine::Impl::query_natural(), LMCAS::InferenceEngine::Impl::query_rational(), LMCAS::anonymous_namespace{integration_rational_collection.cpp}::rd_collect_power(), LMCAS::anonymous_namespace{integration_rational_collection.cpp}::rd_collect_rational(), LMCAS::anonymous_namespace{integration_rational_collection.cpp}::rd_collect_sum(), LMCAS::detail::series_support::series_get_double(), solve_biquadratic_impl(), LMCAS::solve_linear1_ode(), solve_quadratic_internal(), LMCAS::anonymous_namespace{limit_visitor_taylor.cpp}::substitute_infinity_series(), LMCAS::symbolic_cubic_roots(), LMCAS::symbolic_node_to_multipoly(), symbolic_quartic_depression(), symbolic_quartic_roots(), LMCAS::tf_detect_multiplicative_structure(), LMCAS::anonymous_namespace{solver_assumptions.cpp}::try_get_numeric_value(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_rational_power(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_to_rational(), LMCAS::zc_rational_reconstruction() , 以及 LMCAS::zc_reconstruct_candidate().

函数调用图:

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

solve_biquadratic_impl()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::polynomial_solver_detail::solve_biquadratic_impl	(	const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		const std::shared_ptr< SymbolicExpr > &	c,
		const std::string &	variable,
		ComputationContext &	context )

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

                                                   {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto a_simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(a), transform_budget));
    if (a_simplified->get_number_value_is_zero()) {
        auto b_simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(b), transform_budget));
        if (!b_simplified->get_number_value_is_zero()) {
            return solve_quadratic_internal(b, num(0), c, context);
        }
 
        auto c_simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(c), transform_budget));
        if (c_simplified->get_number_value_is_zero()) {
            throw std::invalid_argument(
                "solve_biquadratic: identically zero equation has no finite root list");
        }
        if (is_purely_numeric(c_simplified)) {
            return {};
        }
        throw std::invalid_argument(
            "solve_biquadratic: equation is independent of the requested variable");
    }
 
    auto u_roots = solve_quadratic_internal(a, b, c, context);
 
    std::vector<std::shared_ptr<SymbolicExpr>> results;
    for (const auto& u : u_roots) {
        auto pos_root = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::sqrt(u)), transform_budget));
        auto neg_root = detail::make_expression_ptr(detail::normalize_node(detail::node(negate(SymbolicExpr::sqrt(u))), transform_budget));
        results.push_back(pos_root);
        results.push_back(neg_root);
    }
 
    return results;
}

引用了 LMCAS::a, LMCAS::b, LMCAS::c, LMCAS::context, is_purely_numeric(), LMCAS::detail::make_expression_ptr(), negate(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), num(), solve_quadratic_internal() , 以及 LMCAS::u.

被这些函数引用 LMCAS::exact_factor_roots(), LMCAS::solve_biquadratic(), LMCAS::solve_higher_exact_roots() , 以及 solve_quartic_impl().

函数调用图:

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

solve_by_factoring_impl()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::polynomial_solver_detail::solve_by_factoring_impl	(	const Polynomial< SymbolicPolyCoeff > &	polynomial,
		const std::string &	variable,
		ComputationContext &	context )

在文件 solve_polynomial.cpp 第 68 行定义.

                                                       {
 
    if (poly.is_zero() || poly.degree() < 1) { return {}; }
 
    if (poly.degree() <= 2) {
        return solve_closed_form_poly(poly, var, context);
    }
 
    std::vector<std::shared_ptr<SymbolicExpr>> results;
 
    Polynomial<Rational> rat_poly;
    if (!convert_to_rational_poly(poly, rat_poly, context)) {
        if (poly.degree() <= 4) {
            return solve_closed_form_poly(poly, var, context);
        }
        return detail::make_rootof_solutions_impl(poly, var, context);
    }
 
    // Keep rational boundaries exact before cubic/quartic floating formulas.
    auto rational_roots = bounded_rational_root_search(rat_poly) ?
        find_rational_roots(rat_poly) : std::vector<Rational>{};
 
    for (const auto& r : rational_roots) {
        results.push_back(SymbolicExpr::number(r));
    }
 
    Polynomial<Rational> quotient = rat_poly;
    for (const auto& r : rational_roots) {
        Polynomial<Rational> linear_factor({-r, Rational(1)}, var);
        auto [q, rem] = quotient.div_mod(linear_factor);
        if (!rem.is_zero()) { throw std::logic_error("solve_by_factoring: inexact root division"); }
        quotient = q;
    }
 
    if (quotient.degree() <= 0) {
        return results;
    }
 
    if (quotient.degree() <= 4) {
        auto sym_quotient = rational_to_symbolic_poly(quotient);
        auto factor_roots = solve_closed_form_poly(sym_quotient, var, context);
        results.insert(results.end(), factor_roots.begin(), factor_roots.end());
        return results;
    }
 
    auto sqfree_factors = square_free_factorization(quotient);
 
    for (const auto& [factor, multiplicity] : sqfree_factors) {
        append_factor_solutions(factor, multiplicity, var, results, context);
    }
 
    return results;
}

引用了 LMCAS::append_factor_solutions(), bounded_rational_root_search(), LMCAS::context, convert_to_rational_poly(), LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Polynomial< CoeffType >::div_mod(), LMCAS::find_rational_roots(), LMCAS::Polynomial< CoeffType >::is_zero(), LMCAS::detail::make_rootof_solutions_impl(), LMCAS::r, LMCAS::rational_to_symbolic_poly(), LMCAS::solve_closed_form_poly() , 以及 LMCAS::square_free_factorization().

被这些函数引用 LMCAS::detail::inequality_support::append_factor_roots(), LMCAS::detail::inequality_support::find_roots_with_multiplicity(), LMCAS::solve_by_factoring() , 以及 LMCAS::detail::inequality_support::solve_symbolic_poly().

函数调用图:

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

solve_cubic_impl()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::polynomial_solver_detail::solve_cubic_impl	(	const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		const std::shared_ptr< SymbolicExpr > &	c,
		const std::shared_ptr< SymbolicExpr > &	d,
		const std::string &	variable,
		ComputationContext &	context )

在文件 solve_polynomial_cubic.cpp 第 190 行定义.

                                                            {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    Polynomial<SymbolicPolyCoeff> symbolic(
        {SymbolicPolyCoeff(d), SymbolicPolyCoeff(c),
         SymbolicPolyCoeff(b), SymbolicPolyCoeff(a)}, variable);
    Polynomial<Rational> exact;
    if (convert_to_rational_poly(symbolic, exact, context)) {
        return exact_polynomial_roots(exact, context);
    }
    if (detail::make_expression_ptr(detail::normalize_node(detail::node(a), transform_budget))->get_number_value_is_zero()) {
        return solve_degenerate_cubic(b, c, d, context);
    }
    return symbolic_cubic_roots(a, b, c, d, context);
}

引用了 LMCAS::SymbolicPolyCoeff::SymbolicPolyCoeff(), LMCAS::a, LMCAS::b, LMCAS::c, LMCAS::context, convert_to_rational_poly(), exact_polynomial_roots(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::solve_degenerate_cubic(), LMCAS::symbolic_cubic_roots() , 以及 LMCAS::variable.

被这些函数引用 LMCAS::solve_closed_form_poly(), LMCAS::solve_cubic(), solve_quartic_impl() , 以及 symbolic_quartic_roots().

函数调用图:

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

solve_quadratic_internal()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::polynomial_solver_detail::solve_quadratic_internal	(	const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		const std::shared_ptr< SymbolicExpr > &	c,
		ComputationContext &	context )

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

                                                                       {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto b2 = SymbolicExpr::power(b, num(2));
    auto four_ac = SymbolicExpr::multiply(num(4), SymbolicExpr::multiply(a, c));
    auto delta = detail::make_expression_ptr(detail::normalize_node(detail::node(sub(b2, four_ac)), transform_budget));
 
    auto neg_b = negate(b);
    auto two_a = SymbolicExpr::multiply(num(2), a);
    if (delta && delta->is_zero()) {
        return { detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(neg_b, two_a)), transform_budget)) };
    }
 
    auto sqrt_delta = SymbolicExpr::sqrt(delta);
    auto exact_b = detail::exact_rational_value(detail::node(b));
    auto exact_delta = detail::exact_rational_value(detail::node(delta));
    if (exact_b && *exact_b != Rational(0) &&
        exact_delta && *exact_delta > Rational(0)) {
        auto numerator = *exact_b < Rational(0)
            ? SymbolicExpr::add(neg_b, sqrt_delta)
            : sub(neg_b, sqrt_delta);
        auto x1 = detail::make_expression_ptr(detail::normalize_node(
            detail::node(SymbolicExpr::divide(numerator, two_a)), transform_budget));
        auto x2 = detail::make_expression_ptr(detail::normalize_node(
            detail::node(SymbolicExpr::divide(
                SymbolicExpr::multiply(num(2), c), numerator)), transform_budget));
        return {x1, x2};
    }
    auto x1 = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(SymbolicExpr::add(neg_b, sqrt_delta), two_a)), transform_budget));
    auto x2 = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(sub(neg_b, sqrt_delta), two_a)), transform_budget));
 
    return { x1, x2 };
}

引用了 LMCAS::a, LMCAS::b, LMCAS::c, LMCAS::context, LMCAS::detail::exact_rational_value(), LMCAS::detail::make_expression_ptr(), negate(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), num(), solve_quadratic_internal() , 以及 sub().

被这些函数引用 LMCAS::exact_factor_roots(), solve_biquadratic_impl(), LMCAS::solve_closed_form_poly(), LMCAS::solve_degenerate_cubic(), solve_quadratic_internal() , 以及 symbolic_quartic_roots().

函数调用图:

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

solve_quartic_impl()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::polynomial_solver_detail::solve_quartic_impl	(	const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		const std::shared_ptr< SymbolicExpr > &	c,
		const std::shared_ptr< SymbolicExpr > &	d,
		const std::shared_ptr< SymbolicExpr > &	e,
		const std::string &	variable,
		ComputationContext &	context )

在文件 solve_polynomial_quartic.cpp 第 11 行定义.

                                                       {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
 
    auto a_simp = detail::make_expression_ptr(detail::normalize_node(detail::node(a), transform_budget));
    if (a_simp->get_number_value_is_zero()) {
 
        return solve_cubic_impl(b, c, d, e, var, context);
    }
 
    {
        Polynomial<SymbolicPolyCoeff> symbolic_poly(
            {SymbolicPolyCoeff(e), SymbolicPolyCoeff(d), SymbolicPolyCoeff(c),
             SymbolicPolyCoeff(b), SymbolicPolyCoeff(a)},
            var);
        Polynomial<Rational> rational_poly;
        if (convert_to_rational_poly(symbolic_poly, rational_poly, context)) {
            return exact_polynomial_roots(rational_poly, context);
        }
    }
 
    auto b_simp = detail::make_expression_ptr(detail::normalize_node(detail::node(b), transform_budget));
    auto d_simp = detail::make_expression_ptr(detail::normalize_node(detail::node(d), transform_budget));
    if (b_simp->get_number_value_is_zero() && d_simp->get_number_value_is_zero()) {
        return solve_biquadratic_impl(a, c, e, var, context);
    }
 
    return symbolic_quartic_roots(
        symbolic_quartic_depression(a, b, c, d, e, context), var, context);
}

引用了 LMCAS::SymbolicPolyCoeff::SymbolicPolyCoeff(), LMCAS::a, LMCAS::b, LMCAS::c, LMCAS::context, convert_to_rational_poly(), LMCAS::e(), exact_polynomial_roots(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), solve_biquadratic_impl(), solve_cubic_impl(), symbolic_quartic_depression() , 以及 symbolic_quartic_roots().

被这些函数引用 LMCAS::solve_closed_form_poly() , 以及 LMCAS::solve_quartic().

函数调用图:

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

sub()

std::shared_ptr< SymbolicExpr > LMCAS::polynomial_solver_detail::sub	(	const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b )

在文件 solve_polynomial_normalization.cpp 第 16 行定义.

                                                                                                            {
    return SymbolicExpr::add(a, negate(b));
}

引用了 LMCAS::a, LMCAS::b, negate() , 以及 sub().

被这些函数引用 solve_quadratic_internal(), sub(), symbolic_quartic_depression() , 以及 symbolic_quartic_roots().

函数调用图:

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

symbolic_quartic_depression()

SymbolicQuarticDepression LMCAS::polynomial_solver_detail::symbolic_quartic_depression	(	const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		const std::shared_ptr< SymbolicExpr > &	c,
		const std::shared_ptr< SymbolicExpr > &	d,
		const std::shared_ptr< SymbolicExpr > &	e,
		ComputationContext &	context )

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

                                                                       {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto a2 = SymbolicExpr::power(a, num(2));
    auto a3 = SymbolicExpr::power(a, num(3));
    auto a4 = SymbolicExpr::power(a, num(4));
    auto b2 = SymbolicExpr::power(b, num(2));
    auto b3 = SymbolicExpr::power(b, num(3));
    auto b4 = SymbolicExpr::power(b, num(4));
 
    auto eight_ac = SymbolicExpr::multiply(num(8), SymbolicExpr::multiply(a, c));
    auto three_b2 = SymbolicExpr::multiply(num(3), b2);
    auto p = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(sub(eight_ac, three_b2), SymbolicExpr::multiply(num(8), a2))), transform_budget));
 
    auto four_abc = SymbolicExpr::multiply(num(4), SymbolicExpr::multiply(a, SymbolicExpr::multiply(b, c)));
    auto eight_a2d = SymbolicExpr::multiply(num(8), SymbolicExpr::multiply(a2, d));
    auto q_num = SymbolicExpr::add(sub(b3, four_abc), eight_a2d);
    auto q = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(q_num, SymbolicExpr::multiply(num(8), a3))), transform_budget));
 
    auto neg3_b4 = SymbolicExpr::multiply(num(-3), b4);
    auto t256_a3e = SymbolicExpr::multiply(num(256), SymbolicExpr::multiply(a3, e));
    auto neg64_a2bd = SymbolicExpr::multiply(num(-64), SymbolicExpr::multiply(a2, SymbolicExpr::multiply(b, d)));
    auto t16_ab2c = SymbolicExpr::multiply(num(16), SymbolicExpr::multiply(a, SymbolicExpr::multiply(b2, c)));
    auto r_num = SymbolicExpr::add(SymbolicExpr::add(SymbolicExpr::add(neg3_b4, t256_a3e), neg64_a2bd), t16_ab2c);
    auto r = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(r_num, SymbolicExpr::multiply(num(256), a4))), transform_budget));
 
    auto shift = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(b, SymbolicExpr::multiply(num(4), a))), transform_budget));
    return {p, q, r, shift};
}

引用了 LMCAS::a, LMCAS::b, LMCAS::c, LMCAS::context, LMCAS::e(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), num(), LMCAS::r, sub() , 以及 symbolic_quartic_depression().

被这些函数引用 solve_quartic_impl() , 以及 symbolic_quartic_depression().

函数调用图:

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

symbolic_quartic_roots()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::polynomial_solver_detail::symbolic_quartic_roots	(	const SymbolicQuarticDepression &	depression,
		const std::string &	variable,
		ComputationContext &	context )

在文件 solve_polynomial_quartic_symbolic.cpp 第 44 行定义.

                                 {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const auto& [p, q, r, shift] = depression;
    auto q_simp = detail::make_expression_ptr(detail::normalize_node(detail::node(q), transform_budget));
    if (q_simp->get_number_value_is_zero()) {
 
        auto u_roots = solve_quadratic_internal(num(1), p, r, context);
        std::vector<std::shared_ptr<SymbolicExpr>> results;
        for (const auto& u : u_roots) {
 
            auto pos_y = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::sqrt(u)), transform_budget));
            auto neg_y = detail::make_expression_ptr(detail::normalize_node(detail::node(negate(SymbolicExpr::sqrt(u))), transform_budget));
            results.push_back(detail::make_expression_ptr(detail::normalize_node(detail::node(sub(pos_y, shift)), transform_budget)));
            results.push_back(detail::make_expression_ptr(detail::normalize_node(detail::node(sub(neg_y, shift)), transform_budget)));
        }
        return results;
    }
 
    auto p2 = SymbolicExpr::power(p, num(2));
    auto q2 = SymbolicExpr::power(q, num(2));
    auto eight_p = SymbolicExpr::multiply(num(8), p);
    auto two_p2_minus_8r = detail::make_expression_ptr(detail::normalize_node(detail::node(sub(SymbolicExpr::multiply(num(2), p2), SymbolicExpr::multiply(num(8), r))), transform_budget));
    auto neg_q2 = detail::make_expression_ptr(detail::normalize_node(detail::node(negate(q2)), transform_budget));
 
    auto cubic_roots = solve_cubic_impl(num(8), eight_p, two_p2_minus_8r, neg_q2, var, context);
 
    std::shared_ptr<SymbolicExpr> m = nullptr;
    if (!cubic_roots.empty()) {
        m = cubic_roots[0];
    }
 
    if (!m) return {};
 
    auto two_m = SymbolicExpr::multiply(num(2), m);
    auto s = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::sqrt(two_m)), transform_budget));
 
    auto p_half = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(p, num(2))), transform_budget));
 
    auto m_plus_p_half = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(m, p_half)), transform_budget));
 
    auto q_over_2s = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(q, SymbolicExpr::multiply(num(2), s))), transform_budget));
 
    auto quad1_c = detail::make_expression_ptr(detail::normalize_node(detail::node(sub(m_plus_p_half, q_over_2s)), transform_budget));
 
    auto neg_s = detail::make_expression_ptr(detail::normalize_node(detail::node(negate(s)), transform_budget));
    auto quad2_c = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(m_plus_p_half, q_over_2s)), transform_budget));
 
    auto y_roots1 = solve_quadratic_internal(num(1), s, quad1_c, context);
    auto y_roots2 = solve_quadratic_internal(num(1), neg_s, quad2_c, context);
 
    std::vector<std::shared_ptr<SymbolicExpr>> results;
    for (const auto& y : y_roots1) {
        results.push_back(detail::make_expression_ptr(detail::normalize_node(detail::node(sub(y, shift)), transform_budget)));
    }
    for (const auto& y : y_roots2) {
        results.push_back(detail::make_expression_ptr(detail::normalize_node(detail::node(sub(y, shift)), transform_budget)));
    }
 
    return results;
}

引用了 LMCAS::context, LMCAS::detail::make_expression_ptr(), negate(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), num(), LMCAS::p2, LMCAS::r, solve_cubic_impl(), solve_quadratic_internal(), sub(), symbolic_quartic_roots() , 以及 LMCAS::u.

被这些函数引用 solve_quartic_impl() , 以及 symbolic_quartic_roots().

函数调用图:

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