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

函数
std::optional< int >	integer_value_from_node (const std::shared_ptr< const SymbolicNode > &node)
static std::optional< int >	laurent_power_of_power (const PowerNode &power, const std::string &var)
double	series_get_double (const std::shared_ptr< SymbolicExpr > &expression)
bool	series_is_infinity (const std::shared_ptr< SymbolicExpr > &expression)
bool	series_is_number (const std::shared_ptr< SymbolicExpr > &expression)
double	series_number_value (const NumberNode &number)
std::optional< int >	supported_laurent_integer_power (const std::shared_ptr< const SymbolicNode > &node, const std::string &variable)
Result< void >	validate_power_series_coefficients (const std::vector< std::shared_ptr< SymbolicExpr > > &coefficients, const std::string &operation, const std::string &name)
Result< void >	validate_series_variable (const std::string &variable, ComputationContext &context, const std::string &operation)

函数说明

integer_value_from_node()

std::optional< int > LMCAS::detail::series_support::integer_value_from_node

(

const std::shared_ptr< const SymbolicNode > &

node

)

在文件 series_engine.cpp 第 69 行定义.

{
    BigInt integer;
    if (!try_get_integer_value(std::dynamic_pointer_cast<const NumberNode>(node), integer)) {
        return std::nullopt;
    }
    auto value = integer.try_to_int64();
    if (!value || *value < std::numeric_limits<int>::min() ||
        *value > std::numeric_limits<int>::max()) {
        return std::nullopt;
    }
    return static_cast<int>(*value);
}

引用了 LMCAS::integer, integer_value_from_node(), LMCAS::detail::node(), LMCAS::try_get_integer_value() , 以及 LMCAS::value.

被这些函数引用 integer_value_from_node() , 以及 laurent_power_of_power().

函数调用图:

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

laurent_power_of_power()

std::optional< int > LMCAS::detail::series_support::laurent_power_of_power ( const PowerNode & power, const std::string & var )

static

在文件 series_engine.cpp 第 83 行定义.

                                                  {
    auto exponent = integer_value_from_node(power.exponent());
    if (!exponent) {
        return std::nullopt;
    }
    auto base = std::dynamic_pointer_cast<const VariableNode>(power.base());
    if (base && !base->is_constant() && base->name() == var) {
        return *exponent;
    }
    auto nested = supported_laurent_integer_power(power.base(), var);
    if (!nested) {
        return std::nullopt;
    }
    const BigInt product = BigInt(*nested) * BigInt(*exponent);
    if (product < BigInt(std::numeric_limits<int>::min()) ||
        product > BigInt(std::numeric_limits<int>::max())) {
        return std::nullopt;
    }
    return static_cast<int>(*product.try_to_int64());
}

引用了 LMCAS::PowerNode::base(), LMCAS::exponent, LMCAS::PowerNode::exponent(), integer_value_from_node(), laurent_power_of_power() , 以及 supported_laurent_integer_power().

被这些函数引用 laurent_power_of_power() , 以及 supported_laurent_integer_power().

函数调用图:

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

series_get_double()

double LMCAS::detail::series_support::series_get_double

(

const std::shared_ptr< SymbolicExpr > &

expression

)

在文件 series_convergence.cpp 第 33 行定义.

                                                                  {
    if (!expr || !LMCAS::detail::node(expr)) {
        return 0.0;
    }
    auto num = std::dynamic_pointer_cast<const NumberNode>(LMCAS::detail::node(expr));
    if (!num) {
        return 0.0;
    }
    return series_number_value(*num);
}

引用了 LMCAS::detail::node(), LMCAS::polynomial_solver_detail::num(), series_get_double() , 以及 series_number_value().

被这些函数引用 series_get_double() , 以及 series_is_infinity().

函数调用图:

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

series_is_infinity()

bool LMCAS::detail::series_support::series_is_infinity

(

const std::shared_ptr< SymbolicExpr > &

expression

)

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

                                                                 {
    if (!expr || !LMCAS::detail::node(expr)) {
        return false;
    }
    auto func = std::dynamic_pointer_cast<const FunctionNode>(LMCAS::detail::node(expr));
    if (func && func->type() == FunctionNode::FuncType::Infinity) {
        return true;
    }
    if (series_is_number(expr)) {
        return std::isinf(series_get_double(expr));
    }
    return false;
}

