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

类
struct	CriticalPoint

函数
bool	has_unrecognized_variable_polynomial (const std::shared_ptr< SymbolicExpr > &expression, const std::string &variable)
void	include_rational_zeros (std::vector< Interval > &intervals, const std::vector< CriticalPoint > &points, ComputationContext &context)
std::vector< CriticalPoint >	rational_critical_points (const std::shared_ptr< SymbolicExpr > &numerator, const std::shared_ptr< SymbolicExpr > &denominator, const std::string &variable, ComputationContext &context)
std::vector< Interval >	rational_sign_intervals (const std::vector< CriticalPoint > &critical_points, int combined_leading_sign, int target_sign)
IntervalUnion	zero_numerator_domain (const std::shared_ptr< SymbolicExpr > &denominator, InequalityType type, const std::string &variable, ComputationContext &context)

---

类说明

LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::CriticalPoint

struct LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::CriticalPoint

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

LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::CriticalPoint 的协作图:

类成员
int	den_multiplicity
int	num_multiplicity
shared_ptr< SymbolicExpr >	value

函数说明

has_unrecognized_variable_polynomial()

bool LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::has_unrecognized_variable_polynomial	(	const std::shared_ptr< SymbolicExpr > &	expression,
		const std::string &	variable )

在文件 inequality_solver_rational.cpp 第 123 行定义.

                                                                              {
    auto polynomial = symbolic_to_poly<Rational>(expression, variable);
    return !polynomial;
}

引用了 has_unrecognized_variable_polynomial() , 以及 LMCAS::variable.

被这些函数引用 has_unrecognized_variable_polynomial().

函数调用图:

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

include_rational_zeros()

void LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::include_rational_zeros	(	std::vector< Interval > &	intervals,
		const std::vector< CriticalPoint > &	points,
		ComputationContext &	context )

在文件 inequality_solver_rational.cpp 第 129 行定义.

                                 {
    for (const auto& point : points) {
        if (point.num_multiplicity > 0 && point.den_multiplicity == 0) {
            include_numeric_root(intervals, point.value, context);
        }
    }
}

引用了 LMCAS::context, LMCAS::detail::inequality_support::include_numeric_root(), include_rational_zeros() , 以及 LMCAS::point.

被这些函数引用 include_rational_zeros().

函数调用图:

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

rational_critical_points()

std::vector< CriticalPoint > LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::rational_critical_points	(	const std::shared_ptr< SymbolicExpr > &	numerator,
		const std::shared_ptr< SymbolicExpr > &	denominator,
		const std::string &	variable,
		ComputationContext &	context )

在文件 inequality_solver_rational.cpp 第 61 行定义.

                                                            {
    auto num_roots_with_mult = find_roots_with_multiplicity(numerator, variable, context);
 
    auto den_roots_with_mult = find_roots_with_multiplicity(denominator, variable, context);
    std::vector<CriticalPoint> critical_points;
 
    for (const auto& [root, mult] : num_roots_with_mult) {
        critical_points.push_back({root, mult, 0});
    }
    for (const auto& [root, mult] : den_roots_with_mult) {
 
        bool found = false;
        for (auto& cp : critical_points) {
            if (roots_equal(cp.value, root, context)) {
                cp.den_multiplicity = mult;
                found = true;
                break;
            }
        }
        if (!found) {
            critical_points.push_back({root, 0, mult});
        }
    }
 
    std::sort(critical_points.begin(), critical_points.end(),
        [&context](const CriticalPoint& a, const CriticalPoint& b) {
            return root_less_than(a.value, b.value, context);
        });
    return critical_points;
}

引用了 LMCAS::a, LMCAS::b, LMCAS::context, LMCAS::denominator, LMCAS::detail::inequality_support::find_roots_with_multiplicity(), rational_critical_points(), LMCAS::detail::inequality_support::roots_equal() , 以及 LMCAS::variable.

被这些函数引用 rational_critical_points().

函数调用图:

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

rational_sign_intervals()

std::vector< Interval > LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::rational_sign_intervals	(	const std::vector< CriticalPoint > &	critical_points,
		int	combined_leading_sign,
		int	target_sign )

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

                                                {
    size_t n_cp = critical_points.size();
    std::vector<int> interval_signs(n_cp + 1);
 
    interval_signs[n_cp] = combined_leading_sign;
 
    for (int i = (int)n_cp - 1; i >= 0; --i) {
        int total_mult = critical_points[i].num_multiplicity + critical_points[i].den_multiplicity;
        interval_signs[i] = interval_signs[i + 1];
        if (total_mult % 2 != 0) {
            interval_signs[i] = -interval_signs[i];
        }
    }
    std::vector<Interval> result_intervals;
    for (size_t i = 0; i <= n_cp; ++i) {
        if (interval_signs[i] != target_sign) {
            continue;
        }
        Interval interval;
        interval.lower = i == 0 ? Endpoint::neg_inf() : Endpoint::open(critical_points[i - 1].value);
        interval.upper = i == n_cp ? Endpoint::pos_inf() : Endpoint::open(critical_points[i].value);
        result_intervals.push_back(interval);
    }
    return result_intervals;
}

引用了 LMCAS::interval(), rational_sign_intervals() , 以及 LMCAS::value.

被这些函数引用 rational_sign_intervals().

函数调用图:

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

zero_numerator_domain()

IntervalUnion LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::zero_numerator_domain	(	const std::shared_ptr< SymbolicExpr > &	denominator,
		InequalityType	type,
		const std::string &	variable,
		ComputationContext &	context )

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

                                                                 {
    if (type == InequalityType::GreaterThan || type == InequalityType::LessThan) {
        return IntervalUnion::empty();
    }
 
    auto den_roots_with_mult = find_roots_with_multiplicity(denominator, variable, context);
    if (den_roots_with_mult.empty()) {
        return IntervalUnion::entire_line();
    }
 
    std::vector<std::shared_ptr<SymbolicExpr>> den_roots;
    for (const auto& [root, mult] : den_roots_with_mult) {
        den_roots.push_back(root);
    }
    std::sort(den_roots.begin(), den_roots.end(),
        [&context](const auto& lhs, const auto& rhs) {
            return root_less_than(lhs, rhs, context);
        });
 
    std::vector<Interval> intervals;
 
    {
        Interval iv;
        iv.lower = Endpoint::neg_inf();
        iv.upper = Endpoint::open(den_roots[0]);
        intervals.push_back(iv);
    }
    for (size_t i = 0; i + 1 < den_roots.size(); ++i) {
        Interval iv;
        iv.lower = Endpoint::open(den_roots[i]);
        iv.upper = Endpoint::open(den_roots[i + 1]);
        intervals.push_back(iv);
    }
 
    {
        Interval iv;
        iv.lower = Endpoint::open(den_roots.back());
        iv.upper = Endpoint::pos_inf();
        intervals.push_back(iv);
    }
    return IntervalUnion(intervals);
}

引用了 LMCAS::context, LMCAS::denominator, LMCAS::detail::inequality_support::find_roots_with_multiplicity(), LMCAS::GreaterThan, LMCAS::LessThan, LMCAS::rhs, LMCAS::variable , 以及 zero_numerator_domain().

被这些函数引用 zero_numerator_domain().

函数调用图:

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