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

类
struct	SubstNodeVisitor

函数
static void	collect_transcendental_subexprs (const std::shared_ptr< const SymbolicNode > &node, const std::string &var, std::vector< std::shared_ptr< SymbolicExpr > > &candidates)
static void	deduplicate_candidates (std::vector< std::shared_ptr< SymbolicExpr > > &candidates)
static BigInt	extract_exp_multiplier (const std::shared_ptr< const SymbolicNode > &node, const std::string &var)
static bool	function_candidate (const FunctionNode &function, const std::string &var)
static bool	has_exp_k_var_terms (const std::shared_ptr< const SymbolicNode > &node, const std::string &var)
static Result< bool >	is_substitution_polynomial (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, const std::string &u_var)
static bool	power_candidate (const PowerNode &power, const std::string &var)
static BigInt	product_exp_multiplier (const MultiplyNode &product, const std::string &var)
static Result< bool >	redundant_variable_candidate (const std::shared_ptr< SymbolicExpr > &candidate, const std::shared_ptr< SymbolicExpr > &expr, const std::string &var)
static std::shared_ptr< const SymbolicNode >	rewrite_exp_as_u_power (const std::shared_ptr< const SymbolicNode > &node, const std::string &var, const std::string &u_var)

函数说明

collect_transcendental_subexprs()

void LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::collect_transcendental_subexprs ( const std::shared_ptr< const SymbolicNode > & node, const std::string & var, std::vector< std::shared_ptr< SymbolicExpr > > & candidates )

static

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

                                                        {
 
    if (!node) {
        return;
    }
 
    if (auto func = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        if (function_candidate(*func, var)) {
            candidates.push_back(LMCAS::detail::make_expression_ptr(node));
        }
 
        for (auto& arg : func->arguments()) {
            collect_transcendental_subexprs(arg, var, candidates);
        }
        return;
    }
 
    if (auto pow = std::dynamic_pointer_cast<const PowerNode>(node)) {
        if (power_candidate(*pow, var)) {
            candidates.push_back(LMCAS::detail::make_expression_ptr(pow->base()));
        }
 
        collect_transcendental_subexprs(pow->base(), var, candidates);
        collect_transcendental_subexprs(pow->exponent(), var, candidates);
        return;
    }
 
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        for (auto& op : add->operands()) {
            collect_transcendental_subexprs(op, var, candidates);
        }
        return;
    }
 
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        for (auto& op : mul->operands()) {
            collect_transcendental_subexprs(op, var, candidates);
        }
        return;
    }
}

引用了 LMCAS::add(), collect_transcendental_subexprs(), function_candidate(), LMCAS::detail::make_expression_ptr(), LMCAS::mul(), LMCAS::op, LMCAS::pow() , 以及 power_candidate().

被这些函数引用 collect_transcendental_subexprs().

函数调用图:

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

deduplicate_candidates()

void LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::deduplicate_candidates ( std::vector< std::shared_ptr< SymbolicExpr > > & candidates )

static

在文件 transcendental_solver_substitution.cpp 第 79 行定义.

                                                                                       {
    std::vector<std::shared_ptr<SymbolicExpr>> unique;
    std::vector<std::string> seen;
    for (auto& c : candidates) {
        std::string s = c->to_string();
        bool found = false;
        for (auto& existing : seen) {
            if (existing == s) { found = true; break; }
        }
        if (!found) {
            seen.push_back(s);
            unique.push_back(c);
        }
    }
    candidates = std::move(unique);
}

引用了 LMCAS::c , 以及 deduplicate_candidates().

被这些函数引用 deduplicate_candidates().

函数调用图:

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

extract_exp_multiplier()

BigInt LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::extract_exp_multiplier ( const std::shared_ptr< const SymbolicNode > & node, const std::string & var )

static

在文件 transcendental_solver_substitution.cpp 第 125 行定义.

                                                                                                          {
    auto func = std::dynamic_pointer_cast<const FunctionNode>(node);
    if (!func || func->type() != FunctionNode::FuncType::Exp || func->arguments().size() != 1) {
        return 0;
    }
 
    auto arg = func->arguments()[0];
 
    if (auto v = std::dynamic_pointer_cast<const VariableNode>(arg)) {
        if (!v->is_constant() && v->name() == var) {
            return 1;
        }
    }
 
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(arg)) {
        return product_exp_multiplier(*mul, var);
    }
 
    return 0;
}

引用了 LMCAS::FunctionNode::Exp, extract_exp_multiplier(), LMCAS::mul(), product_exp_multiplier() , 以及 LMCAS::v.