引用了 LMCAS::FunctionNode::Infinity, LMCAS::detail::node(), series_get_double(), series_is_infinity() , 以及 series_is_number().

被这些函数引用 series_is_infinity().

函数调用图:

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

series_is_number()

bool LMCAS::detail::series_support::series_is_number

(

const std::shared_ptr< SymbolicExpr > &

expression

)

在文件 series_convergence.cpp 第 26 行定义.

                                                               {
    if (!expr || !LMCAS::detail::node(expr)) {
        return false;
    }
    return expr->is_number();
}

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

被这些函数引用 series_is_infinity() , 以及 series_is_number().

函数调用图:

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

series_number_value()

double LMCAS::detail::series_support::series_number_value

(

const NumberNode &

number

)

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

                                                     {
    if (std::holds_alternative<BigInt>(number.value())) {
        return std::get<BigInt>(number.value()).to_double();
    }
    return std::get<Rational>(number.value()).to_double();
}

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

被这些函数引用 series_get_double() , 以及 series_number_value().

函数调用图:

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

supported_laurent_integer_power()

std::optional< int > LMCAS::detail::series_support::supported_laurent_integer_power	(	const std::shared_ptr< const SymbolicNode > &	node,
		const std::string &	variable )

在文件 series_engine.cpp 第 105 行定义.

{
    if (!node) {
        return std::nullopt;
    }
    if (std::dynamic_pointer_cast<const NumberNode>(node)) {
        return 0;
    }
    if (auto variable = std::dynamic_pointer_cast<const VariableNode>(node)) {
        return !variable->is_constant() && variable->name() == var
            ? std::optional<int>(1) : std::nullopt;
    }
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        return laurent_power_of_power(*power, var);
    }
    if (auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        BigInt total_power(0);
        for (const auto& operand : multiply->operands()) {
            if (std::dynamic_pointer_cast<const NumberNode>(operand)) {
                continue;
            }
            auto power = supported_laurent_integer_power(operand, var);
            if (!power) {
                return std::nullopt;
            }
            total_power += BigInt(*power);
        }
        if (total_power < BigInt(std::numeric_limits<int>::min()) ||
            total_power > BigInt(std::numeric_limits<int>::max())) {
            return std::nullopt;
        }
        return static_cast<int>(*total_power.try_to_int64());
    }
    return std::nullopt;
 
 
}

引用了 laurent_power_of_power(), LMCAS::detail::node(), supported_laurent_integer_power() , 以及 LMCAS::detail::variable.

被这些函数引用 laurent_power_of_power() , 以及 supported_laurent_integer_power().

函数调用图:

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

validate_power_series_coefficients()

Result< void > LMCAS::detail::series_support::validate_power_series_coefficients	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	coefficients,
		const std::string &	operation,
		const std::string &	name )

在文件 series_engine.cpp 第 145 行定义.

{
    for (size_t i = 0; i < coeffs.size(); ++i) {
        if (!coeffs[i] || !LMCAS::detail::node(coeffs[i])) {
            return Result<void>::failure(
                CasErrc::InvalidArgument,
                name + " contains a null coefficient at index " + std::to_string(i),
                operation);
        }
    }
    return Result<void>::success();
}

引用了 LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, LMCAS::name, LMCAS::detail::node(), LMCAS::detail::operation, LMCAS::Result< T >::success() , 以及 validate_power_series_coefficients().

被这些函数引用 validate_power_series_coefficients().

函数调用图:

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

validate_series_variable()

Result< void > LMCAS::detail::series_support::validate_series_variable	(	const std::string &	variable,
		ComputationContext &	context,
		const std::string &	operation )

在文件 series_engine.cpp 第 53 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) {
        return step;
    }
    if (var.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "series variable name cannot be empty",
                                     operation);
    }
    return Result<void>::success();
}

引用了 LMCAS::detail::context, LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, LMCAS::detail::operation, LMCAS::Result< T >::success() , 以及 validate_series_variable().

被这些函数引用 validate_series_variable().

函数调用图:

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