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

函数
std::optional< ComparableEndpoint >	combine_surd_product (const ComparableEndpoint &left, const ComparableEndpoint &right)
std::optional< ComparableEndpoint >	combine_surd_sum (const ComparableEndpoint &left, const ComparableEndpoint &right)
Result< ComparableEndpoint >	comparable_finite_endpoint (const Endpoint &endpoint, ComputationContext &context, const std::string &operation)
Result< ComparableEndpoint >	comparable_number (const NumberNode &number, ComputationContext &, const std::string &)
Result< ComparableEndpoint >	comparable_root (const RootOfNode &root, ComputationContext &context, const std::string &operation)
Result< ComparableEndpoint >	comparable_surd (ComparableEndpoint surd, ComputationContext &context)
bool	outside_real_function_domain (const FunctionNode &function)
std::optional< ComparableEndpoint >	parse_quadratic_surd (const std::shared_ptr< const SymbolicNode > &node)
std::optional< ComparableEndpoint >	parse_surd_power (const PowerNode &power)
std::optional< ComparableEndpoint >	parse_surd_product (const MultiplyNode &multiply)
std::optional< ComparableEndpoint >	parse_surd_sum (const AddNode &add)
Result< ComparableEndpoint >	unsupported_endpoint (const std::shared_ptr< const SymbolicNode > &node, const std::string &operation)

函数说明

combine_surd_product()

std::optional< ComparableEndpoint > LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::combine_surd_product	(	const ComparableEndpoint &	left,
		const ComparableEndpoint &	right )

在文件 interval_endpoint.cpp 第 63 行定义.

                                                                     {
        if (left.infinity != 0 || right.infinity != 0) {
            return std::nullopt;
        }
        const bool left_radical = left.radical_coefficient != Rational(0);
        const bool right_radical = right.radical_coefficient != Rational(0);
        if (left_radical && right_radical && left.radicand != right.radicand) {
            return std::nullopt;
        }
        const Rational radicand = left_radical ? left.radicand : right.radicand;
        const Rational rational = left.rational * right.rational +
            left.radical_coefficient * right.radical_coefficient * radicand;
        const Rational coefficient =
            left.rational * right.radical_coefficient +
            left.radical_coefficient * right.rational;
        return ComparableEndpoint{0, rational, coefficient, radicand};
}

引用了 combine_surd_product(), LMCAS::detail::ComparableEndpoint::infinity, LMCAS::detail::ComparableEndpoint::radical_coefficient, LMCAS::detail::ComparableEndpoint::radicand, LMCAS::detail::ComparableEndpoint::rational, LMCAS::rational() , 以及 LMCAS::right.

被这些函数引用 combine_surd_product() , 以及 parse_surd_product().

函数调用图:

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

combine_surd_sum()

std::optional< ComparableEndpoint > LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::combine_surd_sum	(	const ComparableEndpoint &	left,
		const ComparableEndpoint &	right )

在文件 interval_endpoint.cpp 第 44 行定义.

                                                                     {
        if (left.infinity != 0 || right.infinity != 0) {
            return std::nullopt;
        }
        if (left.radical_coefficient != Rational(0) &&
            right.radical_coefficient != Rational(0) &&
            left.radicand != right.radicand) {
            return std::nullopt;
        }
        const Rational radicand = left.radical_coefficient != Rational(0)
            ? left.radicand : right.radicand;
        return ComparableEndpoint{
            0,
            left.rational + right.rational,
            left.radical_coefficient + right.radical_coefficient,
            radicand};
}

引用了 combine_surd_sum(), LMCAS::detail::ComparableEndpoint::infinity, LMCAS::detail::ComparableEndpoint::radical_coefficient, LMCAS::detail::ComparableEndpoint::radicand, LMCAS::detail::ComparableEndpoint::rational , 以及 LMCAS::right.

被这些函数引用 combine_surd_sum() , 以及 parse_surd_sum().

函数调用图:

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

comparable_finite_endpoint()

Result< ComparableEndpoint > LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::comparable_finite_endpoint	(	const Endpoint &	endpoint,
		ComputationContext &	context,
		const std::string &	operation )

