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

类
class	RecursionScope

函数
Result< OptionalRationalPolynomial >	recognize_node (const std::shared_ptr< const SymbolicNode > &node, const std::string &variable, ComputationContext &context)
Result< OptionalRationalPolynomial >	recognize_number (const NumberNode &number, const std::string &variable)
Result< OptionalRationalPolynomial >	recognize_power (const PowerNode &power, const std::string &variable, ComputationContext &context)
Result< OptionalRationalPolynomial >	recognize_product (const MultiplyNode &multiply, const std::string &variable, ComputationContext &context)
Result< OptionalRationalPolynomial >	recognize_sum (const AddNode &add, const std::string &variable, ComputationContext &context)

变量
constexpr const char *	kOperation = "recognize_rational_polynomial"

函数说明

recognize_node()

Result< OptionalRationalPolynomial > LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::recognize_node	(	const std::shared_ptr< const SymbolicNode > &	node,
		const std::string &	variable,
		ComputationContext &	context )

在文件 rational_polynomial_recognition.cpp 第 132 行定义.

                                 {
    auto entered = context.enter_recursion(kOperation);
    if (!entered) return Result<OptionalRationalPolynomial>::failure(entered.error());
    RecursionScope scope(context);
 
    if (!node) {
        return Result<OptionalRationalPolynomial>::failure(
            CasErrc::InternalInvariant,
            "polynomial recognition encountered a null AST node",
            kOperation);
    }
 
    if (auto number = std::dynamic_pointer_cast<const NumberNode>(node)) {
        return recognize_number(*number, variable);
    }
    if (auto symbol = std::dynamic_pointer_cast<const VariableNode>(node)) {
        if (symbol->is_constant() || symbol->name() != variable) {
            return Result<OptionalRationalPolynomial>::success(std::nullopt);
        }
        return Result<OptionalRationalPolynomial>::success(
            Polynomial<Rational>({Rational(0), Rational(1)}, variable));
    }
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        return recognize_sum(*add, variable, context);
    }
    if (auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        return recognize_product(*multiply, variable, context);
    }
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        return recognize_power(*power, variable, context);
    }
    return Result<OptionalRationalPolynomial>::success(std::nullopt);
}

引用了 LMCAS::add(), LMCAS::context, LMCAS::Result< T >::failure(), LMCAS::InternalInvariant, kOperation, recognize_node(), recognize_number(), recognize_power(), recognize_product(), recognize_sum(), LMCAS::Result< T >::success() , 以及 LMCAS::variable.

被这些函数引用 recognize_node(), recognize_power(), recognize_product() , 以及 recognize_sum().

函数调用图:

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

recognize_number()

Result< OptionalRationalPolynomial > LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::recognize_number	(	const NumberNode &	number,
		const std::string &	variable )

在文件 rational_polynomial_recognition.cpp 第 24 行定义.

                                                         {
        if (std::holds_alternative<BigInt>(number.value())) {
            return Result<OptionalRationalPolynomial>::success(Polynomial<Rational>(
                Rational(std::get<BigInt>(number.value())), variable));
        }
        if (std::holds_alternative<Rational>(number.value())) {
            return Result<OptionalRationalPolynomial>::success(Polynomial<Rational>(
                std::get<Rational>(number.value()), variable));
        }
        return Result<OptionalRationalPolynomial>::success(std::nullopt);
}

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

被这些函数引用 recognize_node() , 以及 recognize_number().

函数调用图:

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

recognize_power()

Result< OptionalRationalPolynomial > LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::recognize_power	(	const PowerNode &	power,
		const std::string &	variable,
		ComputationContext &	context )

