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

类
struct	ComplexContinuityPoint
class	ComplexPuncturedFacts
class	SideBranchRewriter

类型定义
using	NodePtr = std::shared_ptr<const SymbolicNode>

函数
LimitResult	assumption_limit_failure (const CasError &error)
LimitResult	classify_infinite_function (const FunctionNode &function, const std::string &variable, ComputationContext &context, const FactsQuery &facts, Domain domain)
LimitResult	classify_infinite_power (const PowerNode &power, const std::string &variable, ComputationContext &context, const FactsQuery &facts, Domain domain)
LimitResult	classify_infinite_product (const MultiplyNode &product, const std::string &variable, ComputationContext &context, const FactsQuery &facts, Domain domain)
LimitResult	classify_infinite_sum (const AddNode &sum, const std::string &variable, ComputationContext &context, const FactsQuery &facts, Domain domain)
LimitResult	classify_limit_result (const NodePtr &node, const std::string &variable, ComputationContext &context, const FactsQuery &facts, Domain domain=Domain::Real)
LimitResult	combine_one_sided_limits (const LimitOutcome &left, const LimitOutcome &right, ComputationContext &context)
Result< bool >	complex_polynomial_nonzero (const RelationalNode &relation, const std::string &variable, const FactsQuery &facts, ComputationContext &context, std::vector< NodePtr > &nonzero_bases)
Result< bool >	complex_punctured_condition (const NodePtr &condition, const std::string &variable, const FactsQuery &facts, ComputationContext &context, std::vector< NodePtr > &nonzero_bases)
Result< bool >	complex_punctured_domain (const NodePtr &node, const std::string &variable, const FactsQuery &facts, ComputationContext &context, std::vector< NodePtr > &nonzero_bases)
bool	continuous_function_branch (FunctionNode::FuncType type, const NodePtr &argument, const ComplexContinuityPoint *point)
bool	elementary_continuous_structure (const NodePtr &node, const ComplexContinuityPoint *complex_point=nullptr)
LimitResult	evaluate_one_sided_node (const NodePtr &node, const std::string &variable, const LimitExprPtr &point, LimitDirection direction, ComputationContext &context, const AssumptionContext &local, const FactsQuery &facts, LimitVisitor &visitor)
Result< int >	finite_sign (const NodePtr &node, const FactsQuery &facts, ComputationContext &context)
bool	has_infinity (const NodePtr &node)
int	infinity_sign (const LimitOutcome &value)
LimitResult	limit_at_checked_point (const LimitExprPtr &expression, const std::string &variable, const LimitExprPtr &point, LimitDirection direction, ComputationContext &context, const FactsQuery &facts, Domain domain)
LimitResult	limit_complex_at_point (const LimitExprPtr &expression, const std::string &variable, const LimitExprPtr &point, ComputationContext &context, const FactsQuery &facts)
LimitResult	limit_one_sided_checked (const LimitExprPtr &expression, const std::string &variable, const LimitExprPtr &point, LimitDirection direction, ComputationContext &context)
LimitResult	limit_real_at_point (const LimitExprPtr &expression, const std::string &variable, const LimitExprPtr &point, LimitDirection direction, int endpoint_sign, ComputationContext &context)
std::optional< LimitResult >	oscillatory_one_sided_limit (const NodePtr &node, const std::string &variable, const LimitExprPtr &point, LimitDirection direction, ComputationContext &context, const FactsQuery &facts, LimitVisitor &visitor)
LimitResult	outcome (LimitOutcome value)
bool	power_continuous_structure (const PowerNode &power, const ComplexContinuityPoint *point)
std::optional< LimitResult >	scaled_one_sided_limit (const MultiplyNode &product, const std::string &variable, const LimitExprPtr &point, LimitDirection direction, ComputationContext &context, const FactsQuery &facts)
LimitResult	unknown ()
Result< void >	validate_limit_input (const LimitExprPtr &expression, const std::string &variable, const LimitExprPtr &point, LimitDirection direction, Domain domain)

类型定义说明

NodePtr

using LMCAS::anonymous_namespace{limit_result.cpp}::NodePtr = std::shared_ptr<const SymbolicNode>

在文件 limit_result.cpp 第 19 行定义.

函数说明

assumption_limit_failure()

LimitResult LMCAS::anonymous_namespace{limit_result.cpp}::assumption_limit_failure

(

const CasError &

error

)

在文件 limit_result.cpp 第 27 行定义.

                                                            {
    return error.code == CasErrc::InvalidArgument ? unknown() : LimitResult::failure(error);
}

引用了 assumption_limit_failure(), LMCAS::CasError::code, LMCAS::Result< Verified< LimitOutcome > >::failure(), LMCAS::InvalidArgument , 以及 unknown().

被这些函数引用 assumption_limit_failure() , 以及 limit_one_sided_checked().

函数调用图:

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

classify_infinite_function()

LimitResult LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_function	(	const FunctionNode &	function,
		const std::string &	variable,
		ComputationContext &	context,
		const FactsQuery &	facts,
		Domain	domain )

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

                                                                         {
    if (function.arguments().size() != 1) { return unknown(); }
    auto argument = classify_limit_result(function.arguments()[0], variable, context, facts, domain);
    if (!argument) { return argument; }
    int sign = infinity_sign(argument.value().value);
    if (!sign) {
        auto applied = detail::make_node<FunctionNode>(function.type(), std::vector<NodePtr>{
            detail::node(std::get<FiniteLimit>(argument.value().value).value)});
        return classify_limit_result(applied, variable, context, facts, domain);
    }
    switch (function.type()) {
        case FunctionNode::FuncType::Exp: {
            return sign > 0 ? outcome(PositiveInfinityLimit{}) : outcome(FiniteLimit{SymbolicExpr::number(0)});
        }
        case FunctionNode::FuncType::Abs: { return outcome(PositiveInfinityLimit{}); }
        case FunctionNode::FuncType::Ln: case FunctionNode::FuncType::Sqrt: {
            return sign > 0 ? outcome(PositiveInfinityLimit{}) : unknown();
        }
        case FunctionNode::FuncType::ArcTan: {
            return outcome(FiniteLimit{SymbolicExpr::multiply(SymbolicExpr::number(Rational(sign,2)),
                LMCAS::detail::make_expression_ptr(
                    LMCAS::detail::make_node<VariableNode>("pi", true)))});
        }
        default: { return unknown(); }
    }
}

