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

类型定义
using	PiecewiseResult = Result<PiecewiseIntervalResult>

函数
Result< void >	check_arguments (const std::shared_ptr< SymbolicExpr > &expr, const std::string &variable, const std::vector< std::string > &parameters)
PiecewiseResult	checked_piecewise (PiecewiseResult result, detail::RewriteBudget &budget)
PiecewiseResult	constant_solution (const std::shared_ptr< SymbolicExpr > &coefficient, InequalityType type)
template<typename Node>
Result< void >	exact_operands (const Node &node, const std::string &variable, const std::vector< std::string > &parameters, ComputationContext &context, std::size_t depth)
Result< void >	exact_polynomial_nodes (const detail::SymbolicNodePtr &node, const std::string &variable, const std::vector< std::string > &parameters, ComputationContext &context, std::size_t depth)
PiecewiseResult	inconclusive ()
Result< Interval >	linear_interval (const std::vector< std::shared_ptr< SymbolicExpr > > &coeffs, InequalityType type, detail::RewriteBudget &budget)
PiecewiseResult	nonlinear_solution (const std::vector< std::shared_ptr< SymbolicExpr > > &coeffs, int degree, InequalityType type, ComputationContext &context)
PiecewiseResult	quadratic_solution (const std::shared_ptr< SymbolicExpr > &coefficient, InequalityType type, ComputationContext &context)
bool	satisfies (int sign, InequalityType type)
std::shared_ptr< SymbolicExpr >	sign_condition (const std::shared_ptr< SymbolicExpr > &coefficient, int sign)
Result< std::vector< std::shared_ptr< SymbolicExpr > > >	simplify_coefficients (const Polynomial< SymbolicPolyCoeff > &poly, bool &symbolic, detail::RewriteBudget &budget)
PiecewiseResult	solved_inequality (const std::shared_ptr< SymbolicExpr > &expr, InequalityType type, const std::string &variable, ComputationContext &context)
IntervalUnion	zero_polynomial_solution (InequalityType type)

变量
constexpr const char *	kParametricOperation = "solve_parametric_inequality_checked"

类型定义说明

PiecewiseResult

using LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::PiecewiseResult = Result<PiecewiseIntervalResult>

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

函数说明

check_arguments()

Result< void > LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::check_arguments	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	variable,
		const std::vector< std::string > &	parameters )

在文件 inequality_solver_parametric.cpp 第 181 行定义.

                                            {
    if (parameters.empty()) return Result<void>::success();
    if (!expr || !detail::node(expr) || variable.empty()) {
        return Result<void>::failure(
            CasErrc::InvalidArgument, "inequality expression and variable must not be empty",
            kParametricOperation);
    }
    if (std::find(parameters.begin(), parameters.end(), variable) != parameters.end()) {
        return Result<void>::failure(
            CasErrc::InvalidArgument, "inequality variable cannot also be a parameter",
            kParametricOperation);
    }
    return Result<void>::success();
}

引用了 check_arguments(), LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, kParametricOperation, LMCAS::detail::node(), LMCAS::Result< T >::success() , 以及 LMCAS::variable.

被这些函数引用 check_arguments().

函数调用图:

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

checked_piecewise()

PiecewiseResult LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::checked_piecewise	(	PiecewiseResult	result,
		detail::RewriteBudget &	budget )

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

                                                                                       {
    if (!result) { return result; }
    budget.consume();
    std::size_t nodes = 0;
    for (const auto& branch : result.value().cases) {
        nodes = budget.append_size(nodes, budget.measure(detail::node(branch.condition)));
        for (const auto& interval : branch.solution.intervals()) {
            nodes = budget.append_size(nodes, budget.measure(detail::node(interval.lower.value)));
            nodes = budget.append_size(nodes, budget.measure(detail::node(interval.upper.value)));
        }
    }
    return result;
}

