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

命名空间
namespace	anonymous_namespace{integration_definite_segments.cpp}

类
struct	Boundary
struct	RationalFunction

类型定义
using	Algebraic = ExactRealAlgebraic
using	Node = std::shared_ptr<const SymbolicNode>
using	Poly = Polynomial<Rational>
using	RationalResult = Result<std::optional<RationalFunction>>

函数
Node	absolute_argument (const SymbolicNode &node)
	识别绝对值节点及公共接口的平方开根表示。
Result< Boundary >	boundary_checked (const SymbolicExpr &expression, ComputationContext &context)
static Result< SymbolicExpr >	boundary_value_checked (const SymbolicExpr &primitive, const std::string &var, const SymbolicExpr &point, LimitDirection direction, ComputationContext &context)
Result< Tribool >	certify_continuity_checked (const SymbolicExpr &expression, const std::string &var, const SymbolicExpr &lower, const SymbolicExpr &upper, ComputationContext &context)
static Result< void >	collect_predicate_roots (const Node &condition, const std::string &var, std::vector< Algebraic > &roots, ComputationContext &context)
Result< int >	compare_boundaries (const Boundary &a, const Boundary &b, ComputationContext &context)
static Result< Tribool >	continuous_children (const std::vector< Node > &children, const FactsQuery &facts, ComputationContext &context)
static bool	continuous_function_family (FunctionNode::FuncType type)
static Result< Tribool >	defined_on_interval (const Node &node, const FactsQuery &facts, ComputationContext &context)
Result< std::vector< SymbolicExpr > >	definite_partition_checked (const SymbolicExpr &original, const std::string &var, const SymbolicExpr &lower, const SymbolicExpr &upper, ComputationContext &context)
Result< SymbolicExpr >	definite_segment_checked (const SymbolicExpr &original, const SymbolicExpr &primitive, const std::string &var, const SymbolicExpr &a, const SymbolicExpr &b, ComputationContext &context)
template<class T>
Result< T >	divergent ()
static Result< SymbolicExpr >	evaluate_segment_endpoints (const SymbolicExpr &candidate, const std::string &var, const SymbolicExpr &a, const SymbolicExpr &b, bool concrete_endpoints, ComputationContext &context)
std::optional< Rational >	exact_number (const Node &node)
static Result< Poly >	gcd_checked (Poly a, Poly b, ComputationContext &context)
static bool	include_divergence (int &divergence, int contribution)
int	infinity_sign (const Node &node)
bool	is_undecided (const CasError &error)
bool	needs_segment_expression (const Node &node)
static Result< std::vector< Algebraic > >	ordered_partition_roots (std::vector< Algebraic > &roots, const Boundary &a, const Boundary &b, ComputationContext &context)
static Result< void >	original_conditions_checked (const Node &node, const FactsQuery &facts, std::vector< std::shared_ptr< SymbolicExpr > > &conditions, ComputationContext &context)
static Result< int >	polynomial_at_root_sign (Poly polynomial, Algebraic root, ComputationContext &context)
static Result< void >	polynomial_budget (const Poly &polynomial, ComputationContext &context)
Result< std::optional< int > >	polynomial_sign_checked (const Poly &polynomial, const Boundary &a, const Boundary &b, ComputationContext &context)
static Result< void >	prepare_segment_primitive (SymbolicExpr &candidate, const std::string &var, const SymbolicExpr &lower, const SymbolicExpr &upper, ComputationContext &context)
Result< Poly >	product_checked (const Poly &a, const Poly &b, ComputationContext &context)
RationalResult	rational_checked (const Node &node, const std::string &var, ComputationContext &context)
Result< int >	rational_divergence_checked (RationalFunction &rational, const Boundary &a, const Boundary &b, ComputationContext &context)
static RationalResult	rational_operands_checked (const std::vector< Node > &operands, bool sum, const std::string &var, ComputationContext &context)
static Result< void >	rational_pole_divergence (const RationalFunction &rational, const Algebraic &root, const Boundary &a, const Boundary &b, int &divergence, ComputationContext &context)
static RationalResult	rational_power_checked (const PowerNode &power, const std::string &var, ComputationContext &context)
Result< AssumptionContext >	real_assumptions (const std::string &var, ComputationContext &context)
static Result< void >	recover_rational_cut (Algebraic &root, const BigInt &denominator_bound, ComputationContext &context)
Result< std::vector< Algebraic > >	roots_checked (const Poly &polynomial, ComputationContext &context)
Result< SymbolicExpr >	segment_expression_checked (const SymbolicExpr &expression, const std::string &var, const SymbolicExpr &lower, const SymbolicExpr &upper, ComputationContext &context)
static int	sign (const Rational &value)
static Result< Tribool >	structurally_continuous (const Node &node, const FactsQuery &facts, ComputationContext &context)
template<class T>
Result< T >	undecided ()

变量
constexpr const char *	operation = "integrate.definite"

---

类说明

LMCAS::detail::definite::Boundary

struct LMCAS::detail::definite::Boundary

在文件 integration_definite_support.hpp 第 12 行定义.

LMCAS::detail::definite::Boundary 的协作图:

类成员
Algebraic	finite
int	infinity = 0

LMCAS::detail::definite::RationalFunction

struct LMCAS::detail::definite::RationalFunction

在文件 integration_definite_support.hpp 第 17 行定义.

LMCAS::detail::definite::RationalFunction 的协作图:

类成员
Poly	denominator
Poly	numerator

类型定义说明

Algebraic

using LMCAS::detail::definite::Algebraic = ExactRealAlgebraic

在文件 integration_definite_support.hpp 第 9 行定义.

Node

using LMCAS::detail::definite::Node = std::shared_ptr<const SymbolicNode>

在文件 integration_definite_support.hpp 第 7 行定义.

Poly

using LMCAS::detail::definite::Poly = Polynomial<Rational>

在文件 integration_definite_support.hpp 第 8 行定义.

RationalResult

using LMCAS::detail::definite::RationalResult = Result<std::optional<RationalFunction>>

在文件 integration_definite_support.hpp 第 18 行定义.

函数说明

absolute_argument()

Node LMCAS::detail::definite::absolute_argument

(

const SymbolicNode &

node

)

识别绝对值节点及公共接口的平方开根表示。

前置条件

调用方须先证明参数为实数，再在开区间上使用 |u| = ±u。

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

                                                 {
    Node radicand;
    if (const auto* function = dynamic_cast<const FunctionNode*>(&node)) {
        if (function->arguments().size() != 1) return nullptr;
        if (function->type() == FunctionNode::FuncType::Abs) return function->arguments()[0];
        if (function->type() != FunctionNode::FuncType::Sqrt) return nullptr;
        radicand = function->arguments()[0];
    } else if (const auto* power = dynamic_cast<const PowerNode*>(&node)) {
        auto exponent = exact_number(power->exponent());
        if (!exponent || *exponent != Rational(1, 2)) return nullptr;
        radicand = power->base();
    } else return nullptr;
    const auto* square = dynamic_cast<const PowerNode*>(radicand.get());
    if (!square) return nullptr;
    auto exponent = exact_number(square->exponent());
    return exponent && *exponent == Rational(2) ? square->base() : nullptr;
}

引用了 LMCAS::FunctionNode::Abs, absolute_argument(), exact_number(), LMCAS::exponent, LMCAS::function(), LMCAS::detail::node() , 以及 LMCAS::FunctionNode::Sqrt.