被这些函数引用 extract_exp_multiplier(), has_exp_k_var_terms() , 以及 rewrite_exp_as_u_power().

函数调用图:

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

function_candidate()

bool LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::function_candidate ( const FunctionNode & function, const std::string & var )

static

在文件 transcendental_solver_substitution.cpp 第 13 行定义.

                                                                                   {
    if (function.arguments().size() != 1 ||
        !expression_depends_on_variable(function.arguments()[0], var)) {
        return false;
    }
    using Type = FunctionNode::FuncType;
    return function.type() == Type::Exp || function.type() == Type::Sin ||
           function.type() == Type::Cos || function.type() == Type::Tan;
}

引用了 LMCAS::expression_depends_on_variable(), LMCAS::function() , 以及 function_candidate().

被这些函数引用 collect_transcendental_subexprs() , 以及 function_candidate().

函数调用图:

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

has_exp_k_var_terms()

bool LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::has_exp_k_var_terms ( const std::shared_ptr< const SymbolicNode > & node, const std::string & var )

static

在文件 transcendental_solver_substitution.cpp 第 200 行定义.

                                                                                                     {
    if (!node) {
        return false;
    }
 
    if (extract_exp_multiplier(node, var) > 0) {
        return true;
    }
 
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        for (auto& op : add->operands()) {
            if (has_exp_k_var_terms(op, var)) {
                return true;
            }
        }
    }
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        for (auto& op : mul->operands()) {
            if (has_exp_k_var_terms(op, var)) {
                return true;
            }
        }
    }
    if (auto pow = std::dynamic_pointer_cast<const PowerNode>(node)) {
        if (has_exp_k_var_terms(pow->base(), var)) {
            return true;
        }
        if (has_exp_k_var_terms(pow->exponent(), var)) {
            return true;
        }
    }
    if (auto func = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        for (auto& arg : func->arguments()) {
            if (has_exp_k_var_terms(arg, var)) {
                return true;
            }
        }
    }
 
    return false;
}

引用了 LMCAS::add(), extract_exp_multiplier(), has_exp_k_var_terms(), LMCAS::mul(), LMCAS::op , 以及 LMCAS::pow().

被这些函数引用 has_exp_k_var_terms().

函数调用图:

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

is_substitution_polynomial()

Result< bool > LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::is_substitution_polynomial ( const std::shared_ptr< SymbolicExpr > & expr, const std::string & var, const std::string & u_var )

static

在文件 transcendental_solver_substitution.cpp 第 306 行定义.

                                                  {
    if (expression_depends_on_variable(LMCAS::detail::node(expr), var)) {
        return false;
    }
    auto polynomial = symbolic_to_poly<SymbolicPolyCoeff>(expr, u_var);
    if (!polynomial) {
        if (polynomial.error().code == CasErrc::UnsupportedExpression) {
            return false;
        }
        return Result<bool>::failure(polynomial.error());
    }
    return polynomial.value().degree() >= 2;
}

引用了 LMCAS::expression_depends_on_variable(), LMCAS::Result< T >::failure(), is_substitution_polynomial(), LMCAS::detail::node() , 以及 LMCAS::UnsupportedExpression.

被这些函数引用 is_substitution_polynomial().

函数调用图:

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

power_candidate()

bool LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::power_candidate ( const PowerNode & power, const std::string & var )

static

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

                                                                          {
    if (!expression_depends_on_variable(power.base(), var) ||
        expression_depends_on_variable(power.exponent(), var)) {
        return false;
    }
    auto exponent = std::dynamic_pointer_cast<const NumberNode>(power.exponent());
    BigInt value;
    return try_get_integer_value(exponent, value) && value >= 2;
}

引用了 LMCAS::PowerNode::base(), LMCAS::exponent, LMCAS::PowerNode::exponent(), LMCAS::expression_depends_on_variable(), power_candidate(), LMCAS::try_get_integer_value() , 以及 LMCAS::value.

被这些函数引用 collect_transcendental_subexprs() , 以及 power_candidate().

函数调用图:

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

product_exp_multiplier()

BigInt LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::product_exp_multiplier ( const MultiplyNode & product, const std::string & var )

static