引用了 LMCAS::FunctionNode::Abs, LMCAS::FunctionNode::ArcTan, classify_infinite_function(), classify_limit_result(), LMCAS::context, LMCAS::domain, LMCAS::FunctionNode::Exp, LMCAS::function(), infinity_sign(), LMCAS::FunctionNode::Ln, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), outcome(), LMCAS::FunctionNode::Sqrt, unknown() , 以及 LMCAS::variable.

被这些函数引用 classify_infinite_function() , 以及 classify_limit_result().

函数调用图:

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

classify_infinite_power()

LimitResult LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_power	(	const PowerNode &	power,
		const std::string &	variable,
		ComputationContext &	context,
		const FactsQuery &	facts,
		Domain	domain )

在文件 limit_result.cpp 第 127 行定义.

                                                                         {
    auto base = classify_limit_result(power.base(), variable, context, facts, domain);
    if (!base) { return base; }
    const int sign = infinity_sign(base.value().value);
    BigInt integer;
    auto number = std::dynamic_pointer_cast<const NumberNode>(power.exponent());
    auto exponent = extract_coeff_value<Rational>(detail::make_expression_ptr(power.exponent()));
    bool integral = number && try_get_integer_value(number, integer);
    if (!sign || !exponent || (sign <= 0 && !integral)) { return unknown(); }
    if (exponent.value() < Rational(0)) { return outcome(FiniteLimit{SymbolicExpr::number(0)}); }
    if (exponent.value() > Rational(0)) { return sign < 0 && integer.is_odd()
        ? outcome(NegativeInfinityLimit{}) : outcome(PositiveInfinityLimit{}); }
    return unknown();
}

引用了 LMCAS::PowerNode::base(), classify_infinite_power(), classify_limit_result(), LMCAS::context, LMCAS::domain, LMCAS::exponent, LMCAS::PowerNode::exponent(), LMCAS::extract_coeff_value(), infinity_sign(), LMCAS::integer, LMCAS::detail::make_expression_ptr(), outcome(), LMCAS::try_get_integer_value(), unknown() , 以及 LMCAS::variable.

被这些函数引用 classify_infinite_power() , 以及 classify_limit_result().

函数调用图:

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

classify_infinite_product()

LimitResult LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_product	(	const MultiplyNode &	product,
		const std::string &	variable,
		ComputationContext &	context,
		const FactsQuery &	facts,
		Domain	domain )

在文件 limit_result.cpp 第 92 行定义.

                                                                             {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    int sign = 1;
    bool infinite = false;
    std::vector<NodePtr> finite_factors;
    for (const auto& factor : product.operands()) {
        auto value = classify_limit_result(factor, variable, context, facts, domain);
        if (!value) { return value; }
        int next = infinity_sign(value.value().value);
        if (next) { infinite = true; sign *= next; }
        else { finite_factors.push_back(detail::node(std::get<FiniteLimit>(value.value().value).value)); }
    }
    if (infinite) {
        for (const auto& factor : finite_factors) {
            auto s = finite_sign(factor, facts, context);
            if (!s) { return LimitResult::failure(s.error()); }
            if (!s.value()) { return unknown(); }
            sign *= s.value();
        }
        return sign > 0 ? outcome(PositiveInfinityLimit{}) : outcome(NegativeInfinityLimit{});
    }
    auto finite = detail::make_expression_ptr(detail::normalize_node(detail::make_node<MultiplyNode>(std::move(finite_factors)), transform_budget));
    return finite ? classify_limit_result(detail::node(finite), variable, context, facts, domain) : unknown();
} catch (const CasError& error) {
    return LimitResult::failure(error);
} catch (const std::bad_alloc&) {
    return LimitResult::failure(CasErrc::ResourceLimit, "allocation failed", "classify_infinite_product");
} catch (const std::length_error& error) {
    return LimitResult::failure(CasErrc::ResourceLimit, error.what(), "classify_infinite_product");
} catch (const std::exception& error) {
    return LimitResult::failure(CasErrc::InternalInvariant, error.what(), "classify_infinite_product");
}