在文件 interval_endpoint.cpp 第 267 行定义.

                                    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!endpoint.value || !LMCAS::detail::node(endpoint.value)) {
        return Result<ComparableEndpoint>::failure(
            CasErrc::InvalidArgument,
            "finite interval endpoint must contain an expression",
            operation);
    }
 
    auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(endpoint.value), transform_budget));
    if (!simplified || !LMCAS::detail::node(simplified)) {
        return Result<ComparableEndpoint>::failure(
            CasErrc::InternalInvariant,
            "interval endpoint simplification produced a null expression",
            operation);
    }
 
    const auto& node = LMCAS::detail::node(simplified);
    if (auto number = std::dynamic_pointer_cast<const NumberNode>(node)) {
        return comparable_number(*number, context, operation);
    }
    if (auto surd = parse_quadratic_surd(node)) {
        return comparable_surd(std::move(*surd), context);
    }
    if (auto root = std::dynamic_pointer_cast<const RootOfNode>(node)) {
        return comparable_root(*root, context, operation);
    }
    return unsupported_endpoint(node, operation);
} catch (const CasError& error) {
    return Result<ComparableEndpoint>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<ComparableEndpoint>::failure(CasErrc::ResourceLimit, "allocation failed", operation);
} catch (const std::length_error& error) {
    return Result<ComparableEndpoint>::failure(CasErrc::ResourceLimit, error.what(), operation);
} catch (const std::exception& error) {
    return Result<ComparableEndpoint>::failure(CasErrc::InternalInvariant, error.what(), operation);
}

引用了 comparable_finite_endpoint(), comparable_number(), comparable_root(), comparable_surd(), LMCAS::detail::context, LMCAS::Result< T >::failure(), LMCAS::InternalInvariant, LMCAS::InvalidArgument, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::detail::operation, parse_quadratic_surd() , 以及 unsupported_endpoint().

被这些函数引用 comparable_finite_endpoint().

函数调用图:

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

comparable_number()

Result< ComparableEndpoint > LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::comparable_number	(	const NumberNode &	number,
		ComputationContext &	,
		const std::string &	)

在文件 interval_endpoint.cpp 第 175 行定义.

                      {
        if (std::holds_alternative<BigInt>(number.value())) {
            return Result<ComparableEndpoint>::success(ComparableEndpoint{
                0, Rational(std::get<BigInt>(number.value())),
                Rational(0), Rational(0)});
        }
        return Result<ComparableEndpoint>::success(ComparableEndpoint{
            0, std::get<Rational>(number.value()), Rational(0), Rational(0)});
}

引用了 comparable_number(), LMCAS::Result< T >::success() , 以及 LMCAS::NumberNode::value().

被这些函数引用 comparable_finite_endpoint() , 以及 comparable_number().

函数调用图:

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

comparable_root()

Result< ComparableEndpoint > LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::comparable_root	(	const RootOfNode &	root,
		ComputationContext &	context,
		const std::string &	operation )

在文件 interval_endpoint.cpp 第 208 行定义.

                                {
        auto isolated = LMCAS::detail::isolate_exact_root(
            root.exact_id(), context, operation);
        if (!isolated) {
            return Result<ComparableEndpoint>::failure(isolated.error());
        }
        auto* real = std::get_if<LMCAS::detail::RealIsolation>(
            &isolated.value());
        if (!real) {
            return Result<ComparableEndpoint>::failure(
                CasErrc::DomainError,
                "interval endpoint RootOf is not real",
                operation);
        }
        ComparableEndpoint endpoint_value;
        endpoint_value.algebraic = std::move(real->value);
        return Result<ComparableEndpoint>::success(std::move(endpoint_value));
}

引用了 LMCAS::detail::ComparableEndpoint::algebraic, comparable_root(), LMCAS::detail::context, LMCAS::DomainError, LMCAS::RootOfNode::exact_id(), LMCAS::Result< T >::failure(), LMCAS::detail::isolate_exact_root(), LMCAS::detail::operation, LMCAS::real(), LMCAS::Result< T >::success() , 以及 LMCAS::Result< T >::value().

被这些函数引用 comparable_finite_endpoint() , 以及 comparable_root().

