LMCAS::detail::inequality_support 命名空间参考

命名空间
namespace	anonymous_namespace{inequality_solver_ordering.cpp}

类型定义
using	RootMultiplicityList = std::vector<std::pair<std::shared_ptr<SymbolicExpr>, int>>

函数
static void	append_affine_root (RootMultiplicityList &result, const Polynomial< Rational > &factor, int mult, ComputationContext &context)
static void	append_factor_roots (RootMultiplicityList &result, const Polynomial< Rational > &factor, int mult, const std::string &variable, ComputationContext &context)
static void	append_quadratic_roots (RootMultiplicityList &result, const Polynomial< Rational > &factor, int mult, ComputationContext &context)
static void	append_verified_roots (RootMultiplicityList &result, const Polynomial< Rational > &polynomial, const std::vector< std::shared_ptr< SymbolicExpr > > &roots, int multiplicity, ComputationContext &context)
IntervalUnion	build_parametric_intervals (const std::vector< std::shared_ptr< SymbolicExpr > > &symbolic_roots, const std::vector< int > &multiplicities, int leading_sign, InequalityType type, ComputationContext &context)
static bool	close_symbolic_endpoint (Endpoint &endpoint, const std::shared_ptr< SymbolicExpr > &root, ComputationContext &context)
bool	depends_on_any_param (const std::shared_ptr< SymbolicExpr > &expr, const std::vector< std::string > &parameters)
int	determine_leading_sign (const Polynomial< SymbolicPolyCoeff > &poly, ComputationContext &context)
int	exact_numeric_sign (const std::shared_ptr< SymbolicExpr > &expr, ComputationContext &context)
std::vector< std::pair< std::shared_ptr< SymbolicExpr >, int > >	find_roots_with_multiplicity (const std::shared_ptr< SymbolicExpr > &expr, const std::string &variable, ComputationContext &context)
void	include_numeric_root (std::vector< Interval > &intervals, const std::shared_ptr< SymbolicExpr > &root, ComputationContext &context)
static void	include_symbolic_root (std::vector< Interval > &intervals, const std::shared_ptr< SymbolicExpr > &root, ComputationContext &context)
bool	root_less_than (const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, ComputationContext &context)
bool	roots_equal (const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, ComputationContext &context)
static std::vector< Interval >	select_open_intervals (const std::vector< std::shared_ptr< SymbolicExpr > > &roots, const std::vector< int > &signs, int target_sign)
static std::shared_ptr< SymbolicExpr >	snap_verified_integer_root (const Polynomial< Rational > &poly, const std::shared_ptr< SymbolicExpr > &root, ComputationContext &context)
Result< IntervalUnion >	solve_exact_affine_inequality (const Polynomial< Rational > &polynomial, InequalityType type, ComputationContext &context)
Result< IntervalUnion >	solve_exact_polynomial_inequality (const Polynomial< Rational > &polynomial, InequalityType type, ComputationContext &context)
std::vector< std::shared_ptr< SymbolicExpr > >	solve_symbolic_poly (const Polynomial< SymbolicPolyCoeff > &poly, const std::string &variable, ComputationContext &context)
std::optional< double >	try_checked_numeric_constant (const SymbolicExpr &expr, ComputationContext &context)

类型定义说明

RootMultiplicityList

using LMCAS::detail::inequality_support::RootMultiplicityList = std::vector<std::pair<std::shared_ptr<SymbolicExpr>, int>>

在文件 inequality_solver_numeric.cpp 第 112 行定义.

函数说明

append_affine_root()

void LMCAS::detail::inequality_support::append_affine_root ( RootMultiplicityList & result, const Polynomial< Rational > & factor, int mult, ComputationContext & context )

static

在文件 inequality_solver_numeric.cpp 第 130 行定义.

                                                            {
    Rational a = factor.coeffs[1];
    Rational b = factor.coeffs[0];
    if (a != Rational(0)) {
        Rational root_val = Rational(0) - b / a;
        auto root_expr = SymbolicExpr::number(root_val);
        if (try_checked_numeric_constant(*root_expr, context)) {
            result.push_back({root_expr, mult});
        }
    }
}

引用了 LMCAS::a, append_affine_root(), LMCAS::b, LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::detail::context , 以及 try_checked_numeric_constant().

被这些函数引用 append_affine_root() , 以及 find_roots_with_multiplicity().