在文件 rational_polynomial_recognition.cpp 第 78 行定义.

                                                                                    {
        auto exponent_node = std::dynamic_pointer_cast<const NumberNode>(power.exponent());
        if (!exponent_node) {
            return Result<OptionalRationalPolynomial>::success(std::nullopt);
        }
 
        BigInt exponent;
        if (std::holds_alternative<BigInt>(exponent_node->value())) {
            exponent = std::get<BigInt>(exponent_node->value());
        } else {
            const Rational& rational = std::get<Rational>(exponent_node->value());
            if (!rational.is_integer()) {
                return Result<OptionalRationalPolynomial>::success(std::nullopt);
            }
            exponent = rational.to_bigint();
        }
 
        auto exponent_value = exponent.try_to_int64();
        if (!exponent_value || *exponent_value <= 0) {
            return Result<OptionalRationalPolynomial>::success(std::nullopt);
        }
        if (static_cast<std::uint64_t>(*exponent_value) >=
            context.limits().max_expansion_terms) {
            return Result<OptionalRationalPolynomial>::failure(
                CasErrc::ResourceLimit,
                "polynomial exponent exceeds the expansion term budget",
                kOperation);
        }
 
        auto base = recognize_node(power.base(), variable, context);
        if (!base) return base;
        if (!base.value()) {
            return Result<OptionalRationalPolynomial>::success(std::nullopt);
        }
 
        Polynomial<Rational> result({Rational(1)}, variable);
        for (std::int64_t i = 0; i < *exponent_value; ++i) {
            auto step = context.consume_steps(1, kOperation);
            if (!step) return Result<OptionalRationalPolynomial>::failure(step.error());
            const std::size_t projected_terms = result.is_zero() || base.value()->is_zero()
                ? 0
                : result.coeffs.size() + base.value()->coeffs.size() - 1;
            if (projected_terms > context.limits().max_expansion_terms) {
                return Result<OptionalRationalPolynomial>::failure(
                    CasErrc::ResourceLimit,
                    "polynomial expansion term budget exhausted",
                    kOperation);
            }
            result = result * *base.value();
        }
        return Result<OptionalRationalPolynomial>::success(std::move(result));
}

引用了 LMCAS::PowerNode::base(), LMCAS::context, LMCAS::exponent, LMCAS::PowerNode::exponent(), LMCAS::Result< T >::failure(), kOperation, LMCAS::rational(), recognize_node(), recognize_power(), LMCAS::ResourceLimit, LMCAS::Result< T >::success() , 以及 LMCAS::variable.

被这些函数引用 recognize_node() , 以及 recognize_power().

函数调用图:

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

recognize_product()

Result< OptionalRationalPolynomial > LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::recognize_product	(	const MultiplyNode &	multiply,
		const std::string &	variable,
		ComputationContext &	context )

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

                                                                                          {
        Polynomial<Rational> result({Rational(1)}, variable);
        for (const auto& operand : multiply.operands()) {
            auto child = recognize_node(operand, variable, context);
            if (!child) return child;
            if (!child.value()) {
                return Result<OptionalRationalPolynomial>::success(std::nullopt);
            }
            const std::size_t projected_terms = result.is_zero() || child.value()->is_zero()
                ? 0
                : result.coeffs.size() + child.value()->coeffs.size() - 1;
            if (projected_terms > context.limits().max_expansion_terms) {
                return Result<OptionalRationalPolynomial>::failure(
                    CasErrc::ResourceLimit,
                    "polynomial expansion term budget exhausted",
                    kOperation);
            }
            result = result * *child.value();
        }
        return Result<OptionalRationalPolynomial>::success(std::move(result));
}

引用了 LMCAS::context, LMCAS::Result< T >::failure(), kOperation, recognize_node(), recognize_product(), LMCAS::ResourceLimit, LMCAS::Result< T >::success() , 以及 LMCAS::variable.

被这些函数引用 recognize_node() , 以及 recognize_product().

函数调用图:

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

recognize_sum()

Result< OptionalRationalPolynomial > LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::recognize_sum	(	const AddNode &	add,
		const std::string &	variable,
		ComputationContext &	context )

在文件 rational_polynomial_recognition.cpp 第 37 行定义.

                                                                                {
        Polynomial<Rational> result(variable);
        for (const auto& operand : add.operands()) {
            auto child = recognize_node(operand, variable, context);
            if (!child) return child;
            if (!child.value()) {
                return Result<OptionalRationalPolynomial>::success(std::nullopt);
            }
            result = result + *child.value();
            if (result.coeffs.size() > context.limits().max_expansion_terms) {
                return Result<OptionalRationalPolynomial>::failure(
                    CasErrc::ResourceLimit, "polynomial term budget exhausted", kOperation);
            }
        }
        return Result<OptionalRationalPolynomial>::success(std::move(result));
}

引用了 LMCAS::add(), LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::context, LMCAS::Result< T >::failure(), kOperation, recognize_node(), recognize_sum(), LMCAS::ResourceLimit, LMCAS::Result< T >::success() , 以及 LMCAS::variable.

被这些函数引用 recognize_node() , 以及 recognize_sum().

函数调用图:

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

变量说明

kOperation

const char* LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::kOperation = "recognize_rational_polynomial"

constexpr

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

被这些函数引用 recognize_node(), recognize_power(), recognize_product() , 以及 recognize_sum().