类
class	ExplicitComplexFinder
class	FunctionDependencyFinder
class	FunctionOfExplicitComplexFinder

函数
std::optional< int >	bounded_complex_power (const std::shared_ptr< const SymbolicNode > &node)
bool	contains_explicit_complex (const detail::SymbolicNodePtr &node)
bool	has_function_of_explicit_complex (const detail::SymbolicNodePtr &node)
bool	has_z_dependent_function (const detail::SymbolicNodePtr &node, const std::string &z)
void	split_real_imag (const std::shared_ptr< const SymbolicNode > &node, std::shared_ptr< SymbolicExpr > &re, std::shared_ptr< SymbolicExpr > &im, ComputationContext &context)
	递归地将表达式分解为 (实部, 虚部)，把 ComplexNode 视为 a+bi。仅处理加法、乘法、数值与 ComplexNode 组合；其余子表达式视为实值。
Result< void >	validate_complex_expr_input (const std::shared_ptr< SymbolicExpr > &expr, ComputationContext &context, const std::string &operation)
Result< void >	validate_complex_expr_point_input (const std::shared_ptr< SymbolicExpr > &expr, const std::string &z, const std::shared_ptr< SymbolicExpr > &z0, int order, ComputationContext &context, const std::string &operation)

函数说明

◆ bounded_complex_power()

std::optional< int > LMCAS::anonymous_namespace{complex_analysis.cpp}::bounded_complex_power ( const std::shared_ptr< const SymbolicNode > & node )

在文件 complex_analysis.cpp 第 392 行定义.

                                                   {
    auto number = std::dynamic_pointer_cast<const NumberNode>(node);
    if (!number) return std::nullopt;
    BigInt exponent;
    if (const auto* integer = std::get_if<BigInt>(&number->value())) {
        exponent = *integer;
    } else if (const auto* rational = std::get_if<Rational>(&number->value())) {
        if (!rational->is_integer()) return std::nullopt;
        exponent = rational->get_numerator();
    }
    if (exponent < BigInt(0) || exponent > BigInt(16)) return std::nullopt;
    return static_cast<int>(*exponent.try_to_int64());
}

引用了 bounded_complex_power(), LMCAS::exponent, LMCAS::integer , 以及 LMCAS::rational().

被这些函数引用 bounded_complex_power() , 以及 split_real_imag().

函数调用图:

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

◆ contains_explicit_complex()

bool LMCAS::anonymous_namespace{complex_analysis.cpp}::contains_explicit_complex ( const detail::SymbolicNodePtr & node )

在文件 complex_analysis.cpp 第 133 行定义.

                                                                  {
    if (!node) return false;
    ExplicitComplexFinder finder;
    node->accept(finder);
    return finder.found();
}

引用了 LMCAS::SymbolicNode::accept(), contains_explicit_complex() , 以及 LMCAS::anonymous_namespace{complex_analysis.cpp}::ExplicitComplexFinder::found().

被这些函数引用 contains_explicit_complex() , 以及 LMCAS::anonymous_namespace{complex_analysis.cpp}::FunctionOfExplicitComplexFinder::visit_function().

函数调用图:

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

◆ has_function_of_explicit_complex()

bool LMCAS::anonymous_namespace{complex_analysis.cpp}::has_function_of_explicit_complex ( const detail::SymbolicNodePtr & node )

在文件 complex_analysis.cpp 第 179 行定义.

                                                                         {
    if (!node) return false;
    FunctionOfExplicitComplexFinder finder;
    node->accept(finder);
    return finder.found();
}

引用了 LMCAS::SymbolicNode::accept(), LMCAS::anonymous_namespace{complex_analysis.cpp}::FunctionOfExplicitComplexFinder::found() , 以及 has_function_of_explicit_complex().

被这些函数引用 has_function_of_explicit_complex().

函数调用图:

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

◆ has_z_dependent_function()

bool LMCAS::anonymous_namespace{complex_analysis.cpp}::has_z_dependent_function	(	const detail::SymbolicNodePtr &	node,
		const std::string &	z )

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

                                                  {
    if (!node) return false;
    FunctionDependencyFinder finder(z);
    node->accept(finder);
    return finder.found();
}

引用了 LMCAS::SymbolicNode::accept(), LMCAS::anonymous_namespace{complex_analysis.cpp}::FunctionDependencyFinder::found() , 以及 has_z_dependent_function().

被这些函数引用 has_z_dependent_function().

函数调用图:

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

◆ split_real_imag()

void LMCAS::anonymous_namespace{complex_analysis.cpp}::split_real_imag	(	const std::shared_ptr< const SymbolicNode > &	node,
		std::shared_ptr< SymbolicExpr > &	re,
		std::shared_ptr< SymbolicExpr > &	im,
		ComputationContext &	context )

递归地将表达式分解为 (实部, 虚部)，把 ComplexNode 视为 a+bi。仅处理加法、乘法、数值与 ComplexNode 组合；其余子表达式视为实值。

累乘：(a+bi)(c+di) = (ac-bd) + (ad+bc)i

对整数次幂，展开为重复乘法以分离实/虚部。

(a+bi)^e via repeated complex multiplication

实底数或非整数指数：视为实值

退化情形：原样返回为实部

默认：视为实值表达式