函数调用图:

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

append_factor_roots()

void LMCAS::detail::inequality_support::append_factor_roots ( RootMultiplicityList & result, const Polynomial< Rational > & factor, int mult, const std::string & variable, ComputationContext & context )

static

在文件 inequality_solver_numeric.cpp 第 183 行定义.

                                                                                        {
    std::vector<SymbolicPolyCoeff> spc_coeffs;
    for (int i = 0; i <= factor.degree(); ++i) {
        spc_coeffs.push_back(SymbolicPolyCoeff(SymbolicExpr::number(factor.coeffs[i])));
    }
    Polynomial<SymbolicPolyCoeff> factor_spc(spc_coeffs, variable);
 
    auto factor_roots = polynomial_solver_detail::solve_by_factoring_impl(
        factor_spc, variable, context);
    append_verified_roots(result, factor, factor_roots, mult, context);
}

引用了 LMCAS::SymbolicPolyCoeff::SymbolicPolyCoeff(), append_factor_roots(), append_verified_roots(), LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::detail::context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::polynomial_solver_detail::solve_by_factoring_impl() , 以及 LMCAS::detail::variable.

被这些函数引用 append_factor_roots() , 以及 find_roots_with_multiplicity().

函数调用图:

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

append_quadratic_roots()

void LMCAS::detail::inequality_support::append_quadratic_roots ( RootMultiplicityList & result, const Polynomial< Rational > & factor, int mult, ComputationContext & context )

static

在文件 inequality_solver_numeric.cpp 第 144 行定义.

                                                               {
    Rational a = factor.coeffs[2];
    Rational b = factor.coeffs[1];
    Rational c = factor.coeffs[0];
 
    Rational disc = b * b - Rational(4) * a * c;
    if (disc < Rational(0)) {
        return;
    }
    double disc_val = disc.to_double();
 
    double a_val = a.to_double();
    double b_val = b.to_double();
    double sqrt_disc = std::sqrt(disc_val);
 
    double r1;
    double r2;
    if (sqrt_disc == 0.0) {
        r1 = -b_val / (2.0 * a_val);
        r2 = r1;
    } else {
        const double q =
            -0.5 * b_val - 0.5 * std::copysign(sqrt_disc, b_val);
        r1 = q / a_val;
        r2 = c.to_double() / q;
    }
 
    if (std::isfinite(r1)) {
        auto root = snap_verified_integer_root(factor, SymbolicExpr::number(r1), context);
        result.push_back({root, mult});
    }
    if (std::isfinite(r2) && r2 != r1) {
        auto root = snap_verified_integer_root(factor, SymbolicExpr::number(r2), context);
        result.push_back({root, mult});
    }
}

引用了 LMCAS::a, append_quadratic_roots(), LMCAS::b, LMCAS::c, LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::detail::context , 以及 snap_verified_integer_root().

被这些函数引用 append_quadratic_roots() , 以及 find_roots_with_multiplicity().

函数调用图:

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

append_verified_roots()

void LMCAS::detail::inequality_support::append_verified_roots ( RootMultiplicityList & result, const Polynomial< Rational > & polynomial, const std::vector< std::shared_ptr< SymbolicExpr > > & roots, int multiplicity, ComputationContext & context )

static

在文件 inequality_solver_numeric.cpp 第 114 行定义.

                                                   {
    for (const auto& root : roots) {
        if (!root) {
            continue;
        }
        auto verified = snap_verified_integer_root(polynomial, root, context);
        if (try_checked_numeric_constant(*verified, context)) {
            result.push_back({verified, multiplicity});
        }
    }
}

引用了 append_verified_roots(), LMCAS::detail::context, LMCAS::detail::multiplicity, LMCAS::roots(), snap_verified_integer_root() , 以及 try_checked_numeric_constant().

被这些函数引用 append_factor_roots(), append_verified_roots() , 以及 find_roots_with_multiplicity().

函数调用图:

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

build_parametric_intervals()