引用了 classify_infinite_product(), classify_limit_result(), LMCAS::context, LMCAS::domain, LMCAS::Result< Verified< LimitOutcome > >::failure(), finite_sign(), infinity_sign(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::MultiplyNode::operands(), outcome(), unknown(), LMCAS::value , 以及 LMCAS::variable.

被这些函数引用 classify_infinite_product() , 以及 classify_limit_result().

函数调用图:

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

classify_infinite_sum()

LimitResult LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_sum	(	const AddNode &	sum,
		const std::string &	variable,
		ComputationContext &	context,
		const FactsQuery &	facts,
		Domain	domain )

在文件 limit_result.cpp 第 65 行定义.

                                                                             {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    int sign = 0;
    std::vector<NodePtr> finite_terms;
    for (const auto& term : sum.operands()) {
        auto value = classify_limit_result(term, variable, context, facts, domain);
        if (!value) { return value; }
        int next = infinity_sign(value.value().value);
        if (sign && next && sign != next) { return unknown(); }
        if (next) { sign = next; }
        else { finite_terms.push_back(detail::node(std::get<FiniteLimit>(value.value().value).value)); }
    }
    if (sign) { return sign > 0 ? outcome(PositiveInfinityLimit{}) : outcome(NegativeInfinityLimit{}); }
    auto finite = detail::make_expression_ptr(detail::normalize_node(detail::make_node<AddNode>(std::move(finite_terms)), transform_budget));
    return finite ? classify_limit_result(detail::node(finite), variable, context, facts, domain) : unknown();
} catch (const CasError& error) {
    return LimitResult::failure(error);
} catch (const std::bad_alloc&) {
    return LimitResult::failure(CasErrc::ResourceLimit, "allocation failed", "classify_infinite_sum");
} catch (const std::length_error& error) {
    return LimitResult::failure(CasErrc::ResourceLimit, error.what(), "classify_infinite_sum");
} catch (const std::exception& error) {
    return LimitResult::failure(CasErrc::InternalInvariant, error.what(), "classify_infinite_sum");
}

引用了 classify_infinite_sum(), classify_limit_result(), LMCAS::context, LMCAS::domain, infinity_sign(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::AddNode::operands(), outcome(), unknown(), LMCAS::value , 以及 LMCAS::variable.

被这些函数引用 classify_infinite_sum() , 以及 classify_limit_result().

函数调用图:

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

classify_limit_result()

LimitResult LMCAS::anonymous_namespace{limit_result.cpp}::classify_limit_result	(	const NodePtr &	node,
		const std::string &	variable,
		ComputationContext &	context,
		const FactsQuery &	facts,
		Domain	domain = Domain::Real )

在文件 limit_result.cpp 第 171 行定义.

                                                                         {
    auto step = context.consume_steps(1, "limit.classify");
    if (!step) { return LimitResult::failure(step.error()); }
    if (!node || detail::contains_node_type<LimitNode>(node) || expression_depends_on_variable(node, variable))
        { return unknown(); }
    if (auto function = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        if (function->type() == FunctionNode::FuncType::Infinity) { return outcome(PositiveInfinityLimit{}); }
    }
    if (has_infinity(node)) {
        if (auto sum = std::dynamic_pointer_cast<const AddNode>(node)) {
            return classify_infinite_sum(*sum, variable, context, facts, domain);
        }
        if (auto product = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
            return classify_infinite_product(*product, variable, context, facts, domain);
        }
        if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
            return classify_infinite_power(*power, variable, context, facts, domain);
        }
        if (auto function = std::dynamic_pointer_cast<const FunctionNode>(node)) {
            return classify_infinite_function(*function, variable, context, facts, domain);
        }
        return unknown();
    }
    auto defined = detail::query_definedness(node, facts, domain, context);
    if (!defined) { return LimitResult::failure(defined.error()); }
    if (defined.value() != Tribool::True) { return unknown(); }
    return outcome(FiniteLimit{detail::make_expression_ptr(node)});
}

引用了 classify_infinite_function(), classify_infinite_power(), classify_infinite_product(), classify_infinite_sum(), classify_limit_result(), LMCAS::detail::contains_node_type(), LMCAS::context, LMCAS::domain, LMCAS::expression_depends_on_variable(), LMCAS::Result< Verified< LimitOutcome > >::failure(), LMCAS::function(), has_infinity(), LMCAS::FunctionNode::Infinity, LMCAS::detail::make_expression_ptr(), outcome(), LMCAS::detail::query_definedness(), LMCAS::True, unknown() , 以及 LMCAS::variable.

被这些函数引用 classify_infinite_function(), classify_infinite_power(), classify_infinite_product(), classify_infinite_sum(), classify_limit_result(), evaluate_one_sided_node(), limit_at_checked_point() , 以及 limit_complex_at_point().

函数调用图:

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

combine_one_sided_limits()

LimitResult LMCAS::anonymous_namespace{limit_result.cpp}::combine_one_sided_limits	(	const LimitOutcome &	left,
		const LimitOutcome &	right,
		ComputationContext &	context )

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

                                 {
    if (std::holds_alternative<LimitDoesNotExist>(left) || std::holds_alternative<LimitDoesNotExist>(right))
        return outcome(LimitDoesNotExist{});
    int ls = infinity_sign(left), rs = infinity_sign(right);
    if (ls || rs) {
        if (ls == rs) return outcome(left);
        return outcome(LimitDoesNotExist{});
    }
    const auto& lv = std::get<FiniteLimit>(left).value;
    const auto& rv = std::get<FiniteLimit>(right).value;
    auto equal = detail::compare_pointwise_values(lv, rv, context, Domain::Real);
    if (!equal) return LimitResult::failure(equal.error());
    if (equal.value() == Tribool::True) return outcome(left);
    if (equal.value() == Tribool::False) return outcome(LimitDoesNotExist{});
    return unknown();
}

引用了 combine_one_sided_limits(), LMCAS::detail::compare_pointwise_values(), LMCAS::context, LMCAS::Result< Verified< LimitOutcome > >::failure(), LMCAS::False, infinity_sign(), outcome(), LMCAS::Real, LMCAS::right, LMCAS::True , 以及 unknown().

被这些函数引用 combine_one_sided_limits() , 以及 limit_real_at_point().

函数调用图:

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

complex_polynomial_nonzero()

Result< bool > LMCAS::anonymous_namespace{limit_result.cpp}::complex_polynomial_nonzero	(	const RelationalNode &	relation,
		const std::string &	variable,
		const FactsQuery &	facts,
		ComputationContext &	context,
		std::vector< NodePtr > &	nonzero_bases )

在文件 limit_result.cpp 第 469 行定义.

                                                                                                 {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto difference = SymbolicExpr::add(detail::make_expression_ptr(relation.left()),
        SymbolicExpr::multiply(SymbolicExpr::number(-1), detail::make_expression_ptr(relation.right())));
    auto polynomial = symbolic_to_poly<SymbolicPolyCoeff>(difference, variable);
    if (!polynomial) {
        if (polynomial.error().code == CasErrc::UnsupportedExpression) { return false; }
        return Result<bool>::failure(polynomial.error());
    }
    bool nonzero = false;
    for (const auto& coefficient : polynomial.value().coeffs) {
        auto step = context.consume_steps(1, "limit.complex_domain");
        if (!step) { return Result<bool>::failure(step.error()); }
        auto defined = detail::query_definedness(detail::node(coefficient.val), facts, Domain::Complex, context);
        if (!defined) { return Result<bool>::failure(defined.error()); }
        if (defined.value() != Tribool::True) { return false; }
        auto value = detail::query_nonzero_value(detail::node(coefficient.val), facts, Domain::Complex, context);
        if (!value) { return Result<bool>::failure(value.error()); }
        nonzero |= value.value() == Tribool::True;
    }
    if (!nonzero) { return false; }
    auto normalized = detail::make_expression_ptr(detail::normalize_node(detail::node(difference), transform_budget));
    if (!normalized) { return false; }
    nonzero_bases.push_back(detail::node(normalized));
    return true;
} catch (const CasError& error) {
    return Result<bool>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<bool>::failure(CasErrc::ResourceLimit, "allocation failed", "complex_polynomial_nonzero");
} catch (const std::length_error& error) {
    return Result<bool>::failure(CasErrc::ResourceLimit, error.what(), "complex_polynomial_nonzero");
} catch (const std::exception& error) {
    return Result<bool>::failure(CasErrc::InternalInvariant, error.what(), "complex_polynomial_nonzero");
}

引用了 LMCAS::Complex, complex_polynomial_nonzero(), LMCAS::context, LMCAS::Result< T >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::detail::query_definedness(), LMCAS::detail::query_nonzero_value(), LMCAS::relation(), LMCAS::True, LMCAS::UnsupportedExpression, LMCAS::value , 以及 LMCAS::variable.

被这些函数引用 complex_polynomial_nonzero() , 以及 complex_punctured_condition().

函数调用图:

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

complex_punctured_condition()

Result< bool > LMCAS::anonymous_namespace{limit_result.cpp}::complex_punctured_condition	(	const NodePtr &	condition,
		const std::string &	variable,
		const FactsQuery &	facts,
		ComputationContext &	context,
		std::vector< NodePtr > &	nonzero_bases )

在文件 limit_result.cpp 第 506 行定义.

                                                                                             {
    auto step = context.consume_steps(1, "limit.complex_condition");
    if (!step) { return Result<bool>::failure(step.error()); }
    auto logical = std::dynamic_pointer_cast<const LogicalNode>(condition);
    if (logical && logical->op() == LogicalNode::Op::Or) {
        auto left = complex_punctured_condition(logical->left(), variable, facts, context, nonzero_bases);
        if (!left || left.value()) { return left; }
        return complex_punctured_condition(logical->right(), variable, facts, context, nonzero_bases);
    }
    auto relation = std::dynamic_pointer_cast<const RelationalNode>(condition);
    if (!relation || relation->op() != RelationalNode::Op::NEQ) { return false; }
    return complex_polynomial_nonzero(*relation, variable, facts, context, nonzero_bases);
}

引用了 complex_polynomial_nonzero(), complex_punctured_condition(), LMCAS::context, LMCAS::Result< T >::failure(), LMCAS::LogicalNode::Or, LMCAS::relation() , 以及 LMCAS::variable.

被这些函数引用 complex_punctured_condition() , 以及 complex_punctured_domain().

函数调用图:

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

complex_punctured_domain()

Result< bool > LMCAS::anonymous_namespace{limit_result.cpp}::complex_punctured_domain	(	const NodePtr &	node,
		const std::string &	variable,
		const FactsQuery &	facts,
		ComputationContext &	context,
		std::vector< NodePtr > &	nonzero_bases )

在文件 limit_result.cpp 第 521 行定义.

                                                                                             {
    auto domain = detail::domain_constraints(node, facts, Domain::Complex, context);
    if (!domain) { return Result<bool>::failure(domain.error()); }
    if (!domain.value()) { return false; }
    for (const auto& condition : *domain.value()) {
        auto proven = complex_punctured_condition(detail::node(condition), variable, facts, context, nonzero_bases);
        if (!proven || !proven.value()) { return proven; }
    }
    return true;
}

引用了 LMCAS::Complex, complex_punctured_condition(), complex_punctured_domain(), LMCAS::context, LMCAS::domain, LMCAS::detail::domain_constraints(), LMCAS::Result< T >::failure(), LMCAS::detail::node() , 以及 LMCAS::variable.

被这些函数引用 complex_punctured_domain() , 以及 limit_complex_at_point().

函数调用图:

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

continuous_function_branch()

bool LMCAS::anonymous_namespace{limit_result.cpp}::continuous_function_branch	(	FunctionNode::FuncType	type,
		const NodePtr &	argument,
		const ComplexContinuityPoint *	point )

在文件 limit_result.cpp 第 229 行定义.

                                         {
    switch (type) {
        case FunctionNode::FuncType::Sin: { return true; }
        case FunctionNode::FuncType::Cos: { return true; }
        case FunctionNode::FuncType::Tan: { return true; }
        case FunctionNode::FuncType::Exp: { return true; }
        case FunctionNode::FuncType::Abs: { return true; }
        case FunctionNode::FuncType::Ln: { return !point || point->positive(argument); }
        case FunctionNode::FuncType::Sqrt: { return !point || point->positive(argument); }
        case FunctionNode::FuncType::ArcTan: { return point == nullptr; }
        case FunctionNode::FuncType::ArcSin: { return point == nullptr; }
        case FunctionNode::FuncType::ArcCos: { return point == nullptr; }
        default: { return false; }
    }
}

引用了 LMCAS::FunctionNode::Abs, LMCAS::FunctionNode::ArcCos, LMCAS::FunctionNode::ArcSin, LMCAS::FunctionNode::ArcTan, continuous_function_branch(), LMCAS::FunctionNode::Cos, LMCAS::FunctionNode::Exp, LMCAS::FunctionNode::Ln, LMCAS::point, LMCAS::FunctionNode::Sin, LMCAS::FunctionNode::Sqrt , 以及 LMCAS::FunctionNode::Tan.

被这些函数引用 continuous_function_branch() , 以及 elementary_continuous_structure().

函数调用图:

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

elementary_continuous_structure()

bool LMCAS::anonymous_namespace{limit_result.cpp}::elementary_continuous_structure	(	const NodePtr &	node,
		const ComplexContinuityPoint *	complex_point = nullptr )

在文件 limit_result.cpp 第 245 行定义.

                                                                                               {
    if (std::dynamic_pointer_cast<const NumberNode>(node) ||
        std::dynamic_pointer_cast<const VariableNode>(node)) { return true; }
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        return power_continuous_structure(*power, point);
    }
    if (auto complex = std::dynamic_pointer_cast<const ComplexNode>(node)) {
        return point && elementary_continuous_structure(complex->real(), point) &&
            elementary_continuous_structure(complex->imag(), point);
    }
    const std::vector<NodePtr>* operands = nullptr;
    if (auto sum = std::dynamic_pointer_cast<const AddNode>(node)) {
        operands = &sum->operands();
    } else if (auto product = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        operands = &product->operands();
    }
    if (operands) {
        for (const auto& operand : *operands) {
            if (!elementary_continuous_structure(operand, point)) { return false; }
        }
        return true;
    }
    auto function = std::dynamic_pointer_cast<const FunctionNode>(node);
    return function && function->arguments().size() == 1 &&
        continuous_function_branch(function->type(), function->arguments()[0], point) &&
        elementary_continuous_structure(function->arguments()[0], point);
}