被这些函数引用 absolute_argument(), needs_segment_expression(), original_conditions_checked(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentExpression::visit() , 以及 LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentExpression::visit().

函数调用图:

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

boundary_checked()

Result< Boundary > LMCAS::detail::definite::boundary_checked	(	const SymbolicExpr &	expression,
		ComputationContext &	context )

在文件 integration_definite_algebraic.cpp 第 64 行定义.

                                 {
    if (int infinity = infinity_sign(detail::node(expression)))
        return Boundary{infinity, {}};
    if (auto rational = exact_number(detail::node(expression)))
        return Boundary{0, {Poly({-*rational, Rational(1)}), *rational, *rational, 0, 1}};
    if (dynamic_cast<const NumberNode*>(detail::node(expression).get()))
        return Result<Boundary>::failure(CasErrc::DomainError,
            "nonfinite numeric endpoint requires a typed infinity", operation);
    if (const auto* root = dynamic_cast<const RootOfNode*>(detail::node(expression).get())) {
        auto value = detail::make_exact_real_algebraic(
            root->exact_id().polynomial, root->index(), 1, context);
        if (!value) return Result<Boundary>::failure(value.error());
        return Boundary{0, std::move(value.value())};
    }
    return undecided<Boundary>();
}

引用了 boundary_checked(), LMCAS::detail::context, LMCAS::DomainError, exact_number(), LMCAS::Result< T >::failure(), infinity_sign(), LMCAS::detail::make_exact_real_algebraic(), LMCAS::detail::node(), operation, LMCAS::rational(), undecided() , 以及 LMCAS::value.

被这些函数引用 LMCAS::anonymous_namespace{integration_definite.cpp}::DefiniteInterval::DefiniteInterval(), boundary_checked(), certify_continuity_checked(), definite_partition_checked(), definite_segment_checked(), prepare_segment_primitive() , 以及 segment_expression_checked().

函数调用图:

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

boundary_value_checked()

Result< SymbolicExpr > LMCAS::detail::definite::boundary_value_checked ( const SymbolicExpr & primitive, const std::string & var, const SymbolicExpr & point, LimitDirection direction, ComputationContext & context )

static

在文件 integration_definite_segments.cpp 第 519 行定义.

                                 {
    auto result = limit_checked(detail::make_expression_ptr(primitive), var, detail::make_expression_ptr(point), direction, context);
    if (!result) return Result<SymbolicExpr>::failure(result.error());
    const auto& outcome = result.value().value;
    if (const auto* finite = std::get_if<FiniteLimit>(&outcome)) return *finite->value;
    if (std::holds_alternative<PositiveInfinityLimit>(outcome)) return *SymbolicExpr::infinity(1);
    if (std::holds_alternative<NegativeInfinityLimit>(outcome)) return *SymbolicExpr::infinity(-1);
    return divergent<SymbolicExpr>();
}

引用了 boundary_value_checked(), LMCAS::detail::context, LMCAS::direction, divergent(), LMCAS::Result< T >::failure(), LMCAS::limit_checked(), LMCAS::detail::make_expression_ptr(), LMCAS::point , 以及 LMCAS::Result< T >::value().

被这些函数引用 boundary_value_checked() , 以及 evaluate_segment_endpoints().

函数调用图:

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

certify_continuity_checked()

Result< Tribool > LMCAS::detail::definite::certify_continuity_checked	(	const SymbolicExpr &	expression,
		const std::string &	var,
		const SymbolicExpr &	lower,
		const SymbolicExpr &	upper,
		ComputationContext &	context )

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

                                 {
    auto effective = segment_expression_checked(expression, var, lower, upper, context);
    if (!effective) { return is_undecided(effective.error()) ? Result<Tribool>(Tribool::Unknown) :
        Result<Tribool>::failure(effective.error()); }
    auto assumptions = real_assumptions(var, context);
    if (!assumptions) { return Result<Tribool>::failure(assumptions.error()); }
    detail::AssumptionFacts global(assumptions.value());
    auto everywhere = structurally_continuous(detail::node(effective.value()), global, context);
    if (!everywhere || everywhere.value() != Tribool::Unknown) { return everywhere; }
    auto a = boundary_checked(lower, context);
    auto b = boundary_checked(upper, context);
    if (!a) { return is_undecided(a.error()) ? Result<Tribool>(Tribool::Unknown) : Result<Tribool>::failure(a.error()); }
    if (!b) { return is_undecided(b.error()) ? Result<Tribool>(Tribool::Unknown) : Result<Tribool>::failure(b.error()); }
    SegmentFacts facts(assumptions.value(), var, a.value(), b.value());
    return structurally_continuous(detail::node(effective.value()), facts, context);
}

引用了 LMCAS::a, LMCAS::b, boundary_checked(), certify_continuity_checked(), LMCAS::detail::context, LMCAS::Result< T >::error(), LMCAS::detail::facts, LMCAS::Result< T >::failure(), is_undecided(), LMCAS::lower, LMCAS::detail::node(), real_assumptions(), segment_expression_checked(), structurally_continuous(), LMCAS::Unknown, LMCAS::upper , 以及 LMCAS::Result< T >::value().

被这些函数引用 certify_continuity_checked(), LMCAS::anonymous_namespace{integration_definite.cpp}::certify_partition(), definite_segment_checked() , 以及 prepare_segment_primitive().

函数调用图:

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

collect_predicate_roots()

Result< void > LMCAS::detail::definite::collect_predicate_roots ( const Node & condition, const std::string & var, std::vector< Algebraic > & roots, ComputationContext & context )

static

在文件 integration_definite_segments.cpp 第 225 行定义.

                                                              {
    auto step = context.consume_steps(1, operation);
    if (!step) { return step; }
    if (const auto* logical = dynamic_cast<const LogicalNode*>(condition.get())) {
        auto left = collect_predicate_roots(logical->left(), var, roots, context);
        if (!left) { return left; }
        if (logical->right()) { return collect_predicate_roots(logical->right(), var, roots, context); }
        return Result<void>::success();
    }
    const auto* relation = dynamic_cast<const RelationalNode*>(condition.get());
    if (!relation) { return undecided<void>(); }
    auto difference = sym_sub(detail::expression_from_node(relation->left()),
        detail::expression_from_node(relation->right()));
    auto rational = rational_checked(detail::node(difference), var, context);
    if (!rational) { return Result<void>::failure(rational.error()); }
    if (!rational.value()) { return undecided<void>(); }
    for (const auto* polynomial : {&rational.value()->numerator, &rational.value()->denominator}) {
        if (polynomial->degree() <= 0) { continue; }
        auto isolated = roots_checked(*polynomial, context);
        if (!isolated) { return Result<void>::failure(isolated.error()); }
        roots.insert(roots.end(), isolated.value().begin(), isolated.value().end());
    }
    return Result<void>::success();
}

引用了 collect_predicate_roots(), LMCAS::detail::context, LMCAS::Result< T >::error(), LMCAS::detail::expression_from_node(), LMCAS::Result< T >::failure(), LMCAS::detail::node(), operation, LMCAS::rational(), rational_checked(), LMCAS::relation(), LMCAS::roots(), roots_checked(), LMCAS::Result< T >::success(), LMCAS::sym_sub(), undecided() , 以及 LMCAS::Result< T >::value().

被这些函数引用 collect_predicate_roots() , 以及 definite_partition_checked().

函数调用图:

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

compare_boundaries()

Result< int > LMCAS::detail::definite::compare_boundaries	(	const Boundary &	a,
		const Boundary &	b,
		ComputationContext &	context )

在文件 integration_definite_algebraic.cpp 第 82 行定义.

                                 {
    if (a.infinity || b.infinity)
        { return a.infinity < b.infinity ? -1 : a.infinity > b.infinity ? 1 : 0; }
    auto left = a.finite;
    auto right = b.finite;
    right.polynomial.variable_name = left.polynomial.variable_name;
    if (!(left.upper < right.lower) && !(right.upper < left.lower)) {
        auto equal = detail::equal_exact_real_algebraic(left, right, context);
        if (!equal) { return Result<int>::failure(equal.error()); }
        if (equal.value()) { return 0; }
        while (!(left.upper < right.lower) && !(right.upper < left.lower)) {
            auto refined = detail::refine_exact_real_algebraic(left, context, operation);
            if (!refined) { return Result<int>::failure(refined.error()); }
            refined = detail::refine_exact_real_algebraic(right, context, operation);
            if (!refined) { return Result<int>::failure(refined.error()); }
        }
    }
    return detail::compare_exact_real_algebraic(std::move(left), std::move(right), context);
}

引用了 LMCAS::a, LMCAS::b, compare_boundaries(), LMCAS::detail::compare_exact_real_algebraic(), LMCAS::detail::context, LMCAS::detail::equal_exact_real_algebraic(), LMCAS::Result< T >::failure(), operation, LMCAS::detail::refine_exact_real_algebraic() , 以及 LMCAS::right.

被这些函数引用 compare_boundaries(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_interval_checked(), ordered_partition_roots(), polynomial_sign_checked() , 以及 rational_pole_divergence().

函数调用图:

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

continuous_children()

Result< Tribool > LMCAS::detail::definite::continuous_children ( const std::vector< Node > & children, const FactsQuery & facts, ComputationContext & context )

static

在文件 integration_definite_segments.cpp 第 428 行定义.

                                                          {
    for (const auto& child : children) {
        auto continuous = structurally_continuous(child, facts, context);
        if (!continuous || continuous.value() != Tribool::True) { return continuous; }
    }
    return Tribool::True;
}

引用了 LMCAS::detail::context, continuous_children(), LMCAS::detail::facts, structurally_continuous() , 以及 LMCAS::True.

被这些函数引用 continuous_children() , 以及 structurally_continuous().

函数调用图:

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

continuous_function_family()

bool LMCAS::detail::definite::continuous_function_family ( FunctionNode::FuncType type )

static

在文件 integration_definite_segments.cpp 第 405 行定义.

                                                                  {
    using F = FunctionNode::FuncType;
    switch (type) {
    case F::Sin: { return true; }
    case F::Cos: { return true; }
    case F::Exp: { return true; }
    case F::Abs: { return true; }
    case F::ArcTan: { return true; }
    case F::Ln: { return true; }
    case F::Log: { return true; }
    case F::Sqrt: { return true; }
    case F::Sinh: { return true; }
    case F::Cosh: { return true; }
    case F::Tan: { return true; }
    case F::ArcSin: { return true; }
    case F::ArcCos: { return true; }
    default: { return false; }
    }
}

引用了 continuous_function_family().

被这些函数引用 continuous_function_family() , 以及 structurally_continuous().

函数调用图:

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

defined_on_interval()

Result< Tribool > LMCAS::detail::definite::defined_on_interval ( const Node & node, const FactsQuery & facts, ComputationContext & context )

static

在文件 integration_definite_segments.cpp 第 386 行定义.

                                 {
    auto defined = detail::query_definedness(node, facts, Domain::Real, context);
    if (!defined || defined.value() != Tribool::Unknown) { return defined; }
    const auto* interval = dynamic_cast<const SegmentFacts*>(&facts);
    if (!interval) { return defined; }
    auto conditions = detail::domain_constraints(node, facts, Domain::Real, context);
    if (!conditions) { return Result<Tribool>::failure(conditions.error()); }
    if (!conditions.value()) { return Tribool::Unknown; }
    bool unknown = false;
    for (const auto& condition : *conditions.value()) {
        auto truth = predicate_truth(detail::node(condition), *interval, context);
        if (!truth) { return truth; }
        if (truth.value() == Tribool::False) { return Tribool::False; }
        unknown |= truth.value() == Tribool::Unknown;
    }
    return unknown ? Tribool::Unknown : Tribool::True;
}

引用了 LMCAS::detail::context, defined_on_interval(), LMCAS::detail::domain_constraints(), LMCAS::detail::facts, LMCAS::Result< T >::failure(), LMCAS::False, LMCAS::interval(), LMCAS::detail::node(), LMCAS::detail::query_definedness(), LMCAS::Real, LMCAS::True, LMCAS::Unknown , 以及 LMCAS::Result< T >::value().

被这些函数引用 defined_on_interval() , 以及 structurally_continuous().

函数调用图:

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

definite_partition_checked()

Result< std::vector< SymbolicExpr > > LMCAS::detail::definite::definite_partition_checked	(	const SymbolicExpr &	original,
		const std::string &	var,
		const SymbolicExpr &	lower,
		const SymbolicExpr &	upper,
		ComputationContext &	context )

在文件 integration_definite_segments.cpp 第 352 行定义.

                                 {
    auto assumptions = real_assumptions(var, context);
    if (!assumptions) { return Result<std::vector<SymbolicExpr>>::failure(assumptions.error()); }
    detail::AssumptionFacts facts(assumptions.value());
    std::vector<std::shared_ptr<SymbolicExpr>> conditions;
    auto captured = original_conditions_checked(detail::node(original), facts, conditions, context);
    if (!captured) { return Result<std::vector<SymbolicExpr>>::failure(captured.error()); }
    if (conditions.empty()) { return std::vector<SymbolicExpr>{lower, upper}; }
    auto a = boundary_checked(lower, context);
    auto b = boundary_checked(upper, context);
    if (!a) { return Result<std::vector<SymbolicExpr>>::failure(a.error()); }
    if (!b) { return Result<std::vector<SymbolicExpr>>::failure(b.error()); }
    std::vector<Algebraic> roots;
    for (const auto& condition : conditions) {
        auto collected = collect_predicate_roots(detail::node(condition), var, roots, context);
        if (!collected) { return Result<std::vector<SymbolicExpr>>::failure(collected.error()); }
    }
    auto ordered = ordered_partition_roots(roots, a.value(), b.value(), context);
    if (!ordered) { return Result<std::vector<SymbolicExpr>>::failure(ordered.error()); }
    std::vector<SymbolicExpr> result{lower};
    for (const auto& root : ordered.value()) {
        if (root.is_rational()) { result.push_back(*SymbolicExpr::number(root.lower)); }
        else {
            auto expression = make_rootof_checked(poly_to_symbolic(root.polynomial), var, root.root_index, context);
            if (!expression) { return Result<std::vector<SymbolicExpr>>::failure(expression.error()); }
            result.push_back(*expression.value());
        }
    }
    result.push_back(upper);
    return result;
}

引用了 LMCAS::a, LMCAS::b, boundary_checked(), collect_predicate_roots(), LMCAS::detail::context, definite_partition_checked(), LMCAS::Result< T >::error(), LMCAS::detail::facts, LMCAS::lower, LMCAS::make_rootof_checked(), LMCAS::detail::node(), ordered_partition_roots(), original_conditions_checked(), real_assumptions(), LMCAS::roots(), LMCAS::upper , 以及 LMCAS::Result< T >::value().

被这些函数引用 definite_partition_checked() , 以及 LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_ordered_interval().

函数调用图:

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

definite_segment_checked()

Result< SymbolicExpr > LMCAS::detail::definite::definite_segment_checked	(	const SymbolicExpr &	original,
		const SymbolicExpr &	primitive,
		const std::string &	var,
		const SymbolicExpr &	a,
		const SymbolicExpr &	b,
		ComputationContext &	context )

在文件 integration_definite_segments.cpp 第 595 行定义.

                                                                               {
    auto continuous = certify_continuity_checked(original, var, a, b, context);
    if (!continuous) { return Result<SymbolicExpr>::failure(continuous.error()); }
    if (continuous.value() == Tribool::False) { return divergent<SymbolicExpr>(); }
    if (continuous.value() != Tribool::True) { return undecided<SymbolicExpr>(); }
    SymbolicExpr candidate = primitive;
    auto prepared = prepare_segment_primitive(candidate, var, a, b, context);
    if (!prepared) { return Result<SymbolicExpr>::failure(prepared.error()); }
    auto lower = boundary_checked(a, context);
    auto upper = boundary_checked(b, context);
    return evaluate_segment_endpoints(candidate, var, a, b, lower && upper, context);
}

引用了 LMCAS::a, LMCAS::b, boundary_checked(), certify_continuity_checked(), LMCAS::detail::context, definite_segment_checked(), divergent(), evaluate_segment_endpoints(), LMCAS::Result< T >::failure(), LMCAS::False, LMCAS::lower, prepare_segment_primitive(), LMCAS::True, undecided() , 以及 LMCAS::upper.

被这些函数引用 LMCAS::anonymous_namespace{integration_definite.cpp}::accumulate_segments() , 以及 definite_segment_checked().

函数调用图:

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

divergent()

template<class T>

Result< T > LMCAS::detail::definite::divergent

(

)

在文件 integration_definite_support.hpp 第 27 行定义.

                      {
    return Result<T>::failure(CasErrc::DomainError,
        "ordinary improper integral does not exist",
        "integrate.definite.convergence");
}

引用了 divergent(), LMCAS::DomainError , 以及 LMCAS::Result< T >::failure().

被这些函数引用 LMCAS::anonymous_namespace{integration_definite.cpp}::accumulate_segments(), boundary_value_checked(), definite_segment_checked(), divergent(), LMCAS::anonymous_namespace{integration_definite.cpp}::equal_endpoint_integral(), evaluate_segment_endpoints(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_ordered_interval(), rational_divergence_checked() , 以及 rational_pole_divergence().

函数调用图:

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

evaluate_segment_endpoints()

Result< SymbolicExpr > LMCAS::detail::definite::evaluate_segment_endpoints ( const SymbolicExpr & candidate, const std::string & var, const SymbolicExpr & a, const SymbolicExpr & b, bool concrete_endpoints, ComputationContext & context )

static

在文件 integration_definite_segments.cpp 第 564 行定义.

                                                              {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!concrete_endpoints) {
        auto high = detail::make_expression_ptr(detail::substitute_node(detail::node(candidate), var, detail::node(b), transform_budget));
        auto low = detail::make_expression_ptr(detail::substitute_node(detail::node(candidate), var, detail::node(a), transform_budget));
        if (!high || !low) { return Result<SymbolicExpr>::failure(CasErrc::InternalInvariant,
            "primitive substitution returned no expression", operation); }
        return *detail::make_expression_ptr(detail::normalize_node(detail::node(sym_sub(*high, *low)), transform_budget));
    }
    auto high = boundary_value_checked(candidate, var, b, LimitDirection::FromBelow, context);
    auto low = boundary_value_checked(candidate, var, a, LimitDirection::FromAbove, context);
    if (!high) { return high; }
    if (!low) { return low; }
    const int hs = infinity_sign(detail::node(high.value()));
    const int ls = -infinity_sign(detail::node(low.value()));
    if (hs && ls && hs != ls) { return divergent<SymbolicExpr>(); }
    if (hs || ls) { return *SymbolicExpr::infinity(hs ? hs : ls); }
    return *detail::make_expression_ptr(detail::normalize_node(detail::node(sym_sub(high.value(), low.value())), transform_budget));
} catch (const CasError& error) {
    return Result<SymbolicExpr>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<SymbolicExpr>::failure(CasErrc::ResourceLimit, "allocation failed", "evaluate_segment_endpoints");
} catch (const std::length_error& error) {
    return Result<SymbolicExpr>::failure(CasErrc::ResourceLimit, error.what(), "evaluate_segment_endpoints");
} catch (const std::exception& error) {
    return Result<SymbolicExpr>::failure(CasErrc::InternalInvariant, error.what(), "evaluate_segment_endpoints");
}

引用了 LMCAS::a, LMCAS::b, boundary_value_checked(), LMCAS::detail::context, divergent(), evaluate_segment_endpoints(), LMCAS::Result< T >::failure(), LMCAS::FromAbove, LMCAS::FromBelow, infinity_sign(), LMCAS::InternalInvariant, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), operation, LMCAS::detail::substitute_node() , 以及 LMCAS::sym_sub().

被这些函数引用 definite_segment_checked() , 以及 evaluate_segment_endpoints().

函数调用图:

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

exact_number()

std::optional< Rational > LMCAS::detail::definite::exact_number

(

const Node &

node

)

在文件 integration_definite_algebraic.cpp 第 13 行定义.

                                                     {
    const auto* number = dynamic_cast<const NumberNode*>(node.get());
    if (!number) return std::nullopt;
    return exact_number_as_rational(*number);
}

引用了 exact_number(), LMCAS::exact_number_as_rational() , 以及 LMCAS::detail::node().

被这些函数引用 absolute_argument(), boundary_checked(), exact_number(), infinity_sign() , 以及 rational_power_checked().

函数调用图:

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

gcd_checked()

Result< Poly > LMCAS::detail::definite::gcd_checked ( Poly a, Poly b, ComputationContext & context )

static

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

                                                                             {
    while (!b.is_zero()) {
        auto step = context.consume_steps(a.coeffs.size() * b.coeffs.size() + 1, operation);
        if (!step) return Result<Poly>::failure(step.error());
        auto remainder = a.div_mod(b).second;
        auto checked = polynomial_budget(remainder, context);
        if (!checked) return Result<Poly>::failure(checked.error());
        a = std::move(b);
        b = std::move(remainder);
    }
    return a.make_monic();
}

引用了 LMCAS::a, LMCAS::b, LMCAS::detail::context, LMCAS::Result< T >::failure(), gcd_checked(), operation , 以及 polynomial_budget().

被这些函数引用 gcd_checked(), polynomial_at_root_sign(), rational_divergence_checked() , 以及 roots_checked().

函数调用图:

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

include_divergence()

bool LMCAS::detail::definite::include_divergence ( int & divergence, int contribution )

static

在文件 integration_definite_algebraic.cpp 第 327 行定义.

                                                                  {
    if (divergence && divergence != contribution) { return false; }
    divergence = contribution;
    return true;
}

引用了 LMCAS::divergence() , 以及 include_divergence().

被这些函数引用 include_divergence(), rational_divergence_checked() , 以及 rational_pole_divergence().

函数调用图:

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

infinity_sign()

int LMCAS::detail::definite::infinity_sign

(

const Node &

node

)

在文件 integration_definite_algebraic.cpp 第 41 行定义.

                                    {
    if (const auto* f = dynamic_cast<const FunctionNode*>(node.get())) {
        if (f->type() == FunctionNode::FuncType::Infinity) return 1;
    }
    if (const auto* m = dynamic_cast<const MultiplyNode*>(node.get())) {
        int result = 1;
        bool infinity = false;
        for (const auto& factor : m->operands()) {
            if (infinity_sign(factor)) {
                if (infinity) return 0;
                infinity = true;
                result *= infinity_sign(factor);
            } else {
                auto value = exact_number(factor);
                if (!value || sign(*value) == 0) return 0;
                result *= sign(*value);
            }
        }
        return infinity ? result : 0;
    }
    return 0;
}

引用了 exact_number(), LMCAS::FunctionNode::Infinity, infinity_sign(), LMCAS::detail::node(), sign() , 以及 LMCAS::value.

被这些函数引用 LMCAS::anonymous_namespace{integration_definite.cpp}::accumulate_segments(), boundary_checked(), evaluate_segment_endpoints() , 以及 infinity_sign().

函数调用图:

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

is_undecided()

bool LMCAS::detail::definite::is_undecided ( const CasError & error )

inline

在文件 integration_definite_support.hpp 第 33 行定义.

                                                {
    return error.code == CasErrc::Inconclusive ||
        error.code == CasErrc::UnsupportedExpression;
}

引用了 LMCAS::CasError::code, LMCAS::Inconclusive, is_undecided() , 以及 LMCAS::UnsupportedExpression.

被这些函数引用 certify_continuity_checked(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_interval_checked(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_ordered_interval(), is_undecided() , 以及 prepare_segment_primitive().

函数调用图:

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

needs_segment_expression()

bool LMCAS::detail::definite::needs_segment_expression

(

const Node &

node

)

在文件 integration_definite_segments.cpp 第 207 行定义.

                                                {
    class Detector final : public detail::RecursiveSymbolicVisitor {
    public:
        bool found = false;
        void visit(const PiecewiseNode&) override { found = true; }
        void visit(const FunctionNode& function) override {
            if (absolute_argument(function)) found = true;
            else detail::RecursiveSymbolicVisitor::visit(function);
        }
        void visit(const PowerNode& power) override {
            if (absolute_argument(power)) found = true;
            else detail::RecursiveSymbolicVisitor::visit(power);
        }
    } detector;
    node->accept(detector);
    return detector.found;
}

引用了 absolute_argument(), LMCAS::function(), needs_segment_expression(), LMCAS::detail::node() , 以及 LMCAS::detail::RecursiveSymbolicVisitor::visit().

被这些函数引用 LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_ordered_interval(), needs_segment_expression() , 以及 segment_expression_checked().

函数调用图:

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

ordered_partition_roots()

Result< std::vector< Algebraic > > LMCAS::detail::definite::ordered_partition_roots ( std::vector< Algebraic > & roots, const Boundary & a, const Boundary & b, ComputationContext & context )

static

在文件 integration_definite_segments.cpp 第 329 行定义.

                                 {
    std::vector<Algebraic> ordered;
    for (auto& root : roots) {
        auto left = compare_boundaries(a, Boundary{0, root}, context);
        auto right = compare_boundaries(Boundary{0, root}, b, context);
        if (!left) { return Result<std::vector<Algebraic>>::failure(left.error()); }
        if (!right) { return Result<std::vector<Algebraic>>::failure(right.error()); }
        if (left.value() >= 0 || right.value() >= 0) { continue; }
        auto position = ordered.begin();
        bool duplicate = false;
        for (; position != ordered.end(); ++position) {
            auto comparison = compare_boundaries(Boundary{0, root}, Boundary{0, *position}, context);
            if (!comparison) { return Result<std::vector<Algebraic>>::failure(comparison.error()); }
            if (comparison.value() == 0) { duplicate = true; break; }
            if (comparison.value() < 0) { break; }
        }
        if (!duplicate) { ordered.insert(position, std::move(root)); }
    }
    return ordered;
}

引用了 LMCAS::a, LMCAS::b, compare_boundaries(), LMCAS::detail::context, ordered_partition_roots(), LMCAS::right , 以及 LMCAS::roots().

被这些函数引用 definite_partition_checked() , 以及 ordered_partition_roots().

函数调用图:

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

original_conditions_checked()

Result< void > LMCAS::detail::definite::original_conditions_checked ( const Node & node, const FactsQuery & facts, std::vector< std::shared_ptr< SymbolicExpr > > & conditions, ComputationContext & context )

static

在文件 integration_definite_segments.cpp 第 259 行定义.

                                                                                     {
    auto step = context.consume_steps(1, operation);
    if (!step) return step;
    if (const auto* piecewise = dynamic_cast<const PiecewiseNode*>(node.get())) {
        for (const auto& branch : piecewise->branches()) {
            conditions.push_back(detail::make_expression_ptr(branch.condition));
            auto child = original_conditions_checked(branch.expression, facts, conditions, context);
            if (!child) return child;
        }
        if (piecewise->default_expr())
            return original_conditions_checked(piecewise->default_expr(), facts, conditions, context);
        return Result<void>::success();
    }
    auto domain = detail::domain_constraints(node, facts, Domain::Real, context);
    if (!domain) return Result<void>::failure(domain.error());
    if (!domain.value()) return undecided<void>();
    conditions.insert(conditions.end(), domain.value()->begin(), domain.value()->end());
    class AbsoluteBoundaries final : public detail::RecursiveSymbolicVisitor {
    public:
        AbsoluteBoundaries(std::vector<std::shared_ptr<SymbolicExpr>>& out, const FactsQuery& facts,
                           ComputationContext& context)
            : out_(out), facts_(facts), context_(context) {}
        std::optional<CasError> error;
        void visit(const FunctionNode& function) override {
            collect(function);
            detail::RecursiveSymbolicVisitor::visit(function);
        }
        void visit(const PowerNode& power) override {
            collect(power);
            detail::RecursiveSymbolicVisitor::visit(power);
        }
    private:
        void collect(const SymbolicNode& node) {
            if (auto argument = absolute_argument(node)) {
                auto nonnegative = detail::query_nonnegative_value(argument, facts_, context_);
                if (!nonnegative) { error = nonnegative.error(); return; }
                auto nonzero = detail::query_nonzero_value(argument, facts_, Domain::Real, context_);
                if (!nonzero) { error = nonzero.error(); return; }
                if (nonnegative.value() == Tribool::Unknown && nonzero.value() == Tribool::Unknown)
                    out_.push_back(detail::make_expression_ptr(detail::make_node<RelationalNode>(
                        argument, detail::node(SymbolicExpr::number(0)), RelationOp::EQ)));
            }
        }
        std::vector<std::shared_ptr<SymbolicExpr>>& out_;
        const FactsQuery& facts_;
        ComputationContext& context_;
    } boundaries(conditions, facts, context);
    node->accept(boundaries);
    if (boundaries.error) return Result<void>::failure(*boundaries.error);
    return Result<void>::success();
}

引用了 absolute_argument(), LMCAS::detail::context, LMCAS::detail::domain, LMCAS::detail::domain_constraints(), LMCAS::EQ, LMCAS::detail::facts, LMCAS::Result< T >::failure(), LMCAS::function(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), operation, original_conditions_checked(), LMCAS::detail::query_nonnegative_value(), LMCAS::detail::query_nonzero_value(), LMCAS::Real, LMCAS::Result< T >::success(), undecided(), LMCAS::Unknown , 以及 LMCAS::detail::RecursiveSymbolicVisitor::visit().

被这些函数引用 definite_partition_checked() , 以及 original_conditions_checked().

函数调用图:

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

polynomial_at_root_sign()

Result< int > LMCAS::detail::definite::polynomial_at_root_sign ( Poly polynomial, Algebraic root, ComputationContext & context )

static

在文件 integration_definite_algebraic.cpp 第 307 行定义.

                                 {
    if (polynomial.is_zero()) { return 0; }
    if (root.is_rational()) { return sign(polynomial.eval(root.lower)); }
    auto common = gcd_checked(polynomial, root.polynomial, context);
    if (!common) { return Result<int>::failure(common.error()); }
    if (common.value().degree() > 0) {
        auto zeros = detail::count_real_roots_exact(common.value(), root.lower, root.upper, context, operation);
        if (!zeros) { return Result<int>::failure(zeros.error()); }
        if (zeros.value()) { return 0; }
    }
    for (;;) {
        auto zeros = detail::count_real_roots_exact(polynomial, root.lower, root.upper, context, operation);
        if (!zeros) { return Result<int>::failure(zeros.error()); }
        if (!zeros.value()) { return sign(polynomial.eval(root.lower)); }
        auto refined = detail::refine_exact_real_algebraic(root, context, operation);
        if (!refined) { return Result<int>::failure(refined.error()); }
    }
}

引用了 LMCAS::detail::context, LMCAS::detail::count_real_roots_exact(), LMCAS::Polynomial< CoeffType >::eval(), LMCAS::Result< T >::failure(), gcd_checked(), LMCAS::detail::ExactRealAlgebraic::is_rational(), LMCAS::Polynomial< CoeffType >::is_zero(), LMCAS::detail::ExactRealAlgebraic::lower, operation, LMCAS::detail::ExactRealAlgebraic::polynomial, polynomial_at_root_sign(), LMCAS::detail::refine_exact_real_algebraic(), sign() , 以及 LMCAS::detail::ExactRealAlgebraic::upper.

被这些函数引用 polynomial_at_root_sign() , 以及 rational_pole_divergence().

函数调用图:

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

polynomial_budget()

Result< void > LMCAS::detail::definite::polynomial_budget ( const Poly & polynomial, ComputationContext & context )

static

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

                                                                                           {
    auto terms = context.require_expansion_terms(polynomial.coeffs.size(), operation);
    if (!terms) return terms;
    for (const auto& coefficient : polynomial.coeffs) {
        auto checked = context.require_integer_bits(std::max(
            coefficient.get_numerator().bit_length(),
            coefficient.get_denominator().bit_length()), operation);
        if (!checked) return checked;
    }
    return context.consume_steps(polynomial.coeffs.size() + 1, operation);
}

引用了 LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::detail::context, operation , 以及 polynomial_budget().

被这些函数引用 gcd_checked(), polynomial_budget() , 以及 product_checked().

函数调用图:

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

polynomial_sign_checked()

Result< std::optional< int > > LMCAS::detail::definite::polynomial_sign_checked	(	const Poly &	polynomial,
		const Boundary &	a,
		const Boundary &	b,
		ComputationContext &	context )

在文件 integration_definite_algebraic.cpp 第 279 行定义.

                                                                       {
    if (polynomial.is_zero()) return std::optional<int>{0};
    if (polynomial.degree() == 0) return std::optional<int>{sign(polynomial.lead_coeff())};
    auto roots = roots_checked(polynomial, context);
    if (!roots) return Result<std::optional<int>>::failure(roots.error());
    for (const auto& root : roots.value()) {
        auto left = compare_boundaries(a, Boundary{0, root}, context);
        auto right = compare_boundaries(Boundary{0, root}, b, context);
        if (!left) return Result<std::optional<int>>::failure(left.error());
        if (!right) return Result<std::optional<int>>::failure(right.error());
        if (left.value() < 0 && right.value() < 0) return std::optional<int>{};
    }
    if (a.infinity < 0)
        return std::optional<int>{sign(polynomial.lead_coeff()) *
            (polynomial.degree() % 2 ? -1 : 1)};
    if (b.infinity > 0) return std::optional<int>{sign(polynomial.lead_coeff())};
    auto left = a.finite;
    auto right = b.finite;
    while (!(left.upper < right.lower)) {
        auto l = detail::refine_exact_real_algebraic(left, context, operation);
        if (!l) return Result<std::optional<int>>::failure(l.error());
        auto r = detail::refine_exact_real_algebraic(right, context, operation);
        if (!r) return Result<std::optional<int>>::failure(r.error());
    }
    return std::optional<int>{sign(polynomial.eval((left.upper + right.lower) / Rational(2)))};
}

引用了 LMCAS::a, LMCAS::b, compare_boundaries(), LMCAS::detail::context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Result< T >::error(), LMCAS::Polynomial< CoeffType >::eval(), LMCAS::Polynomial< CoeffType >::is_zero(), LMCAS::Polynomial< CoeffType >::lead_coeff(), operation, polynomial_sign_checked(), LMCAS::r, LMCAS::detail::refine_exact_real_algebraic(), LMCAS::right, LMCAS::roots(), roots_checked(), sign() , 以及 LMCAS::Result< T >::value().

被这些函数引用 polynomial_sign_checked() , 以及 LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::value_sign_impl().

函数调用图:

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

prepare_segment_primitive()

Result< void > LMCAS::detail::definite::prepare_segment_primitive ( SymbolicExpr & candidate, const std::string & var, const SymbolicExpr & lower, const SymbolicExpr & upper, ComputationContext & context )

static

在文件 integration_definite_segments.cpp 第 531 行定义.

                                     {
    auto a = boundary_checked(lower, context);
    auto b = boundary_checked(upper, context);
    if (!a && !is_undecided(a.error())) {
        return Result<void>::failure(a.error());
    }
    if (!b && !is_undecided(b.error())) {
        return Result<void>::failure(b.error());
    }
    if (a && b) {
        auto assumptions = real_assumptions(var, context);
        if (!assumptions) { return Result<void>::failure(assumptions.error()); }
        SegmentFacts facts(assumptions.value(), var, a.value(), b.value());
        RealPrimitiveCandidate rewrite(facts, context);
        candidate = detail::expression_from_node(rewrite.rewrite(detail::node(candidate)));
        if (rewrite.error) { return Result<void>::failure(*rewrite.error); }
    }
    auto continuous = certify_continuity_checked(candidate, var, lower, upper, context);
    if (!continuous) { return Result<void>::failure(continuous.error()); }
    if (continuous.value() != Tribool::True) { return undecided<void>(); }
    return Result<void>::success();
} catch (const CasError& error) {
    return Result<void>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<void>::failure(CasErrc::ResourceLimit, "allocation failed", "prepare_segment_primitive");
} catch (const std::length_error& error) {
    return Result<void>::failure(CasErrc::ResourceLimit, error.what(), "prepare_segment_primitive");
} catch (const std::exception& error) {
    return Result<void>::failure(CasErrc::InternalInvariant, error.what(), "prepare_segment_primitive");
}

引用了 LMCAS::a, LMCAS::b, boundary_checked(), certify_continuity_checked(), LMCAS::detail::context, LMCAS::Result< T >::error(), LMCAS::detail::expression_from_node(), LMCAS::detail::facts, LMCAS::Result< T >::failure(), is_undecided(), LMCAS::lower, LMCAS::detail::node(), prepare_segment_primitive(), real_assumptions(), LMCAS::Result< T >::success(), LMCAS::True, undecided(), LMCAS::upper , 以及 LMCAS::Result< T >::value().

被这些函数引用 definite_segment_checked() , 以及 prepare_segment_primitive().

函数调用图:

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

product_checked()

Result< Poly > LMCAS::detail::definite::product_checked	(	const Poly &	a,
		const Poly &	b,
		ComputationContext &	context )

在文件 integration_definite_algebraic.cpp 第 115 行定义.

                                                                                        {
    const auto size = a.coeffs.size() + b.coeffs.size();
    auto budget = context.require_expansion_terms(size, operation);
    if (!budget) return Result<Poly>::failure(budget.error());
    if (size > static_cast<std::size_t>(std::numeric_limits<int>::max()))
        return Result<Poly>::failure(CasErrc::ResourceLimit,
            "polynomial degree exceeds representation", operation);
    auto step = context.consume_steps(a.coeffs.size() * b.coeffs.size() + 1, operation);
    if (!step) return Result<Poly>::failure(step.error());
    auto value = a * b;
    budget = polynomial_budget(value, context);
    if (!budget) return Result<Poly>::failure(budget.error());
    return value;
}

引用了 LMCAS::a, LMCAS::b, LMCAS::detail::budget, LMCAS::detail::context, LMCAS::Result< T >::failure(), operation, polynomial_budget(), product_checked(), LMCAS::ResourceLimit , 以及 LMCAS::value.

被这些函数引用 product_checked(), rational_operands_checked() , 以及 rational_power_checked().

函数调用图:

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

rational_checked()

RationalResult LMCAS::detail::definite::rational_checked	(	const Node &	node,
		const std::string &	var,
		ComputationContext &	context )

在文件 integration_definite_algebraic.cpp 第 194 行定义.

                                 {
    auto entered = context.enter_recursion(operation);
    if (!entered) { return RationalResult::failure(entered.error()); }
    struct Leave { ComputationContext& context; ~Leave() { context.leave_recursion(); } } leave{context};
    auto polynomial = recognize_rational_polynomial(detail::expression_from_node(node), var, context);
    if (!polynomial) { return RationalResult::failure(polynomial.error()); }
    if (polynomial.value()) { return std::optional<RationalFunction>{
        RationalFunction{std::move(*polynomial.value()), Poly(Rational(1), var)}}; }
    const auto* sum = dynamic_cast<const AddNode*>(node.get());
    const auto* product = dynamic_cast<const MultiplyNode*>(node.get());
    if (sum || product) {
        return rational_operands_checked(
            sum ? sum->operands() : product->operands(), sum != nullptr, var, context);
    }
    if (const auto* power = dynamic_cast<const PowerNode*>(node.get())) {
        return rational_power_checked(*power, var, context);
    }
    return std::optional<RationalFunction>{};
}

引用了 LMCAS::detail::context, LMCAS::detail::expression_from_node(), LMCAS::Result< std::optional< RationalFunction > >::failure(), LMCAS::detail::node(), operation, rational_checked(), rational_operands_checked(), rational_power_checked() , 以及 LMCAS::recognize_rational_polynomial().

被这些函数引用 collect_predicate_roots(), rational_checked(), rational_operands_checked(), rational_power_checked(), LMCAS::anonymous_namespace{integration_definite.cpp}::reduced_integrand_checked() , 以及 LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::value_sign_impl().

函数调用图:

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

rational_divergence_checked()

Result< int > LMCAS::detail::definite::rational_divergence_checked	(	RationalFunction &	rational,
		const Boundary &	a,
		const Boundary &	b,
		ComputationContext &	context )

在文件 integration_definite_algebraic.cpp 第 362 行定义.

                                                                       {
    if (rational.denominator.is_zero()) { return divergent<int>(); }
    auto gcd = gcd_checked(rational.numerator, rational.denominator, context);
    if (!gcd) { return Result<int>::failure(gcd.error()); }
    rational.numerator = rational.numerator.div_mod(gcd.value()).first;
    rational.denominator = rational.denominator.div_mod(gcd.value()).first;
    if (rational.numerator.is_zero()) { return 0; }
    auto roots = roots_checked(rational.denominator, context);
    if (!roots) { return Result<int>::failure(roots.error()); }
    int divergence = 0;
    for (const auto& root : roots.value()) {
        auto pole = rational_pole_divergence(rational, root, a, b, divergence, context);
        if (!pole) { return Result<int>::failure(pole.error()); }
    }
    const int degree = rational.numerator.degree() - rational.denominator.degree();
    if (degree >= -1) {
        int coefficient = sign(rational.numerator.lead_coeff()) * sign(rational.denominator.lead_coeff());
        if (a.infinity < 0 && !include_divergence(divergence, coefficient * (degree % 2 ? -1 : 1))) { return divergent<int>(); }
        if (b.infinity > 0 && !include_divergence(divergence, coefficient)) { return divergent<int>(); }
    }
    return divergence;
}

引用了 LMCAS::a, LMCAS::b, LMCAS::detail::context, LMCAS::divergence(), divergent(), LMCAS::Result< T >::error(), LMCAS::Result< T >::failure(), gcd_checked(), include_divergence(), LMCAS::rational(), rational_divergence_checked(), rational_pole_divergence(), LMCAS::roots(), roots_checked(), sign() , 以及 LMCAS::Result< T >::value().

被这些函数引用 rational_divergence_checked() , 以及 LMCAS::anonymous_namespace{integration_definite.cpp}::reduced_integrand_checked().

函数调用图:

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

rational_operands_checked()

RationalResult LMCAS::detail::definite::rational_operands_checked ( const std::vector< Node > & operands, bool sum, const std::string & var, ComputationContext & context )

static

在文件 integration_definite_algebraic.cpp 第 143 行定义.

                                                                 {
    RationalFunction result{Poly(Rational(sum ? 0 : 1), var), Poly(Rational(1), var)};
    for (const auto& operand : operands) {
        auto child = rational_checked(operand, var, context);
        if (!child || !child.value()) { return child; }
        auto n = product_checked(result.numerator,
            sum ? child.value()->denominator : child.value()->numerator, context);
        if (!n) { return RationalResult::failure(n.error()); }
        if (sum) {
            auto other = product_checked(child.value()->numerator, result.denominator, context);
            if (!other) { return RationalResult::failure(other.error()); }
            n.value() = n.value() + other.value();
        }
        auto d = product_checked(result.denominator, child.value()->denominator, context);
        if (!d) { return RationalResult::failure(d.error()); }
        result = {std::move(n.value()), std::move(d.value())};
    }
    return std::optional<RationalFunction>{std::move(result)};
}

引用了 LMCAS::detail::context, LMCAS::detail::definite::RationalFunction::denominator, LMCAS::Result< std::optional< RationalFunction > >::failure(), LMCAS::detail::definite::RationalFunction::numerator, product_checked(), rational_checked() , 以及 rational_operands_checked().

被这些函数引用 rational_checked() , 以及 rational_operands_checked().

函数调用图:

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

rational_pole_divergence()

Result< void > LMCAS::detail::definite::rational_pole_divergence ( const RationalFunction & rational, const Algebraic & root, const Boundary & a, const Boundary & b, int & divergence, ComputationContext & context )

static

在文件 integration_definite_algebraic.cpp 第 333 行定义.

                                                  {
    auto left = compare_boundaries(a, Boundary{0, root}, context);
    auto right = compare_boundaries(Boundary{0, root}, b, context);
    if (!left) { return Result<void>::failure(left.error()); }
    if (!right) { return Result<void>::failure(right.error()); }
    if (left.value() > 0 || right.value() > 0) { return Result<void>::success(); }
    Poly derivative = rational.denominator;
    std::size_t multiplicity = 0;
    int denominator_sign = 0;
    do {
        derivative = derivative.differentiate();
        ++multiplicity;
        auto value = polynomial_at_root_sign(derivative, root, context);
        if (!value) { return Result<void>::failure(value.error()); }
        denominator_sign = value.value();
    } while (!denominator_sign);
    auto numerator_sign = polynomial_at_root_sign(rational.numerator, root, context);
    if (!numerator_sign) { return Result<void>::failure(numerator_sign.error()); }
    int coefficient_sign = numerator_sign.value() * denominator_sign;
    if (!coefficient_sign) { return Result<void>::failure(CasErrc::InternalInvariant,
        "reduced rational pole has a zero numerator", operation); }
    if (left.value() < 0 && !include_divergence(divergence, coefficient_sign * (multiplicity % 2 ? -1 : 1)))
        { return divergent<void>(); }
    if (right.value() < 0 && !include_divergence(divergence, coefficient_sign)) { return divergent<void>(); }
    return Result<void>::success();
}

引用了 LMCAS::a, LMCAS::b, compare_boundaries(), LMCAS::detail::context, LMCAS::Polynomial< CoeffType >::differentiate(), LMCAS::divergence(), divergent(), LMCAS::Result< T >::failure(), include_divergence(), LMCAS::InternalInvariant, LMCAS::detail::multiplicity, operation, polynomial_at_root_sign(), LMCAS::rational(), rational_pole_divergence(), LMCAS::right, LMCAS::Result< T >::success() , 以及 LMCAS::value.

被这些函数引用 rational_divergence_checked() , 以及 rational_pole_divergence().

函数调用图:

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

rational_power_checked()

RationalResult LMCAS::detail::definite::rational_power_checked ( const PowerNode & power, const std::string & var, ComputationContext & context )

static

在文件 integration_definite_algebraic.cpp 第 164 行定义.

                                                       {
    auto exponent = exact_number(power.exponent());
    if (!exponent || !exponent->is_integer()) { return std::optional<RationalFunction>{}; }
    auto base = rational_checked(power.base(), var, context);
    if (!base || !base.value()) { return base; }
    BigInt count = exponent->to_bigint();
    if (count < BigInt(0)) {
        std::swap(base.value()->numerator, base.value()->denominator);
        count = -count;
    }
    RationalFunction result{Poly(Rational(1), var), Poly(Rational(1), var)};
    while (count != BigInt(0)) {
        if (count % BigInt(2) != BigInt(0)) {
            auto n = product_checked(result.numerator, base.value()->numerator, context);
            auto d = product_checked(result.denominator, base.value()->denominator, context);
            if (!n) { return RationalResult::failure(n.error()); }
            if (!d) { return RationalResult::failure(d.error()); }
            result = {std::move(n.value()), std::move(d.value())};
        }
        count = count / BigInt(2);
        if (count == BigInt(0)) { break; }
        auto n = product_checked(base.value()->numerator, base.value()->numerator, context);
        auto d = product_checked(base.value()->denominator, base.value()->denominator, context);
        if (!n) { return RationalResult::failure(n.error()); }
        if (!d) { return RationalResult::failure(d.error()); }
        base.value() = RationalFunction{std::move(n.value()), std::move(d.value())};
    }
    return std::optional<RationalFunction>{std::move(result)};
}

引用了 LMCAS::PowerNode::base(), LMCAS::detail::context, LMCAS::detail::definite::RationalFunction::denominator, exact_number(), LMCAS::exponent, LMCAS::PowerNode::exponent(), LMCAS::Result< std::optional< RationalFunction > >::failure(), LMCAS::detail::definite::RationalFunction::numerator, product_checked(), rational_checked() , 以及 rational_power_checked().

被这些函数引用 rational_checked() , 以及 rational_power_checked().

函数调用图:

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

real_assumptions()

Result< AssumptionContext > LMCAS::detail::definite::real_assumptions	(	const std::string &	var,
		ComputationContext &	context )

在文件 integration_definite_segments.cpp 第 251 行定义.

                                                                                              {
    AssumptionContext assumptions = context.assumptions() ? *context.assumptions() : AssumptionContext{};
    assumptions.push();
    auto real = assumptions.assume_domain_checked(var, Domain::Real);
    if (!real) return Result<AssumptionContext>::failure(real.error());
    return assumptions;
}

引用了 LMCAS::detail::context, LMCAS::Result< T >::error(), LMCAS::Result< T >::failure(), LMCAS::Real, LMCAS::real() , 以及 real_assumptions().

被这些函数引用 certify_continuity_checked(), definite_partition_checked(), LMCAS::anonymous_namespace{integration_definite.cpp}::equal_endpoint_integral(), prepare_segment_primitive(), real_assumptions() , 以及 segment_expression_checked().

函数调用图:

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

recover_rational_cut()

Result< void > LMCAS::detail::definite::recover_rational_cut ( Algebraic & root, const BigInt & denominator_bound, ComputationContext & context )

static

有理根定理给出分母 q 的上界；当前包围宽度保证根 p/q 位于中点连分数的渐近分数中。 通过连分数恢复有理分割点，免去整数因子枚举。

在文件 integration_definite_algebraic.cpp 第 215 行定义.

                                 {
    if (root.is_rational()) { return Result<void>::success(); }
    auto bits = context.require_integer_bits(2 * denominator_bound.bit_length() + 2, operation);
    if (!bits) { return bits; }
    const Rational separation(BigInt(1), BigInt(2) * denominator_bound * denominator_bound);
    while (root.upper - root.lower >= separation) {
        auto refined = detail::refine_exact_real_algebraic(root, context, operation);
        if (!refined) { return refined; }
        if (root.is_rational()) { return Result<void>::success(); }
    }
    /**
     * @brief 有理根定理给出分母 q 的上界；当前包围宽度保证根 p/q 位于中点连分数的渐近分数中。
     * 通过连分数恢复有理分割点，免去整数因子枚举。
     */
    const Rational midpoint = (root.lower + root.upper) / Rational(2);
    BigInt numerator = midpoint.get_numerator(), denominator = midpoint.get_denominator();
    BigInt old_p(0), p(1), old_q(1), q(0);
    while (denominator != BigInt(0)) {
        auto step = context.consume_steps(1, operation);
        if (!step) { return step; }
        BigInt quotient = numerator / denominator;
        BigInt remainder = numerator % denominator;
        if (remainder < BigInt(0)) { quotient = quotient - BigInt(1); remainder = remainder + denominator; }
        BigInt next_p = quotient * p + old_p;
        BigInt next_q = quotient * q + old_q;
        if (next_q > denominator_bound) { break; }
        Rational candidate(next_p, next_q);
        if (candidate >= root.lower && candidate <= root.upper &&
            root.polynomial.eval(candidate) == Rational(0)) {
            root.lower = root.upper = candidate;
            break;
        }
        old_p = std::move(p); p = std::move(next_p);
        old_q = std::move(q); q = std::move(next_q);
        numerator = std::move(denominator); denominator = std::move(remainder);
    }
    return Result<void>::success();
}

引用了 LMCAS::detail::context, LMCAS::denominator, LMCAS::Polynomial< CoeffType >::eval(), LMCAS::detail::ExactRealAlgebraic::is_rational(), LMCAS::detail::ExactRealAlgebraic::lower, operation, LMCAS::detail::ExactRealAlgebraic::polynomial, recover_rational_cut(), LMCAS::detail::refine_exact_real_algebraic(), LMCAS::Result< T >::success() , 以及 LMCAS::detail::ExactRealAlgebraic::upper.

被这些函数引用 recover_rational_cut() , 以及 roots_checked().

函数调用图:

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

roots_checked()

Result< std::vector< Algebraic > > LMCAS::detail::definite::roots_checked	(	const Poly &	polynomial,
		ComputationContext &	context )

在文件 integration_definite_algebraic.cpp 第 255 行定义.

                                                                                                {
    if (polynomial.degree() <= 0) return std::vector<Algebraic>{};
    auto repeated = gcd_checked(polynomial, polynomial.differentiate(), context);
    if (!repeated) return Result<std::vector<Algebraic>>::failure(repeated.error());
    auto square_free = polynomial.div_mod(repeated.value()).first.make_monic();
    BigInt denominator_bound(1);
    for (const auto& coefficient : square_free.coeffs) {
        const auto& denominator = coefficient.get_denominator();
        denominator_bound = denominator_bound / BigInt::gcd(denominator_bound, denominator) * denominator;
        auto checked = context.require_integer_bits(denominator_bound.bit_length(), operation);
        if (!checked) return Result<std::vector<Algebraic>>::failure(checked.error());
    }
    auto isolated = detail::isolate_real_roots_exact(square_free, context, operation);
    if (!isolated) return Result<std::vector<Algebraic>>::failure(isolated.error());
    std::vector<Algebraic> roots;
    for (std::size_t i = 0; i < isolated.value().size(); ++i) {
        Algebraic root{square_free, isolated.value()[i].first, isolated.value()[i].second, i, 1};
        auto recovered = recover_rational_cut(root, denominator_bound, context);
        if (!recovered) return Result<std::vector<Algebraic>>::failure(recovered.error());
        roots.push_back(std::move(root));
    }
    return roots;
}

引用了 LMCAS::detail::context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::denominator, LMCAS::Polynomial< CoeffType >::differentiate(), LMCAS::Polynomial< CoeffType >::div_mod(), gcd_checked(), LMCAS::detail::isolate_real_roots_exact(), operation, recover_rational_cut(), LMCAS::roots() , 以及 roots_checked().

被这些函数引用 collect_predicate_roots(), polynomial_sign_checked(), rational_divergence_checked() , 以及 roots_checked().

函数调用图:

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

segment_expression_checked()

Result< SymbolicExpr > LMCAS::detail::definite::segment_expression_checked	(	const SymbolicExpr &	expression,
		const std::string &	var,
		const SymbolicExpr &	lower,
		const SymbolicExpr &	upper,
		ComputationContext &	context )

在文件 integration_definite_segments.cpp 第 312 行定义.

                                 {
    if (!needs_segment_expression(detail::node(expression))) return expression;
    auto a = boundary_checked(lower, context);
    auto b = boundary_checked(upper, context);
    if (!a) return Result<SymbolicExpr>::failure(a.error());
    if (!b) return Result<SymbolicExpr>::failure(b.error());
    auto assumptions = real_assumptions(var, context);
    if (!assumptions) return Result<SymbolicExpr>::failure(assumptions.error());
    SegmentFacts facts(assumptions.value(), var, a.value(), b.value());
    SegmentExpression rewrite(facts, context);
    auto selected = rewrite.rewrite(detail::node(expression));
    if (rewrite.error) return Result<SymbolicExpr>::failure(*rewrite.error);
    return detail::expression_from_node(selected);
}

引用了 LMCAS::a, LMCAS::b, boundary_checked(), LMCAS::detail::context, LMCAS::Result< T >::error(), LMCAS::detail::expression_from_node(), LMCAS::detail::facts, LMCAS::Result< T >::failure(), LMCAS::lower, needs_segment_expression(), LMCAS::detail::node(), real_assumptions(), segment_expression_checked(), LMCAS::upper , 以及 LMCAS::Result< T >::value().

被这些函数引用 certify_continuity_checked(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_segment_primitive() , 以及 segment_expression_checked().

函数调用图:

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

sign()

int LMCAS::detail::definite::sign ( const Rational & value )

static

在文件 integration_definite_algebraic.cpp 第 9 行定义.

                                       {
    return value < Rational(0) ? -1 : value > Rational(0) ? 1 : 0;
}

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

被这些函数引用 infinity_sign(), polynomial_at_root_sign(), polynomial_sign_checked(), rational_divergence_checked() , 以及 sign().

函数调用图:

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

structurally_continuous()

Result< Tribool > LMCAS::detail::definite::structurally_continuous ( const Node & node, const FactsQuery & facts, ComputationContext & context )

static

在文件 integration_definite_segments.cpp 第 437 行定义.

                                 {
    auto step = context.consume_steps(1, operation);
    if (!step) { return Result<Tribool>::failure(step.error()); }
    auto defined = defined_on_interval(node, facts, context);
    if (!defined || defined.value() != Tribool::True) { return defined; }
    if (dynamic_cast<const NumberNode*>(node.get()) || dynamic_cast<const VariableNode*>(node.get()) ||
        dynamic_cast<const RootOfNode*>(node.get())) { return Tribool::True; }
    const auto* sum = dynamic_cast<const AddNode*>(node.get());
    const auto* product = dynamic_cast<const MultiplyNode*>(node.get());
    const auto* function = dynamic_cast<const FunctionNode*>(node.get());
    const auto* power = dynamic_cast<const PowerNode*>(node.get());
    if (power) {
        auto base = structurally_continuous(power->base(), facts, context);
        if (!base || base.value() != Tribool::True) { return base; }
        return structurally_continuous(power->exponent(), facts, context);
    }
    if (sum) { return continuous_children(sum->operands(), facts, context); }
    if (product) { return continuous_children(product->operands(), facts, context); }
    if (function) {
        if (!continuous_function_family(function->type())) { return Tribool::Unknown; }
        return continuous_children(function->arguments(), facts, context);
    }
    return Tribool::Unknown;
}

引用了 LMCAS::detail::context, continuous_children(), continuous_function_family(), defined_on_interval(), LMCAS::detail::facts, LMCAS::Result< T >::failure(), LMCAS::function(), LMCAS::detail::node(), operation, structurally_continuous(), LMCAS::True , 以及 LMCAS::Unknown.

被这些函数引用 certify_continuity_checked(), continuous_children() , 以及 structurally_continuous().

函数调用图:

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

undecided()

template<class T>

Result< T > LMCAS::detail::definite::undecided

(

)

在文件 integration_definite_support.hpp 第 21 行定义.

                      {
    return Result<T>::failure(CasErrc::Inconclusive,
        "interval certificate is unavailable", operation);
}

引用了 LMCAS::Result< T >::failure(), LMCAS::Inconclusive, operation , 以及 undecided().

被这些函数引用 boundary_checked(), collect_predicate_roots(), definite_segment_checked(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_segment_primitive(), original_conditions_checked(), prepare_segment_primitive() , 以及 undecided().

函数调用图:

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

变量说明

operation

const char* LMCAS::detail::definite::operation = "integrate.definite"

inlineconstexpr

在文件 integration_definite_support.hpp 第 10 行定义.

被这些函数引用 boundary_checked(), collect_predicate_roots(), compare_boundaries(), evaluate_segment_endpoints(), gcd_checked(), original_conditions_checked(), polynomial_at_root_sign(), polynomial_budget(), polynomial_sign_checked(), product_checked(), rational_checked(), rational_pole_divergence(), recover_rational_cut(), roots_checked(), structurally_continuous(), undecided() , 以及 LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentExpression::visit().