IntervalUnion LMCAS::detail::inequality_support::build_parametric_intervals	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	symbolic_roots,
		const std::vector< int > &	multiplicities,
		int	leading_sign,
		InequalityType	type,
		ComputationContext &	context )

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

                                                      {
 
    if (symbolic_roots.empty()) {
 
        bool want_positive = (type == InequalityType::GreaterThan || type == InequalityType::GreaterEqual);
        int target_sign = want_positive ? 1 : -1;
        if (leading_sign == target_sign) {
            return IntervalUnion::entire_line();
        }
        return IntervalUnion::empty();
    }
 
    size_t n = symbolic_roots.size();
    std::vector<int> interval_signs(n + 1);
 
    interval_signs[n] = leading_sign;
 
    for (int i = (int)n - 1; i >= 0; --i) {
        interval_signs[i] = interval_signs[i + 1];
        if (multiplicities[i] % 2 != 0) {
            interval_signs[i] = -interval_signs[i];
        }
    }
 
    bool want_positive = (type == InequalityType::GreaterThan || type == InequalityType::GreaterEqual);
    bool is_strict = (type == InequalityType::GreaterThan || type == InequalityType::LessThan);
    int target_sign = want_positive ? 1 : -1;
 
    auto result_intervals = select_open_intervals(symbolic_roots, interval_signs, target_sign);
 
    if (!is_strict) {
        for (const auto& root : symbolic_roots) include_symbolic_root(result_intervals, root, context);
    }
    return IntervalUnion(result_intervals);
}

引用了 build_parametric_intervals(), LMCAS::detail::context, LMCAS::GreaterEqual, LMCAS::GreaterThan, include_symbolic_root(), LMCAS::LessThan , 以及 select_open_intervals().

被这些函数引用 build_parametric_intervals() , 以及 LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::quadratic_solution().

函数调用图:

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

close_symbolic_endpoint()

bool LMCAS::detail::inequality_support::close_symbolic_endpoint ( Endpoint & endpoint, const std::shared_ptr< SymbolicExpr > & root, ComputationContext & context )

static

在文件 inequality_solver_chart.cpp 第 32 行定义.

                                                                                                         {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (detail::node(endpoint.value)->equals(*detail::node(root))) {
        endpoint.is_open = false;
        return true;
    }
    auto diff = SymbolicExpr::add(endpoint.value,
        SymbolicExpr::multiply(root, SymbolicExpr::number(-1)));
    if (!detail::make_expression_ptr(detail::normalize_node(detail::node(diff), transform_budget))->is_zero()) {
        return false;
    }
    endpoint.is_open = false;
    return true;
}

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

被这些函数引用 close_symbolic_endpoint() , 以及 include_symbolic_root().

函数调用图:

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

depends_on_any_param()

bool LMCAS::detail::inequality_support::depends_on_any_param	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::vector< std::string > &	parameters )

在文件 inequality_solver_numeric.cpp 第 237 行定义.

                                                                          {
    if (!expr || !LMCAS::detail::node(expr)) {
        return false;
    }
    for (const auto& param : parameters) {
        if (expression_depends_on_variable(LMCAS::detail::node(expr), param)) {
            return true;
        }
    }
    return false;
}

引用了 depends_on_any_param(), LMCAS::expression_depends_on_variable() , 以及 LMCAS::detail::node().

被这些函数引用 depends_on_any_param().

函数调用图:

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

determine_leading_sign()

int LMCAS::detail::inequality_support::determine_leading_sign	(	const Polynomial< SymbolicPolyCoeff > &	poly,
		ComputationContext &	context )

在文件 inequality_solver_numeric.cpp 第 55 行定义.

                                                        {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (poly.is_zero()) {
        return 0;
    }
    auto lc = poly.lead_coeff().val;
    if (!lc) {
        return 1;
    }
    auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(lc), transform_budget));
    if (!simplified) {
        return 1;
    }
 
    if (auto val = try_checked_numeric_constant(*simplified, context)) {
        if (*val > 0) {
            return 1;
        }
        if (*val < 0) {
            return -1;
        }
    }
 
    if (auto num = std::dynamic_pointer_cast<const NumberNode>(LMCAS::detail::node(simplified))) {
        if (std::holds_alternative<BigInt>(num->value())) {
            return std::get<BigInt>(num->value()).is_negative() ? -1 : 1;
        }
        if (std::holds_alternative<Rational>(num->value())) {
            return std::get<Rational>(num->value()).get_numerator().is_negative() ? -1 : 1;
        }
    }
    return 1;
}