引用了 LMCAS::complex(), continuous_function_branch(), elementary_continuous_structure(), LMCAS::function(), LMCAS::point , 以及 power_continuous_structure().

被这些函数引用 elementary_continuous_structure(), limit_complex_at_point(), oscillatory_one_sided_limit() , 以及 power_continuous_structure().

函数调用图:

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

evaluate_one_sided_node()

LimitResult LMCAS::anonymous_namespace{limit_result.cpp}::evaluate_one_sided_node	(	const NodePtr &	node,
		const std::string &	variable,
		const LimitExprPtr &	point,
		LimitDirection	direction,
		ComputationContext &	context,
		const AssumptionContext &	local,
		const FactsQuery &	facts,
		LimitVisitor &	visitor )

在文件 limit_result.cpp 第 370 行定义.

                                                                                        {
    if (!expression_depends_on_variable(node, variable))
        { return classify_limit_result(node, variable, context, facts); }
    auto original_domain = detail::domain_constraints(node, facts, Domain::Real, context);
    if (!original_domain) { return LimitResult::failure(original_domain.error()); }
    if (!original_domain.value()) { return unknown(); }
    for (const auto& condition : *original_domain.value())
        { if (!visitor.condition_holds_near_point(detail::node(condition))) { return unknown(); } }
    if (auto product = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        auto scaled = scaled_one_sided_limit(*product, variable, point, direction, context, facts);
        if (scaled) { return std::move(*scaled); }
    }
    auto oscillatory = oscillatory_one_sided_limit(node, variable, point, direction, context, facts, visitor);
    if (oscillatory) { return std::move(*oscillatory); }
    detail::RewriteBudget budget(context, context.limits().max_recursion_depth,
                                 context.limits().max_ast_nodes, "limit");
    detail::AssumptionFacts local_facts(local);
    auto prepared = detail::normalize_node(node, budget, local_facts);
    prepared->accept(visitor);
    return classify_limit_result(visitor.get_result(), variable, context, facts);
} catch (const CasError& error) {
    return LimitResult::failure(error);
} catch (const std::bad_alloc&) {
    return LimitResult::failure(CasErrc::ResourceLimit, "allocation failed", "evaluate_one_sided_node");
} catch (const std::length_error& error) {
    return LimitResult::failure(CasErrc::ResourceLimit, error.what(), "evaluate_one_sided_node");
} catch (const std::exception& error) {
    return LimitResult::failure(CasErrc::InternalInvariant, error.what(), "evaluate_one_sided_node");
}