函数调用图:

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

comparable_surd()

Result< ComparableEndpoint > LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::comparable_surd	(	ComparableEndpoint	surd,
		ComputationContext &	context )

在文件 interval_endpoint.cpp 第 187 行定义.

                                                          {
        if (surd.radical_coefficient != Rational(0)) {
            const Rational a = surd.rational;
            const Rational b = surd.radical_coefficient;
            const Rational d = surd.radicand;
            auto algebraic = LMCAS::detail::make_exact_real_algebraic(
                Polynomial<Rational>({
                    a * a - b * b * d,
                    Rational(-2) * a,
                    Rational(1)
                }),
                b > Rational(0) ? 1 : 0, 1, context);
            if (!algebraic) {
                return Result<ComparableEndpoint>::failure(algebraic.error());
            }
            surd.algebraic = std::move(algebraic.value());
        }
        return Result<ComparableEndpoint>::success(std::move(surd));
}

引用了 LMCAS::a, LMCAS::detail::ComparableEndpoint::algebraic, LMCAS::b, comparable_surd(), LMCAS::detail::context, LMCAS::Result< T >::failure(), LMCAS::detail::make_exact_real_algebraic(), LMCAS::detail::ComparableEndpoint::radical_coefficient, LMCAS::detail::ComparableEndpoint::radicand, LMCAS::detail::ComparableEndpoint::rational , 以及 LMCAS::Result< T >::success().

被这些函数引用 comparable_finite_endpoint() , 以及 comparable_surd().

函数调用图:

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

outside_real_function_domain()

bool LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::outside_real_function_domain

(

const FunctionNode &

function

)

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

                                                                {
    if (function.arguments().size() != 1) {
        return false;
    }
    auto argument = exact_rational_value(function.arguments()[0]);
    if (!argument) {
        return false;
    }
    if (function.type() == FunctionNode::FuncType::Ln) {
        return *argument <= Rational(0);
    }
    return function.type() == FunctionNode::FuncType::Sqrt &&
        *argument < Rational(0);
}

引用了 LMCAS::detail::exact_rational_value(), LMCAS::function(), LMCAS::FunctionNode::Ln, outside_real_function_domain() , 以及 LMCAS::FunctionNode::Sqrt.

被这些函数引用 outside_real_function_domain() , 以及 unsupported_endpoint().

函数调用图:

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

parse_quadratic_surd()

std::optional< ComparableEndpoint > LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::parse_quadratic_surd

(

const std::shared_ptr< const SymbolicNode > &

node

)

在文件 interval_endpoint.cpp 第 142 行定义.

                                                   {
    if (!node) {
        return std::nullopt;
    }
    if (auto number = exact_rational_value(node)) {
        return ComparableEndpoint{0, *number, Rational(0), Rational(0)};
    }
 
    if (auto function = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        if (function->type() != FunctionNode::FuncType::Sqrt ||
            function->arguments().size() != 1) {
            return std::nullopt;
        }
        auto radicand = exact_rational_value(function->arguments()[0]);
        if (!radicand || *radicand <= Rational(0)) {
            return std::nullopt;
        }
        return ComparableEndpoint{0, Rational(0), Rational(1), *radicand};
    }
 
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        return parse_surd_sum(*add);
    }
    if (auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        return parse_surd_product(*multiply);
    }
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        return parse_surd_power(*power);
    }
    return std::nullopt;
}

引用了 LMCAS::add(), LMCAS::detail::exact_rational_value(), LMCAS::function(), LMCAS::detail::node(), parse_quadratic_surd(), parse_surd_power(), parse_surd_product(), parse_surd_sum() , 以及 LMCAS::FunctionNode::Sqrt.

被这些函数引用 comparable_finite_endpoint(), parse_quadratic_surd(), parse_surd_power(), parse_surd_product() , 以及 parse_surd_sum().

函数调用图:

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

parse_surd_power()

std::optional< ComparableEndpoint > LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::parse_surd_power