引用了 LMCAS::detail::context, determine_leading_sign(), LMCAS::Polynomial< CoeffType >::is_zero(), LMCAS::Polynomial< CoeffType >::lead_coeff(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::polynomial_solver_detail::num() , 以及 try_checked_numeric_constant().

被这些函数引用 determine_leading_sign().

函数调用图:

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

exact_numeric_sign()

int LMCAS::detail::inequality_support::exact_numeric_sign	(	const std::shared_ptr< SymbolicExpr > &	expr,
		ComputationContext &	context )

在文件 inequality_solver_numeric.cpp 第 26 行定义.

                                                    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!expr || !LMCAS::detail::node(expr)) {
        return 0;
    }
    auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(expr), transform_budget));
    if (!simplified || !LMCAS::detail::node(simplified)) {
        return 0;
    }
    auto num = std::dynamic_pointer_cast<const NumberNode>(LMCAS::detail::node(simplified));
    if (!num) {
        return 0;
    }
    if (std::holds_alternative<BigInt>(num->value())) {
        const auto& value = std::get<BigInt>(num->value());
        if (value.is_zero()) {
            return 0;
        }
        return value.is_negative() ? -1 : 1;
    }
    const auto& value = std::get<Rational>(num->value());
    if (value.get_numerator().is_zero()) {
        return 0;
    }
    return value.get_numerator().is_negative() ? -1 : 1;
}

引用了 LMCAS::detail::context, exact_numeric_sign(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::polynomial_solver_detail::num() , 以及 LMCAS::value.

被这些函数引用 exact_numeric_sign() , 以及 LMCAS::solve_constant_inequality().

函数调用图:

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

find_roots_with_multiplicity()

std::vector< std::pair< std::shared_ptr< SymbolicExpr >, int > > LMCAS::detail::inequality_support::find_roots_with_multiplicity	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	variable,
		ComputationContext &	context )

在文件 inequality_solver_numeric.cpp 第 197 行定义.

                                                            {
 
    std::vector<std::pair<std::shared_ptr<SymbolicExpr>, int>> result;
 
    auto converted = symbolic_to_poly<Rational>(expr, variable);
    if (!converted) throw std::invalid_argument(converted.error().message);
    const auto& poly_rat = converted.value();
    if (poly_rat.is_zero() || poly_rat.degree() <= 0) {
        return result;
    }
 
    auto factors = square_free_factorization(poly_rat);
    if (factors.empty()) {
        auto symbolic = symbolic_to_poly<SymbolicPolyCoeff>(expr, variable);
        if (!symbolic) throw std::invalid_argument(symbolic.error().message);
        const auto& poly_spc = symbolic.value();
        if (!poly_spc.is_zero() && poly_spc.degree() >= 1) {
            auto roots = polynomial_solver_detail::solve_by_factoring_impl(
                poly_spc, variable, context);
            append_verified_roots(result, poly_rat, roots, 1, context);
        }
        return result;
    }
    for (const auto& [factor, mult] : factors) {
        if (factor.degree() <= 0) {
            continue;
        }
        if (factor.degree() == 1) {
            append_affine_root(result, factor, mult, context);
        } else if (factor.degree() == 2) {
            append_quadratic_roots(result, factor, mult, context);
        } else {
            append_factor_roots(result, factor, mult, variable, context);
        }
    }
    return result;
}

引用了 append_affine_root(), append_factor_roots(), append_quadratic_roots(), append_verified_roots(), LMCAS::detail::context, find_roots_with_multiplicity(), LMCAS::roots(), LMCAS::polynomial_solver_detail::solve_by_factoring_impl(), LMCAS::square_free_factorization() , 以及 LMCAS::detail::variable.

被这些函数引用 find_roots_with_multiplicity(), LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::rational_critical_points() , 以及 LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::zero_numerator_domain().

函数调用图:

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

include_numeric_root()

void LMCAS::detail::inequality_support::include_numeric_root	(	std::vector< Interval > &	intervals,
		const std::shared_ptr< SymbolicExpr > &	root,
		ComputationContext &	context )

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

                                                       {
    bool merged = false;
    for (auto& interval : intervals) {
        if (!interval.upper.is_pos_infinity && interval.upper.value &&
            roots_equal(interval.upper.value, root, context)) {
            interval.upper.is_open = false;
            merged = true;
        }
        if (!interval.lower.is_neg_infinity && interval.lower.value &&
            roots_equal(interval.lower.value, root, context)) {
            interval.lower.is_open = false;
            merged = true;
        }
    }
    if (!merged) {
        intervals.push_back(Interval::point(root));
    }
}