引用了 classify_limit_result(), LMCAS::context, LMCAS::direction, LMCAS::detail::domain_constraints(), evaluate_one_sided_node(), LMCAS::expression_depends_on_variable(), LMCAS::Result< Verified< LimitOutcome > >::failure(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), oscillatory_one_sided_limit(), LMCAS::point, LMCAS::Real, scaled_one_sided_limit(), unknown() , 以及 LMCAS::variable.

被这些函数引用 evaluate_one_sided_node() , 以及 limit_one_sided_checked().

函数调用图:

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

finite_sign()

Result< int > LMCAS::anonymous_namespace{limit_result.cpp}::finite_sign	(	const NodePtr &	node,
		const FactsQuery &	facts,
		ComputationContext &	context )

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

                                                                                                   {
    auto nz = detail::query_nonzero_value(node, facts, Domain::Real, context);
    if (!nz) { return Result<int>::failure(nz.error()); }
    if (nz.value() == Tribool::False) { return 0; }
    auto positive = detail::query_positive_value(node, facts, context);
    if (!positive) { return Result<int>::failure(positive.error()); }
    if (positive.value() == Tribool::True) { return 1; }
    auto nonnegative = detail::query_nonnegative_value(node, facts, context);
    if (!nonnegative) { return Result<int>::failure(nonnegative.error()); }
    if (nonnegative.value() == Tribool::False) { return -1; }
    auto negative = facts.is_negative(node, context);
    if (!negative) { return Result<int>::failure(negative.error()); }
    if (negative.value() == Tribool::True) { return -1; }
    return Result<int>::failure(CasErrc::Inconclusive, "finite sign is unknown", "limit");
}

引用了 LMCAS::context, LMCAS::Result< T >::failure(), LMCAS::False, finite_sign(), LMCAS::Inconclusive, LMCAS::detail::query_nonnegative_value(), LMCAS::detail::query_nonzero_value(), LMCAS::detail::query_positive_value(), LMCAS::Real , 以及 LMCAS::True.

被这些函数引用 classify_infinite_product() , 以及 finite_sign().

函数调用图:

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

has_infinity()

bool LMCAS::anonymous_namespace{limit_result.cpp}::has_infinity

(

const NodePtr &

node

)

在文件 limit_result.cpp 第 35 行定义.

                                       {
    class Detector final : public detail::RecursiveSymbolicVisitor {
    public:
        bool found = false;
        void visit(const FunctionNode& f) override {
            if (f.type() == FunctionNode::FuncType::Infinity) found = true;
            else detail::RecursiveSymbolicVisitor::visit(f);
        }
    } detector;
    if (node) node->accept(detector);
    return detector.found;
}