(

const PowerNode &

power

)

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

                                                                         {
        auto exponent = exact_rational_value(power.exponent());
        if (!exponent) {
            return std::nullopt;
        }
        if (*exponent == Rational(1, 2)) {
            auto radicand = exact_rational_value(power.base());
            if (!radicand || *radicand <= Rational(0)) {
                return std::nullopt;
            }
            return ComparableEndpoint{0, Rational(0), Rational(1), *radicand};
        }
        auto base = parse_quadratic_surd(power.base());
        if (!base || *exponent != Rational(-1)) {
            return std::nullopt;
        }
        const Rational norm = base->rational * base->rational -
            base->radical_coefficient * base->radical_coefficient * base->radicand;
        if (norm == Rational(0)) {
            return std::nullopt;
        }
        return ComparableEndpoint{
            0,
            base->rational / norm,
            (Rational(0) - base->radical_coefficient) / norm,
            base->radicand};
}

引用了 LMCAS::PowerNode::base(), LMCAS::detail::exact_rational_value(), LMCAS::exponent, LMCAS::PowerNode::exponent(), parse_quadratic_surd() , 以及 parse_surd_power().

被这些函数引用 parse_quadratic_surd() , 以及 parse_surd_power().

函数调用图:

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

parse_surd_product()

std::optional< ComparableEndpoint > LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::parse_surd_product

(

const MultiplyNode &

multiply

)

在文件 interval_endpoint.cpp 第 98 行定义.

                                                                                 {
        ComparableEndpoint result{0, Rational(1), Rational(0), Rational(0)};
        for (const auto& operand : multiply.operands()) {
            auto parsed = parse_quadratic_surd(operand);
            if (!parsed) {
                return std::nullopt;
            }
            auto combined = combine_surd_product(result, *parsed);
            if (!combined) {
                return std::nullopt;
            }
            result = std::move(*combined);
        }
        return result;
}

引用了 combine_surd_product(), parse_quadratic_surd() , 以及 parse_surd_product().

被这些函数引用 parse_quadratic_surd() , 以及 parse_surd_product().

函数调用图:

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

parse_surd_sum()

std::optional< ComparableEndpoint > LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::parse_surd_sum

(

const AddNode &

add

)

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

                                                                   {
        ComparableEndpoint result{0, Rational(0), Rational(0), Rational(0)};
        for (const auto& operand : add.operands()) {
            auto parsed = parse_quadratic_surd(operand);
            if (!parsed) {
                return std::nullopt;
            }
            auto combined = combine_surd_sum(result, *parsed);
            if (!combined) {
                return std::nullopt;
            }
            result = std::move(*combined);
        }
        return result;
}

引用了 LMCAS::add(), combine_surd_sum(), parse_quadratic_surd() , 以及 parse_surd_sum().

被这些函数引用 parse_quadratic_surd() , 以及 parse_surd_sum().

函数调用图:

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

unsupported_endpoint()

Result< ComparableEndpoint > LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::unsupported_endpoint	(	const std::shared_ptr< const SymbolicNode > &	node,
		const std::string &	operation )

在文件 interval_endpoint.cpp 第 244 行定义.

                                                                               {
    if (auto variable = std::dynamic_pointer_cast<const VariableNode>(node);
        variable && !variable->is_constant()) {
        return Result<ComparableEndpoint>::failure(
            CasErrc::UnboundSymbol,
            "interval endpoint contains unbound symbol '" + variable->name() + "'",
            operation);
    }
    if (auto function = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        if (outside_real_function_domain(*function)) {
            return Result<ComparableEndpoint>::failure(
                CasErrc::DomainError,
                "interval endpoint is outside the real function domain",
                operation);
        }
    }
    return Result<ComparableEndpoint>::failure(
        CasErrc::Inconclusive,
        "exact ordering of a symbolic interval endpoint is not proven",
        operation);
}

引用了 LMCAS::DomainError, LMCAS::Result< T >::failure(), LMCAS::function(), LMCAS::Inconclusive, LMCAS::detail::node(), LMCAS::detail::operation, outside_real_function_domain(), LMCAS::UnboundSymbol, unsupported_endpoint() , 以及 LMCAS::detail::variable.

被这些函数引用 comparable_finite_endpoint() , 以及 unsupported_endpoint().

函数调用图:

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