在文件 complex_analysis.cpp 第 409 行定义.

                                                                                   {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    re = SymbolicExpr::number(0);
    im = SymbolicExpr::number(0);
    if (!node) return;
 
 
    if (auto cn = std::dynamic_pointer_cast<const ComplexNode>(node)) {
        re = LMCAS::detail::make_expression_ptr(cn->real());
        im = LMCAS::detail::make_expression_ptr(cn->imag());
        return;
    }
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        for (const auto& op : add->operands()) {
            std::shared_ptr<SymbolicExpr> r2, i2;
            split_real_imag(op, r2, i2, context);
            re = SymbolicExpr::add(re, r2);
            im = SymbolicExpr::add(im, i2);
        }
        re = detail::make_expression_ptr(detail::normalize_node(detail::node(re), transform_budget));
        im = detail::make_expression_ptr(detail::normalize_node(detail::node(im), transform_budget));
        return;
    }
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        /// 累乘：(a+bi)(c+di) = (ac-bd) + (ad+bc)i
        std::shared_ptr<SymbolicExpr> accR = SymbolicExpr::number(1);
        std::shared_ptr<SymbolicExpr> accI = SymbolicExpr::number(0);
        for (const auto& op : mul->operands()) {
            std::shared_ptr<SymbolicExpr> r2, i2;
            split_real_imag(op, r2, i2, context);
            auto ac = SymbolicExpr::multiply(accR, r2);
            auto bd = SymbolicExpr::multiply(accI, i2);
            auto ad = SymbolicExpr::multiply(accR, i2);
            auto bc = SymbolicExpr::multiply(accI, r2);
            accR = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(ac, SymbolicExpr::multiply(SymbolicExpr::number(-1), bd))), transform_budget));
            accI = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(ad, bc)), transform_budget));
        }
        re = accR;
        im = accI;
        return;
    }
    if (auto pw = std::dynamic_pointer_cast<const PowerNode>(node)) {
        /// 对整数次幂，展开为重复乘法以分离实/虚部。
        auto exponent = bounded_complex_power(pw->exponent());
        std::shared_ptr<SymbolicExpr> baseR, baseI;
        split_real_imag(pw->base(), baseR, baseI, context);
        bool base_real = LMCAS::detail::node(baseI) && LMCAS::detail::node(baseI)->is_zero();
        if (exponent && !base_real) {
            /// (a+bi)^e via repeated complex multiplication
            std::shared_ptr<SymbolicExpr> accR = SymbolicExpr::number(1);
            std::shared_ptr<SymbolicExpr> accI = SymbolicExpr::number(0);
            for (int k = 0; k < *exponent; ++k) {
                auto ac = SymbolicExpr::multiply(accR, baseR);
                auto bd = SymbolicExpr::multiply(accI, baseI);
                auto ad = SymbolicExpr::multiply(accR, baseI);
                auto bc = SymbolicExpr::multiply(accI, baseR);
                accR = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(ac, SymbolicExpr::multiply(SymbolicExpr::number(-1), bd))), transform_budget));
                accI = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(ad, bc)), transform_budget));
            }
            re = accR; im = accI;
            return;
        }
        /// 实底数或非整数指数：视为实值
        if (base_real) {
            re = LMCAS::detail::make_expression_ptr(node);
            im = SymbolicExpr::number(0);
            return;
        }
        /// 退化情形：原样返回为实部
        re = LMCAS::detail::make_expression_ptr(node);
        im = SymbolicExpr::number(0);
        return;
    }
    /// 默认：视为实值表达式
    re = LMCAS::detail::make_expression_ptr(node);
    im = SymbolicExpr::number(0);
}

引用了 LMCAS::add(), bounded_complex_power(), LMCAS::context, LMCAS::exponent, LMCAS::SymbolicNode::is_zero(), LMCAS::detail::make_expression_ptr(), LMCAS::mul(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::op , 以及 split_real_imag().

被这些函数引用 split_real_imag().

函数调用图:

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

◆ validate_complex_expr_input()

Result< void > LMCAS::anonymous_namespace{complex_analysis.cpp}::validate_complex_expr_input	(	const std::shared_ptr< SymbolicExpr > &	expr,
		ComputationContext &	context,
		const std::string &	operation )

在文件 complex_analysis.cpp 第 21 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) return step;
    if (!expr || !LMCAS::detail::node(expr)) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "expression cannot be null", operation);
    }
    return Result<void>::success();
}

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

被这些函数引用 validate_complex_expr_input().

函数调用图:

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

◆ validate_complex_expr_point_input()

Result< void > LMCAS::anonymous_namespace{complex_analysis.cpp}::validate_complex_expr_point_input	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	z,
		const std::shared_ptr< SymbolicExpr > &	z0,
		int	order,
		ComputationContext &	context,
		const std::string &	operation )

在文件 complex_analysis.cpp 第 34 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) return step;
    if (!expr || !LMCAS::detail::node(expr) || !z0 || !LMCAS::detail::node(z0)) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "complex-analysis expressions cannot be null",
                                     operation);
    }
    if (z.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "complex variable name cannot be empty",
                                     operation);
    }
    if (order < 1 || order > 13) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "complex-analysis order must be between 1 and 13",
                                     operation);
    }
    return Result<void>::success();
}

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

被这些函数引用 validate_complex_expr_point_input().

函数调用图:

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

类

函数

函数说明

◆ bounded_complex_power()

◆ contains_explicit_complex()

◆ has_function_of_explicit_complex()

◆ has_z_dependent_function()

◆ split_real_imag()

◆ validate_complex_expr_input()

◆ validate_complex_expr_point_input()