引用了 LMCAS::detail::RewriteBudget::append_size(), checked_piecewise(), LMCAS::detail::RewriteBudget::consume(), LMCAS::interval(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::node() , 以及 LMCAS::Result< T >::value().

被这些函数引用 checked_piecewise().

函数调用图:

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

constant_solution()

PiecewiseResult LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::constant_solution	(	const std::shared_ptr< SymbolicExpr > &	coefficient,
		InequalityType	type )

在文件 inequality_solver_parametric.cpp 第 150 行定义.

                                                       {
    PiecewiseIntervalResult result;
    for (int sign : {1, 0, -1}) {
        result.cases.push_back({
            sign_condition(coefficient, sign),
            satisfies(sign, type) ? IntervalUnion::entire_line()
                                  : IntervalUnion::empty()});
    }
    return result;
}

引用了 constant_solution(), satisfies() , 以及 sign_condition().

被这些函数引用 constant_solution() , 以及 nonlinear_solution().

函数调用图:

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

exact_operands()

template<typename Node>

Result< void > LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::exact_operands	(	const Node &	node,
		const std::string &	variable,
		const std::vector< std::string > &	parameters,
		ComputationContext &	context,
		std::size_t	depth )

在文件 inequality_solver_parametric.cpp 第 102 行定义.

                                                                          {
    for (const auto& operand : node.operands()) {
        auto checked = exact_polynomial_nodes(
            operand, variable, parameters, context, depth + 1);
        if (!checked) return checked;
    }
    return Result<void>::success();
}

引用了 LMCAS::context, LMCAS::depth, exact_operands(), exact_polynomial_nodes(), LMCAS::Result< T >::success() , 以及 LMCAS::variable.

被这些函数引用 exact_operands() , 以及 exact_polynomial_nodes().

函数调用图:

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

exact_polynomial_nodes()

Result< void > LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::exact_polynomial_nodes	(	const detail::SymbolicNodePtr &	node,
		const std::string &	variable,
		const std::vector< std::string > &	parameters,
		ComputationContext &	context,
		std::size_t	depth )

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

                     {
    if (depth >= context.limits().max_recursion_depth) {
        return Result<void>::failure(CasErrc::ResourceLimit,
            "parameter expression recursion limit exceeded", kParametricOperation);
    }
    auto step = context.consume_steps(1, kParametricOperation);
    if (!step) return step;
    if (const auto number = std::dynamic_pointer_cast<const NumberNode>(node)) {
        if (detail::exact_rational_value(*number)) return Result<void>::success();
    } else if (const auto symbol = std::dynamic_pointer_cast<const VariableNode>(node)) {
        if (!symbol->is_constant() &&
            (symbol->name() == variable ||
             std::find(parameters.begin(), parameters.end(), symbol->name()) != parameters.end())) {
            return Result<void>::success();
        }
    } else if (const auto sum = std::dynamic_pointer_cast<const AddNode>(node)) {
        return exact_operands(*sum, variable, parameters, context, depth);
    } else if (const auto product = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        return exact_operands(*product, variable, parameters, context, depth);
    } else if (const auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        if (exact_small_integer_node(
                power->exponent(), 0, std::numeric_limits<int>::max())) {
            return exact_polynomial_nodes(
                power->base(), variable, parameters, context, depth + 1);
        }
    }
    return Result<void>::failure(CasErrc::Inconclusive,
        "parameter expression is not an exact polynomial", kParametricOperation);
}

引用了 LMCAS::context, LMCAS::depth, exact_operands(), exact_polynomial_nodes(), LMCAS::detail::exact_rational_value(), LMCAS::exact_small_integer_node(), LMCAS::Result< T >::failure(), LMCAS::Inconclusive, kParametricOperation, LMCAS::ResourceLimit, LMCAS::Result< T >::success() , 以及 LMCAS::variable.

被这些函数引用 exact_operands() , 以及 exact_polynomial_nodes().

函数调用图:

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

inconclusive()

PiecewiseResult LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::inconclusive

(

)

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

                               {
    return PiecewiseResult::failure(
        CasErrc::Inconclusive,
        "parameter signs or quadratic roots cannot be certified",
        kParametricOperation);
}

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

被这些函数引用 inconclusive(), linear_interval() , 以及 nonlinear_solution().

函数调用图:

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

linear_interval()

Result< Interval > LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::linear_interval	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	coeffs,
		InequalityType	type,
		detail::RewriteBudget &	budget )