引用了 LMCAS::SymbolicNode::accept(), has_infinity(), LMCAS::FunctionNode::Infinity, LMCAS::FunctionNode::type() , 以及 LMCAS::detail::RecursiveSymbolicVisitor::visit().

被这些函数引用 classify_limit_result(), has_infinity(), limit_complex_at_point() , 以及 limit_one_sided_checked().

函数调用图:

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

infinity_sign()

int LMCAS::anonymous_namespace{limit_result.cpp}::infinity_sign

(

const LimitOutcome &

value

)

在文件 limit_result.cpp 第 30 行定义.

                                             {
    if (std::holds_alternative<PositiveInfinityLimit>(value)) return 1;
    if (std::holds_alternative<NegativeInfinityLimit>(value)) return -1;
    return 0;
}

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

被这些函数引用 classify_infinite_function(), classify_infinite_power(), classify_infinite_product(), classify_infinite_sum(), combine_one_sided_limits(), infinity_sign(), limit_at_checked_point() , 以及 oscillatory_one_sided_limit().

函数调用图:

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

limit_at_checked_point()

LimitResult LMCAS::anonymous_namespace{limit_result.cpp}::limit_at_checked_point	(	const LimitExprPtr &	expression,
		const std::string &	variable,
		const LimitExprPtr &	point,
		LimitDirection	direction,
		ComputationContext &	context,
		const FactsQuery &	facts,
		Domain	domain )

在文件 limit_result.cpp 第 606 行定义.

                                                {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto endpoint = classify_limit_result(detail::node(point), variable, context, facts, domain);
    if (!endpoint) { return endpoint; }
    const int endpoint_sign = infinity_sign(endpoint.value().value);
    if (domain == Domain::Complex && endpoint_sign) { return unknown(); }
    auto canonical_point = endpoint_sign ? SymbolicExpr::infinity(endpoint_sign)
        : detail::make_expression_ptr(detail::normalize_node(detail::node(std::get<FiniteLimit>(endpoint.value().value).value), transform_budget));
    if (!canonical_point) { return unknown(); }
    if (domain == Domain::Complex) {
        return limit_complex_at_point(expression, variable, canonical_point, context, facts);
    }
    return limit_real_at_point(expression, variable, canonical_point, direction, endpoint_sign, context);
} catch (const CasError& error) {
    return LimitResult::failure(error);
} catch (const std::bad_alloc&) {
    return LimitResult::failure(CasErrc::ResourceLimit, "allocation failed", "limit_at_checked_point");
} catch (const std::length_error& error) {
    return LimitResult::failure(CasErrc::ResourceLimit, error.what(), "limit_at_checked_point");
} catch (const std::exception& error) {
    return LimitResult::failure(CasErrc::InternalInvariant, error.what(), "limit_at_checked_point");
}