在文件 transcendental_solver_substitution.cpp 第 96 行定义.

                                                                                        {
    std::shared_ptr<const NumberNode> number;
    bool has_variable = false;
    bool has_other = false;
    for (const auto& operand : product.operands()) {
        if (auto numeric = std::dynamic_pointer_cast<const NumberNode>(operand)) {
            if (!number) {
                number = numeric;
            } else {
                has_other = true;
            }
        } else if (auto variable = std::dynamic_pointer_cast<const VariableNode>(operand)) {
            if (!variable->is_constant() && variable->name() == var) {
                has_variable = true;
            } else {
                has_other = true;
            }
        } else {
            has_other = true;
        }
    }
    BigInt value;
    if (has_variable && number && !has_other &&
        try_get_integer_value(number, value) && value > 0) {
        return value;
    }
    return 0;
}

引用了 LMCAS::MultiplyNode::operands(), product_exp_multiplier(), LMCAS::try_get_integer_value(), LMCAS::value , 以及 LMCAS::variable.

被这些函数引用 extract_exp_multiplier() , 以及 product_exp_multiplier().

函数调用图:

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

redundant_variable_candidate()

Result< bool > LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::redundant_variable_candidate ( const std::shared_ptr< SymbolicExpr > & candidate, const std::shared_ptr< SymbolicExpr > & expr, const std::string & var )

static

在文件 transcendental_solver_substitution.cpp 第 289 行定义.

                                                                   {
    auto variable = std::dynamic_pointer_cast<const VariableNode>(LMCAS::detail::node(candidate));
    if (!variable || variable->is_constant() || variable->name() != var) {
        return false;
    }
    auto polynomial = symbolic_to_poly<SymbolicPolyCoeff>(expr, var);
    if (!polynomial) {
        if (polynomial.error().code == CasErrc::UnsupportedExpression) {
            return false;
        }
        return Result<bool>::failure(polynomial.error());
    }
    return polynomial.value().degree() >= 2;
}

引用了 LMCAS::Result< T >::failure(), LMCAS::detail::node(), redundant_variable_candidate(), LMCAS::UnsupportedExpression , 以及 LMCAS::variable.

被这些函数引用 redundant_variable_candidate().

函数调用图:

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

rewrite_exp_as_u_power()

std::shared_ptr< const SymbolicNode > LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::rewrite_exp_as_u_power ( const std::shared_ptr< const SymbolicNode > & node, const std::string & var, const std::string & u_var )

static

在文件 transcendental_solver_substitution.cpp 第 146 行定义.

                            {
 
    if (!node) {
        return node;
    }
 
    const BigInt k = extract_exp_multiplier(node, var);
    if (k > 0) {
        auto u_node = LMCAS::detail::make_node<VariableNode>(u_var);
        if (k == 1) {
            return u_node;
        }
        return SymbolicFactory::create_power(u_node, LMCAS::detail::make_node<NumberNode>(k));
    }
 
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        std::vector<std::shared_ptr<const SymbolicNode>> new_ops;
        new_ops.reserve(add->operands().size());
        for (auto& op : add->operands()) {
            new_ops.push_back(rewrite_exp_as_u_power(op, var, u_var));
        }
        return SymbolicFactory::create_add(std::move(new_ops));
    }
 
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        std::vector<std::shared_ptr<const SymbolicNode>> new_ops;
        new_ops.reserve(mul->operands().size());
        for (auto& op : mul->operands()) {
            new_ops.push_back(rewrite_exp_as_u_power(op, var, u_var));
        }
        return SymbolicFactory::create_multiply(std::move(new_ops));
    }
 
    if (auto pow = std::dynamic_pointer_cast<const PowerNode>(node)) {
        auto new_base = rewrite_exp_as_u_power(pow->base(), var, u_var);
        auto new_exp = rewrite_exp_as_u_power(pow->exponent(), var, u_var);
        return SymbolicFactory::create_power(new_base, new_exp);
    }
 
    if (auto func = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        std::vector<std::shared_ptr<const SymbolicNode>> new_args;
        new_args.reserve(func->arguments().size());
        for (auto& arg : func->arguments()) {
            new_args.push_back(rewrite_exp_as_u_power(arg, var, u_var));
        }
        return LMCAS::detail::make_node<FunctionNode>(func->type(), std::move(new_args));
    }
 
    return node;
}

引用了 LMCAS::add(), LMCAS::SymbolicFactory::create_add(), LMCAS::SymbolicFactory::create_multiply(), LMCAS::SymbolicFactory::create_power(), extract_exp_multiplier(), LMCAS::detail::make_node(), LMCAS::mul(), LMCAS::op, LMCAS::pow() , 以及 rewrite_exp_as_u_power().

被这些函数引用 rewrite_exp_as_u_power().

函数调用图:

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