引用了 LMCAS::detail::context, include_numeric_root(), LMCAS::interval(), roots_equal() , 以及 LMCAS::Result< T >::value().

被这些函数引用 include_numeric_root() , 以及 LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::include_rational_zeros().

函数调用图:

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

include_symbolic_root()

void LMCAS::detail::inequality_support::include_symbolic_root ( std::vector< Interval > & intervals, const std::shared_ptr< SymbolicExpr > & root, ComputationContext & context )

static

在文件 inequality_solver_chart.cpp 第 50 行定义.

                                                                                                       {
    bool merged = false;
    for (auto& interval : intervals) {
        if (!interval.upper.is_pos_infinity && interval.upper.value) {
            if (close_symbolic_endpoint(interval.upper, root, context)) {
                merged = true;
            }
        }
        if (!interval.lower.is_neg_infinity && interval.lower.value) {
            if (close_symbolic_endpoint(interval.lower, root, context)) {
                merged = true;
            }
        }
    }
    if (!merged) {
        intervals.push_back(Interval::point(root));
    }
}

引用了 close_symbolic_endpoint(), LMCAS::detail::context, include_symbolic_root(), LMCAS::interval() , 以及 LMCAS::Result< T >::value().

被这些函数引用 build_parametric_intervals() , 以及 include_symbolic_root().

函数调用图:

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

root_less_than()

bool LMCAS::detail::inequality_support::root_less_than	(	const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		ComputationContext &	context )

在文件 inequality_solver_ordering.cpp 第 99 行定义.

                                                                                       {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!a || !b) {
        return false;
    }
    auto va = try_checked_numeric_constant(*a, context);
    auto vb = try_checked_numeric_constant(*b, context);
    if (va && vb) {
        return *va < *vb;
    }
    auto diff = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(a, SymbolicExpr::multiply(b, SymbolicExpr::number(-1)))), transform_budget));
    if (auto vd = try_checked_numeric_constant(*diff, context)) {
        return *vd < 0;
    }
    return root_expression_sign(diff, context) < 0;
}

引用了 LMCAS::a, LMCAS::b, LMCAS::detail::context, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), root_less_than() , 以及 try_checked_numeric_constant().

被这些函数引用 root_less_than().

函数调用图:

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

roots_equal()

bool LMCAS::detail::inequality_support::roots_equal	(	const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		ComputationContext &	context )

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

                                                                                    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!a || !b) {
        return false;
    }
    auto numeric_a = try_checked_numeric_constant(*a, context);
    auto numeric_b = try_checked_numeric_constant(*b, context);
    if (numeric_a && numeric_b) {
        return *numeric_a == *numeric_b;
    }
    auto difference = SymbolicExpr::add(
        a,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), b));
    auto simplified = difference ? detail::make_expression_ptr(detail::normalize_node(detail::node(difference), transform_budget)) : nullptr;
    return simplified && simplified->is_zero();
}

引用了 LMCAS::a, LMCAS::b, LMCAS::detail::context, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), roots_equal() , 以及 try_checked_numeric_constant().

被这些函数引用 include_numeric_root(), LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::rational_critical_points() , 以及 roots_equal().

函数调用图:

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

select_open_intervals()

std::vector< Interval > LMCAS::detail::inequality_support::select_open_intervals ( const std::vector< std::shared_ptr< SymbolicExpr > > & roots, const std::vector< int > & signs, int target_sign )

static

在文件 inequality_solver_chart.cpp 第 70 行定义.

                                                  {
    std::vector<Interval> intervals;
    for (size_t index = 0; index < signs.size(); ++index) {
        if (signs[index] != target_sign) {
            continue;
        }
        Interval interval;
        interval.lower = index == 0 ? Endpoint::neg_inf() : Endpoint::open(roots[index - 1]);
        interval.upper = index == roots.size() ? Endpoint::pos_inf() : Endpoint::open(roots[index]);
        intervals.push_back(interval);
    }
    return intervals;
}

引用了 LMCAS::interval(), LMCAS::roots() , 以及 select_open_intervals().

被这些函数引用 build_parametric_intervals() , 以及 select_open_intervals().

函数调用图:

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

snap_verified_integer_root()

std::shared_ptr< SymbolicExpr > LMCAS::detail::inequality_support::snap_verified_integer_root ( const Polynomial< Rational > & poly, const std::shared_ptr< SymbolicExpr > & root, ComputationContext & context )