引用了 classify_limit_result(), LMCAS::Complex, LMCAS::context, LMCAS::direction, LMCAS::domain, infinity_sign(), limit_at_checked_point(), limit_complex_at_point(), limit_real_at_point(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::point, unknown() , 以及 LMCAS::variable.

被这些函数引用 limit_at_checked_point().

函数调用图:

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

limit_complex_at_point()

LimitResult LMCAS::anonymous_namespace{limit_result.cpp}::limit_complex_at_point	(	const LimitExprPtr &	expression,
		const std::string &	variable,
		const LimitExprPtr &	point,
		ComputationContext &	context,
		const FactsQuery &	facts )

在文件 limit_result.cpp 第 552 行定义.

                                                                                         {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (has_infinity(detail::node(expression))) { return unknown(); }
    if (!expression_depends_on_variable(detail::node(expression), variable)) {
        return classify_limit_result(detail::node(expression), variable, context, facts, Domain::Complex);
    }
    ComplexContinuityPoint continuity_point{variable, detail::node(point), facts, context};
    if (!elementary_continuous_structure(detail::node(expression), &continuity_point)) { return unknown(); }
    std::vector<NodePtr> nonzero_bases;
    auto domain_proof = complex_punctured_domain(detail::node(expression), variable, facts, context, nonzero_bases);
    if (!domain_proof) { return LimitResult::failure(domain_proof.error()); }
    if (!domain_proof.value()) { return unknown(); }
    ComplexPuncturedFacts punctured(facts, nonzero_bases);
    NormalizationVisitor normalizer(transform_budget, punctured, Domain::Complex);
    detail::node(expression)->accept(normalizer);
    auto prepared = normalizer.get_result();
    if (!prepared) { return unknown(); }
    auto substituted = substitute_free(prepared, variable, detail::node(point), &transform_budget);
    if (!substituted) { return unknown(); }
    auto defined = detail::query_definedness(substituted, facts, Domain::Complex, context);
    if (!defined) { return LimitResult::failure(defined.error()); }
    if (defined.value() != Tribool::True) { return unknown(); }
    substituted->accept(normalizer);
    auto value = normalizer.get_result();
    return value ? classify_limit_result(value, variable, context, facts, Domain::Complex) : unknown();
} catch (const CasError& error) {
    return LimitResult::failure(error);
} catch (const std::bad_alloc&) {
    return LimitResult::failure(CasErrc::ResourceLimit, "allocation failed", "limit_complex_at_point");
} catch (const std::length_error& error) {
    return LimitResult::failure(CasErrc::ResourceLimit, error.what(), "limit_complex_at_point");
} catch (const std::exception& error) {
    return LimitResult::failure(CasErrc::InternalInvariant, error.what(), "limit_complex_at_point");
}

引用了 LMCAS::SymbolicNode::accept(), classify_limit_result(), LMCAS::Complex, complex_punctured_domain(), LMCAS::context, elementary_continuous_structure(), LMCAS::expression_depends_on_variable(), LMCAS::Result< Verified< LimitOutcome > >::failure(), LMCAS::NormalizationVisitor::get_result(), has_infinity(), limit_complex_at_point(), LMCAS::detail::node(), LMCAS::point, LMCAS::detail::query_definedness(), LMCAS::substitute_free(), LMCAS::True, unknown(), LMCAS::value , 以及 LMCAS::variable.

被这些函数引用 limit_at_checked_point() , 以及 limit_complex_at_point().

函数调用图:

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

limit_one_sided_checked()

LimitResult LMCAS::anonymous_namespace{limit_result.cpp}::limit_one_sided_checked	(	const LimitExprPtr &	expression,
		const std::string &	variable,
		const LimitExprPtr &	point,
		LimitDirection	direction,
		ComputationContext &	context )

在文件 limit_result.cpp 第 403 行定义.

                                                                                      {
    AssumptionContext local = context.assumptions() ? *context.assumptions() : AssumptionContext{};
    auto real_variable = local.assume_domain_checked(variable, Domain::Real);
    if (!real_variable) { return assumption_limit_failure(real_variable.error()); }
    if (has_infinity(detail::node(point))) {
        const int sign = std::dynamic_pointer_cast<const FunctionNode>(detail::node(point)) ? 1 : -1;
        auto tail = local.assume_sign_checked(variable, sign < 0 ? Sign::Negative : Sign::Positive);
        if (!tail) { return assumption_limit_failure(tail.error()); }
    }
    detail::AssumptionFacts facts(local);
    const char* token = direction == LimitDirection::FromBelow ? "-" : "+";
    LimitVisitor visitor(variable, detail::node(point), token, &local, &context);
    if (!has_infinity(detail::node(point))) {
        auto sign = visitor.sign_near_point(detail::make_node<VariableNode>(variable));
        if (sign && *sign != 0) {
            auto side = local.assume_sign_checked(variable, *sign < 0 ? Sign::Negative : Sign::Positive);
            if (!side) { return assumption_limit_failure(side.error()); }
        }
    }
    SideBranchRewriter branches(visitor, facts, context);
    auto node = branches.rewrite(detail::node(expression));
    return evaluate_one_sided_node(node, variable, point, direction, context, local, facts, visitor);
}

引用了 assumption_limit_failure(), LMCAS::context, LMCAS::direction, evaluate_one_sided_node(), LMCAS::FromBelow, has_infinity(), limit_one_sided_checked(), LMCAS::detail::make_node(), LMCAS::Negative, LMCAS::detail::node(), LMCAS::point, LMCAS::Positive, LMCAS::Real, LMCAS::detail::SymbolicRewriter::rewrite() , 以及 LMCAS::variable.

被这些函数引用 limit_one_sided_checked() , 以及 limit_real_at_point().

函数调用图:

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

limit_real_at_point()

LimitResult LMCAS::anonymous_namespace{limit_result.cpp}::limit_real_at_point	(	const LimitExprPtr &	expression,
		const std::string &	variable,
		const LimitExprPtr &	point,
		LimitDirection	direction,
		int	endpoint_sign,
		ComputationContext &	context )

在文件 limit_result.cpp 第 589 行定义.

                                                                                                         {
    if (direction != LimitDirection::Both || endpoint_sign) {
        return limit_one_sided_checked(expression, variable, point, direction, context);
    }
    auto left = limit_one_sided_checked(expression, variable, point, LimitDirection::FromBelow, context);
    if (!left && left.error().code != CasErrc::Inconclusive) { return left; }
    auto right = limit_one_sided_checked(expression, variable, point, LimitDirection::FromAbove, context);
    if (!right && right.error().code != CasErrc::Inconclusive) { return right; }
    if ((left && std::holds_alternative<LimitDoesNotExist>(left.value().value)) ||
        (right && std::holds_alternative<LimitDoesNotExist>(right.value().value))) {
        return outcome(LimitDoesNotExist{});
    }
    if (!left || !right) { return unknown(); }
    return combine_one_sided_limits(left.value().value, right.value().value, context);
}

引用了 LMCAS::Both, combine_one_sided_limits(), LMCAS::context, LMCAS::direction, LMCAS::FromAbove, LMCAS::FromBelow, LMCAS::Inconclusive, limit_one_sided_checked(), limit_real_at_point(), outcome(), LMCAS::point, LMCAS::right, unknown() , 以及 LMCAS::variable.

被这些函数引用 limit_at_checked_point() , 以及 limit_real_at_point().

函数调用图:

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

oscillatory_one_sided_limit()

std::optional< LimitResult > LMCAS::anonymous_namespace{limit_result.cpp}::oscillatory_one_sided_limit	(	const NodePtr &	node,
		const std::string &	variable,
		const LimitExprPtr &	point,
		LimitDirection	direction,
		ComputationContext &	context,
		const FactsQuery &	facts,
		LimitVisitor &	visitor )

在文件 limit_result.cpp 第 347 行定义.

                                                                                 {
    auto f = std::dynamic_pointer_cast<const FunctionNode>(node);
    if (!f || f->arguments().size() != 1) { return std::nullopt; }
    if (f->type() != FunctionNode::FuncType::Sin && f->type() != FunctionNode::FuncType::Cos) {
        return std::nullopt;
    }
    auto argument = detail::make_expression_ptr(f->arguments()[0]);
    auto inner = limit_checked(argument, variable, point, direction, context);
    if (!inner && inner.error().code != CasErrc::Inconclusive) { return inner; }
    if (!inner || !infinity_sign(inner.value().value) || !elementary_continuous_structure(f->arguments()[0])) {
        return std::nullopt;
    }
    auto domain = detail::domain_constraints(f->arguments()[0], facts, Domain::Real, context);
    if (!domain) { return LimitResult::failure(domain.error()); }
    if (!domain.value()) { return std::nullopt; }
    for (const auto& condition : *domain.value()) {
        if (!visitor.condition_holds_near_point(detail::node(condition))) { return std::nullopt; }
    }
    return outcome(LimitDoesNotExist{});
}

引用了 LMCAS::context, LMCAS::FunctionNode::Cos, LMCAS::direction, LMCAS::domain, LMCAS::detail::domain_constraints(), elementary_continuous_structure(), LMCAS::Result< Verified< LimitOutcome > >::failure(), LMCAS::Inconclusive, infinity_sign(), LMCAS::limit_checked(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), oscillatory_one_sided_limit(), outcome(), LMCAS::point, LMCAS::Real, LMCAS::FunctionNode::Sin , 以及 LMCAS::variable.

被这些函数引用 evaluate_one_sided_node() , 以及 oscillatory_one_sided_limit().

函数调用图:

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

outcome()

LimitResult LMCAS::anonymous_namespace{limit_result.cpp}::outcome

(

LimitOutcome

value

)

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

                                        {
    return LimitResult::success(Verified<LimitOutcome>{std::move(value), ByConstructionProof{}});
}

引用了 outcome(), LMCAS::Result< Verified< LimitOutcome > >::success() , 以及 LMCAS::value.

被这些函数引用 classify_infinite_function(), classify_infinite_power(), classify_infinite_product(), classify_infinite_sum(), classify_limit_result(), combine_one_sided_limits(), limit_real_at_point(), oscillatory_one_sided_limit() , 以及 outcome().

函数调用图:

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

power_continuous_structure()

bool LMCAS::anonymous_namespace{limit_result.cpp}::power_continuous_structure	(	const PowerNode &	power,
		const ComplexContinuityPoint *	point )

在文件 limit_result.cpp 第 218 行定义.

                                                                                             {
    if (point) {
        BigInt integer;
        auto exponent = std::dynamic_pointer_cast<const NumberNode>(power.exponent());
        if ((!exponent || !try_get_integer_value(exponent, integer)) &&
            !point->positive(power.base())) { return false; }
    }
    return elementary_continuous_structure(power.base(), point) &&
        elementary_continuous_structure(power.exponent(), point);
}

引用了 LMCAS::PowerNode::base(), elementary_continuous_structure(), LMCAS::exponent, LMCAS::PowerNode::exponent(), LMCAS::integer, LMCAS::point, power_continuous_structure() , 以及 LMCAS::try_get_integer_value().

被这些函数引用 elementary_continuous_structure() , 以及 power_continuous_structure().

函数调用图:

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

scaled_one_sided_limit()

std::optional< LimitResult > LMCAS::anonymous_namespace{limit_result.cpp}::scaled_one_sided_limit	(	const MultiplyNode &	product,
		const std::string &	variable,
		const LimitExprPtr &	point,
		LimitDirection	direction,
		ComputationContext &	context,
		const FactsQuery &	facts )

在文件 limit_result.cpp 第 324 行定义.

                                                          {
    std::shared_ptr<const SymbolicNode> varying;
    bool invertible_scale = true;
    for (const auto& factor : product.operands()) {
        if (expression_depends_on_variable(factor, variable)) {
            if (varying) { invertible_scale = false; break; }
            varying = factor;
        } else {
            auto nonzero = detail::query_nonzero_value(factor, facts, Domain::Real, context);
            if (!nonzero) { return LimitResult::failure(nonzero.error()); }
            if (nonzero.value() != Tribool::True) { invertible_scale = false; break; }
        }
    }
    if (invertible_scale && varying) {
        auto inner = limit_checked(detail::make_expression_ptr(varying), variable, point, direction, context);
        if (!inner && inner.error().code != CasErrc::Inconclusive) { return inner; }
        if (inner && std::holds_alternative<LimitDoesNotExist>(inner.value().value)) { return inner; }
    }
    return std::nullopt;
}

引用了 LMCAS::context, LMCAS::direction, LMCAS::expression_depends_on_variable(), LMCAS::Result< Verified< LimitOutcome > >::failure(), LMCAS::Inconclusive, LMCAS::limit_checked(), LMCAS::detail::make_expression_ptr(), LMCAS::MultiplyNode::operands(), LMCAS::point, LMCAS::detail::query_nonzero_value(), LMCAS::Real, scaled_one_sided_limit(), LMCAS::True , 以及 LMCAS::variable.

被这些函数引用 evaluate_one_sided_node() , 以及 scaled_one_sided_limit().

函数调用图:

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

unknown()

LimitResult LMCAS::anonymous_namespace{limit_result.cpp}::unknown

(

)

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

                      {
    return LimitResult::failure(CasErrc::Inconclusive,
        "limit could not be proved in the supported domain", "limit");
}

引用了 LMCAS::Result< Verified< LimitOutcome > >::failure(), LMCAS::Inconclusive , 以及 unknown().

被这些函数引用 assumption_limit_failure(), classify_infinite_function(), classify_infinite_power(), classify_infinite_product(), classify_infinite_sum(), classify_limit_result(), combine_one_sided_limits(), evaluate_one_sided_node(), limit_at_checked_point(), limit_complex_at_point(), limit_real_at_point() , 以及 unknown().

函数调用图:

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

validate_limit_input()

Result< void > LMCAS::anonymous_namespace{limit_result.cpp}::validate_limit_input	(	const LimitExprPtr &	expression,
		const std::string &	variable,
		const LimitExprPtr &	point,
		LimitDirection	direction,
		Domain	domain )

在文件 limit_result.cpp 第 533 行定义.

                                                                        {
    if (!expression || !point || !detail::node(expression) || !detail::node(point) || variable.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
            "limit requires an expression, named variable, and point", "limit");
    }
    if (expression_depends_on_variable(detail::node(point), variable)) {
        return Result<void>::failure(CasErrc::InvalidArgument,
            "limit point depends on the approaching variable", "limit");
    }
    if (domain != Domain::Real && domain != Domain::Complex) {
        return Result<void>::failure(CasErrc::InvalidArgument, "limit domain must be Real or Complex", "limit");
    }
    if (domain == Domain::Complex && direction != LimitDirection::Both) {
        return Result<void>::failure(CasErrc::InvalidArgument, "complex limits have no ordered sides", "limit");
    }
    return Result<void>::success();
}

引用了 LMCAS::Both, LMCAS::Complex, LMCAS::direction, LMCAS::domain, LMCAS::expression_depends_on_variable(), LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, LMCAS::detail::node(), LMCAS::point, LMCAS::Real, LMCAS::Result< T >::success(), validate_limit_input() , 以及 LMCAS::variable.

被这些函数引用 validate_limit_input().

函数调用图:

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