在文件 inequality_solver_parametric.cpp 第 113 行定义.

                                                      {
    const auto slope = detail::exact_rational_value(detail::node(coeffs[1]));
    if (!slope) {
        return Result<Interval>::failure(inconclusive().error());
    }
    if (*slope == Rational(0)) {
        return Result<Interval>::failure(inconclusive().error());
    }
    std::optional<detail::AssumptionFacts> facts;
    if (budget.context().assumptions()) { facts.emplace(*budget.context().assumptions()); }
    auto root = detail::make_expression_ptr(detail::normalize_node(
        detail::node(SymbolicExpr::divide(
            SymbolicExpr::multiply(SymbolicExpr::number(-1), coeffs[0]), coeffs[1])),
        budget, facts ? *facts : detail::no_facts()));
 
    const bool greater = satisfies(1, type);
    const bool strict = type == InequalityType::GreaterThan ||
                        type == InequalityType::LessThan;
    const bool above = greater != slope->get_numerator().is_negative();
    const auto endpoint = strict ? Endpoint::open(root)
                                 : Endpoint::closed(root);
    return above ? Interval{endpoint, Endpoint::pos_inf()}
                 : Interval{Endpoint::neg_inf(), endpoint};
}

引用了 LMCAS::ComputationContext::assumptions(), LMCAS::detail::RewriteBudget::context(), LMCAS::detail::exact_rational_value(), LMCAS::Result< T >::failure(), LMCAS::GreaterThan, inconclusive(), LMCAS::LessThan, linear_interval(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::no_facts(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 satisfies().

被这些函数引用 linear_interval().

函数调用图:

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

nonlinear_solution()

PiecewiseResult LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::nonlinear_solution	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	coeffs,
		int	degree,
		InequalityType	type,
		ComputationContext &	context )

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

                                                                  {
    if (degree == 0) return constant_solution(coeffs[0], type);
    if (!coeffs[0]->is_zero() || !coeffs[1]->is_zero()) return inconclusive();
    return quadratic_solution(coeffs[2], type, context);
}

引用了 constant_solution(), LMCAS::context, inconclusive(), nonlinear_solution() , 以及 quadratic_solution().

被这些函数引用 nonlinear_solution().

函数调用图:

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

quadratic_solution()

PiecewiseResult LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::quadratic_solution	(	const std::shared_ptr< SymbolicExpr > &	coefficient,
		InequalityType	type,
		ComputationContext &	context )

在文件 inequality_solver_parametric.cpp 第 162 行定义.

                                                                                     {
    PiecewiseIntervalResult result;
    for (int sign : {1, 0, -1}) {
        auto solution = sign == 0 ? zero_polynomial_solution(type)
            : detail::inequality_support::build_parametric_intervals(
                {SymbolicExpr::number(0)}, {2}, sign, type, context);
        result.cases.push_back({sign_condition(coefficient, sign), std::move(solution)});
    }
    return result;
}

引用了 LMCAS::detail::inequality_support::build_parametric_intervals(), LMCAS::context, quadratic_solution(), sign_condition() , 以及 zero_polynomial_solution().

被这些函数引用 nonlinear_solution() , 以及 quadratic_solution().

函数调用图:

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

satisfies()

bool LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::satisfies	(	int	sign,
		InequalityType	type )

在文件 inequality_solver_parametric.cpp 第 45 行定义.

                                              {
    switch (type) {
        case InequalityType::GreaterThan: return sign > 0;
        case InequalityType::GreaterEqual: return sign >= 0;
        case InequalityType::LessThan: return sign < 0;
        case InequalityType::LessEqual: return sign <= 0;
    }
    return false;
}

引用了 LMCAS::GreaterEqual, LMCAS::GreaterThan, LMCAS::LessEqual, LMCAS::LessThan , 以及 satisfies().

被这些函数引用 constant_solution(), linear_interval() , 以及 satisfies().

函数调用图:

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

sign_condition()

std::shared_ptr< SymbolicExpr > LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::sign_condition	(	const std::shared_ptr< SymbolicExpr > &	coefficient,
		int	sign )

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

                                                              {
    const auto op = sign > 0 ? RelationalNode::Op::GT
        : sign < 0 ? RelationalNode::Op::LT : RelationalNode::Op::EQ;
    return detail::make_expression_ptr(detail::make_node<RelationalNode>(
        detail::node(coefficient), detail::node(SymbolicExpr::number(0)), op));
}

引用了 LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::op , 以及 sign_condition().

被这些函数引用 constant_solution(), quadratic_solution() , 以及 sign_condition().

函数调用图:

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

simplify_coefficients()

Result< std::vector< std::shared_ptr< SymbolicExpr > > > LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::simplify_coefficients	(	const Polynomial< SymbolicPolyCoeff > &	poly,
		bool &	symbolic,
		detail::RewriteBudget &	budget )

在文件 inequality_solver_parametric.cpp 第 198 行定义.

                                 {
    std::vector<std::shared_ptr<SymbolicExpr>> coeffs;
    coeffs.reserve(poly.coeffs.size());
    std::optional<detail::AssumptionFacts> facts;
    if (budget.context().assumptions()) { facts.emplace(*budget.context().assumptions()); }
    std::size_t nodes = 0;
    for (const auto& coefficient : poly.coeffs) {
        auto value = detail::make_expression_ptr(detail::normalize_node(
            detail::node(coefficient.val), budget, facts ? *facts : detail::no_facts()));
        nodes = budget.append_size(nodes, budget.measure(detail::node(value)));
        if (!detail::exact_rational_value(detail::node(value))) symbolic = true;
        coeffs.push_back(std::move(value));
    }
    return coeffs;
}

引用了 LMCAS::detail::RewriteBudget::append_size(), LMCAS::ComputationContext::assumptions(), LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::detail::RewriteBudget::context(), LMCAS::detail::exact_rational_value(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::no_facts(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), simplify_coefficients() , 以及 LMCAS::value.

被这些函数引用 simplify_coefficients().

函数调用图:

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

solved_inequality()

PiecewiseResult LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::solved_inequality	(	const std::shared_ptr< SymbolicExpr > &	expr,
		InequalityType	type,
		const std::string &	variable,
		ComputationContext &	context )

在文件 inequality_solver_parametric.cpp 第 140 行定义.

                                                            {
    auto solved = InequalitySolver::solve_inequality_checked(expr, type, variable, context);
    if (!solved) return PiecewiseResult::failure(solved.error());
    PiecewiseIntervalResult result;
    result.cases.push_back({nullptr, std::move(solved.value())});
    return result;
}

引用了 LMCAS::context, LMCAS::Result< PiecewiseIntervalResult >::failure(), solved_inequality() , 以及 LMCAS::variable.

被这些函数引用 solved_inequality().

函数调用图:

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

zero_polynomial_solution()

IntervalUnion LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::zero_polynomial_solution

(

InequalityType

type

)

在文件 inequality_solver_parametric.cpp 第 39 行定义.

                                                            {
    return type == InequalityType::GreaterEqual || type == InequalityType::LessEqual
        ? IntervalUnion::entire_line()
        : IntervalUnion::empty();
}

引用了 LMCAS::GreaterEqual, LMCAS::LessEqual , 以及 zero_polynomial_solution().

被这些函数引用 quadratic_solution() , 以及 zero_polynomial_solution().

函数调用图:

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

变量说明

kParametricOperation

const char* LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::kParametricOperation = "solve_parametric_inequality_checked"

constexpr

在文件 inequality_solver_parametric.cpp 第 14 行定义.

被这些函数引用 check_arguments(), exact_polynomial_nodes() , 以及 inconclusive().