static

在文件 inequality_solver_numeric.cpp 第 91 行定义.

                                                                          {
    if (!root || poly.is_zero()) {
        return root;
    }
    auto numeric = try_checked_numeric_constant(*root, context);
    if (!numeric) {
        return root;
    }
 
    const Rational candidate = Rational::from_double(*numeric);
    if (!candidate.is_integer()) {
        return root;
    }
    if (poly.eval(candidate) == Rational(0)) {
        return SymbolicExpr::number(candidate);
    }
    return root;
}

引用了 LMCAS::detail::context, LMCAS::Polynomial< CoeffType >::eval(), LMCAS::Polynomial< CoeffType >::is_zero(), snap_verified_integer_root() , 以及 try_checked_numeric_constant().

被这些函数引用 append_quadratic_roots(), append_verified_roots() , 以及 snap_verified_integer_root().

函数调用图:

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

solve_exact_affine_inequality()

Result< IntervalUnion > LMCAS::detail::inequality_support::solve_exact_affine_inequality	(	const Polynomial< Rational > &	polynomial,
		InequalityType	type,
		ComputationContext &	context )

在文件 inequality_solver_polynomial.cpp 第 463 行定义.

                                 {
    return solve_exact_affine_inequality_impl(polynomial, type, context);
}

引用了 LMCAS::detail::context , 以及 solve_exact_affine_inequality().

被这些函数引用 solve_exact_affine_inequality().

函数调用图:

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

solve_exact_polynomial_inequality()

Result< IntervalUnion > LMCAS::detail::inequality_support::solve_exact_polynomial_inequality	(	const Polynomial< Rational > &	polynomial,
		InequalityType	type,
		ComputationContext &	context )

在文件 inequality_solver_polynomial.cpp 第 470 行定义.

                                 {
    return solve_exact_polynomial_inequality_impl(polynomial, type, context);
}

引用了 LMCAS::detail::context , 以及 solve_exact_polynomial_inequality().

被这些函数引用 solve_exact_polynomial_inequality().

函数调用图:

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

solve_symbolic_poly()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::detail::inequality_support::solve_symbolic_poly	(	const Polynomial< SymbolicPolyCoeff > &	poly,
		const std::string &	variable,
		ComputationContext &	context )

在文件 inequality_solver_numeric.cpp 第 250 行定义.

                                                            {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
 
    if (poly.is_zero() || poly.degree() < 1) {
        return {};
    }
 
    int deg = poly.degree();
    auto get_coeff = [&](int d) -> std::shared_ptr<SymbolicExpr> {
        if (d < 0 || d > deg) {
            return SymbolicExpr::number(0);
        }
        return poly.coeffs[d].val ? poly.coeffs[d].val : SymbolicExpr::number(0);
    };
 
    if (deg == 1) {
 
        auto a = get_coeff(1);
        auto b = get_coeff(0);
        auto neg_b = SymbolicExpr::multiply(b, SymbolicExpr::number(-1));
        auto root = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(neg_b, a)), transform_budget));
        return { root };
    }
 
    auto results = polynomial_solver_detail::solve_by_factoring_impl(poly, variable, context);
    return results;
}

引用了 LMCAS::a, LMCAS::b, LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::detail::context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::get_coeff(), LMCAS::Polynomial< CoeffType >::is_zero(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::polynomial_solver_detail::solve_by_factoring_impl(), solve_symbolic_poly() , 以及 LMCAS::detail::variable.

被这些函数引用 solve_symbolic_poly().

函数调用图:

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

try_checked_numeric_constant()

std::optional< double > LMCAS::detail::inequality_support::try_checked_numeric_constant	(	const SymbolicExpr &	expr,
		ComputationContext &	context )

在文件 inequality_solver_numeric.cpp 第 21 行定义.

                                                           {
    return LMCAS::detail::try_finite_numeric(expr, context);
}

引用了 LMCAS::detail::context, try_checked_numeric_constant() , 以及 LMCAS::detail::try_finite_numeric().

被这些函数引用 append_affine_root(), append_verified_roots(), determine_leading_sign(), root_less_than(), LMCAS::detail::inequality_support::anonymous_namespace{inequality_solver_ordering.cpp}::root_power_sign(), roots_equal(), snap_verified_integer_root() , 以及 try_checked_numeric_constant().

函数调用图:

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