命名空间
namespace	anonymous_namespace{solver_imaginary.cpp}

函数
bool	collect_denominator_factors (const std::shared_ptr< const SymbolicNode > &node, std::vector< std::shared_ptr< const SymbolicNode > > &denominator_factors, std::vector< std::shared_ptr< SymbolicExpr > > &denominator_constraints)
bool	contains_imaginary (const std::shared_ptr< SymbolicExpr > &expression)
lmmc_real_t	finite_midpoint (lmmc_real_t lower, lmmc_real_t upper)
bool	is_polynomial_node (const std::shared_ptr< const SymbolicNode > &node)
std::shared_ptr< SymbolicExpr >	multiply_no_expand (const std::shared_ptr< const SymbolicNode > &term, const std::vector< std::shared_ptr< const SymbolicNode > > &denominator_factors)
std::map< std::string, SymbolicExpr >	project_unconditional_linear_system (const std::vector< SymbolicExpr > &equations, const std::vector< std::string > &variables, ComputationContext &context)
std::map< std::string, SymbolicExpr >	solve_linear_system_impl (const std::vector< SymbolicExpr > &equations, const std::vector< std::string > &variables, ComputationContext &context)
bool	solver_number_value (const NumberNode &number, double &value)
std::shared_ptr< SymbolicExpr >	to_ptr (const SymbolicExpr &expression)

函数说明

◆ collect_denominator_factors()

bool LMCAS::solver_detail::collect_denominator_factors	(	const std::shared_ptr< const SymbolicNode > &	node,
		std::vector< std::shared_ptr< const SymbolicNode > > &	denominator_factors,
		std::vector< std::shared_ptr< SymbolicExpr > > &	denominator_constraints )

在文件 solver_linear.cpp 第 225 行定义.

  {
    if (!node) {
        return false;
    }
 
    if (std::dynamic_pointer_cast<const NumberNode>(node) || std::dynamic_pointer_cast<const VariableNode>(node)) {
        return true;
    }
 
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        return collect_operand_denominators(add->operands(), den_factors, den_constraints);
    }
 
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        return collect_operand_denominators(mul->operands(), den_factors, den_constraints);
    }
 
    if (auto pow = std::dynamic_pointer_cast<const PowerNode>(node)) {
        return collect_power_denominators(*pow, den_factors, den_constraints);
    }
 
    if (auto func = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        return collect_operand_denominators(func->arguments(), den_factors, den_constraints);
    }
 
    return false;
}

引用了 LMCAS::add(), LMCAS::collect_operand_denominators(), LMCAS::collect_power_denominators(), LMCAS::mul() , 以及 LMCAS::pow().

被这些函数引用 LMCAS::anonymous_namespace{solver_groebner_system.cpp}::clear_denominators(), LMCAS::collect_operand_denominators() , 以及 LMCAS::collect_power_denominators().

函数调用图:

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

◆ contains_imaginary()

bool LMCAS::solver_detail::contains_imaginary ( const std::shared_ptr< SymbolicExpr > & expression )

在文件 solver_imaginary.cpp 第 226 行定义.

                                                                 {
    if (!expr || !LMCAS::detail::node(expr)) {
        return false;
    }
    ContainsImaginaryVisitor visitor;
    LMCAS::detail::node(expr)->accept(visitor);
    return visitor.found;
}

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

被这些函数引用 contains_imaginary() , 以及 LMCAS::solution_is_excluded().

函数调用图:

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

◆ finite_midpoint()

lmmc_real_t LMCAS::solver_detail::finite_midpoint	(	lmmc_real_t	lower,
		lmmc_real_t	upper )

inline

在文件 solver_support.hpp 第 9 行定义.

                                                                         {
    if (lower < 0.0 && upper > 0.0) {
        return lower * 0.5 + upper * 0.5;
    }
    return lower + (upper - lower) * 0.5;
}

引用了 finite_midpoint(), LMCAS::lower , 以及 LMCAS::upper.

被这些函数引用 finite_midpoint(), LMCAS::detail::anonymous_namespace{mixed_transcendental_refinement.cpp}::RootRefinement::midpoint() , 以及 LMCAS::anonymous_namespace{newton_raphson.cpp}::solve_isolated_polynomial().

函数调用图:

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

◆ is_polynomial_node()

bool LMCAS::solver_detail::is_polynomial_node ( const std::shared_ptr< const SymbolicNode > & node )

在文件 solver_linear.cpp 第 141 行定义.

                                                                                    {
    if (!node) {
        return false;
    }
    if (std::dynamic_pointer_cast<const NumberNode>(node)) {
        return true;
    }
    if (std::dynamic_pointer_cast<const VariableNode>(node)) {
        return true;
    }
 
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        for (const auto& op : add->operands()) {
            if (!is_polynomial_node(op)) {
                return false;
            }
        }
        return true;
    }
 
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        for (const auto& op : mul->operands()) {
            if (!is_polynomial_node(op)) {
                return false;
            }
        }
        return true;
    }
 
    if (auto pow = std::dynamic_pointer_cast<const PowerNode>(node)) {
        BigInt exp(0);
        if (!get_integer_value(pow->exponent(), exp)) {
            return false;
        }
        if (exp < 0) {
            return false;
        }
        return is_polynomial_node(pow->base());
    }
 
    return false;
}

引用了 LMCAS::add(), LMCAS::exp(), LMCAS::get_integer_value(), is_polynomial_node(), LMCAS::mul(), LMCAS::op , 以及 LMCAS::pow().

被这些函数引用 LMCAS::anonymous_namespace{solver_groebner_system.cpp}::clear_denominators(), LMCAS::collect_power_denominators() , 以及 is_polynomial_node().

函数调用图:

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

◆ multiply_no_expand()

std::shared_ptr< SymbolicExpr > LMCAS::solver_detail::multiply_no_expand	(	const std::shared_ptr< const SymbolicNode > &	term,
		const std::vector< std::shared_ptr< const SymbolicNode > > &	denominator_factors )

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

  {
    std::vector<std::shared_ptr<const SymbolicNode>> factors;
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(term)) {
        factors.insert(factors.end(), mul->operands().begin(), mul->operands().end());
    } else if (term) {
        factors.push_back(term);
    }
    factors.insert(factors.end(), den_factors.begin(), den_factors.end());
 
    std::shared_ptr<const NumberNode> const_acc =
        LMCAS::detail::make_node<NumberNode>(BigInt(1));
    std::map<std::shared_ptr<const SymbolicNode>, std::shared_ptr<const NumberNode>, NodeLess> bases;
 
    for (const auto& op : factors) {
        if (!op) {
            continue;
        }
        if (auto num = std::dynamic_pointer_cast<const NumberNode>(op)) {
            const_acc = multiply_number_nodes(const_acc, num);
            continue;
        }
 
        std::shared_ptr<const SymbolicNode> base = op;
        std::shared_ptr<const NumberNode> exp = LMCAS::detail::make_node<NumberNode>(BigInt(1));
        if (auto pow = std::dynamic_pointer_cast<const PowerNode>(op)) {
            base = pow->base();
            if (auto e_num = std::dynamic_pointer_cast<const NumberNode>(pow->exponent())) {
                exp = e_num;
            }
        }
 
        auto it = bases.find(base);
        if (it == bases.end()) {
            bases[base] = exp;
        } else {
            bases[base] = add_number_nodes(it->second, exp);
        }
    }
 
    std::vector<std::shared_ptr<const SymbolicNode>> final_ops;
    if (!const_acc->is_one()) final_ops.push_back(const_acc);
 
    for (const auto& [base, exp] : bases) {
        if (exp->is_zero()) {
            continue;
        }
        if (exp->is_one()) final_ops.push_back(base);
        else final_ops.push_back(LMCAS::detail::make_node<PowerNode>(base, exp));
    }
 
    if (final_ops.empty()) {
        return SymbolicExpr::number(1);
    }
    if (final_ops.size() == 1) {
        return LMCAS::detail::make_expression_ptr(final_ops[0]);
    }
    return LMCAS::detail::make_expression_ptr(LMCAS::detail::make_node<MultiplyNode>(final_ops));
}

引用了 LMCAS::add_number_nodes(), LMCAS::exp(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::mul(), LMCAS::multiply_number_nodes(), LMCAS::polynomial_solver_detail::num(), LMCAS::op , 以及 LMCAS::pow().

被这些函数引用 LMCAS::anonymous_namespace{solver_groebner_system.cpp}::clear_denominators().

函数调用图:

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

◆ project_unconditional_linear_system()

std::map< std::string, SymbolicExpr > LMCAS::solver_detail::project_unconditional_linear_system	(	const std::vector< SymbolicExpr > &	equations,
		const std::vector< std::string > &	variables,
		ComputationContext &	context )

在文件 solver_linear.cpp 第 298 行定义.

                                                                        {
    try {
        return solve_linear_system_impl(equations, variables, context);
    } catch (const CasError& error) {
        // 容器接口以空映射表示求解未决；受检算法保留内部错误分类。
        if (error.code == CasErrc::Inconclusive ||
            error.code == CasErrc::UnsupportedExpression) {
            return {};
        }
        throw;
    }
}

引用了 LMCAS::CasError::code, LMCAS::context, LMCAS::Inconclusive, solve_linear_system_impl() , 以及 LMCAS::UnsupportedExpression.

函数调用图:

◆ solve_linear_system_impl()

std::map< std::string, SymbolicExpr > LMCAS::solver_detail::solve_linear_system_impl	(	const std::vector< SymbolicExpr > &	equations,
		const std::vector< std::string > &	variables,
		ComputationContext &	context )

在文件 solver_linear.cpp 第 313 行定义.

                                                                        {
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                            context.limits().max_ast_nodes, "solve_linear_system");
 
    size_t num_vars = variables.size();
    size_t num_eqs = equations_in.size();
 
    std::vector<std::vector<std::shared_ptr<SymbolicExpr>>> matrix(num_eqs, std::vector<std::shared_ptr<SymbolicExpr>>(num_vars + 1));
 
    for (size_t i = 0; i < num_eqs; ++i) {
        SymbolicExpr current_eq = equations_in[i];
 
        SymbolicExpr constant_part = current_eq;
 
        for (size_t j = 0; j < num_vars; ++j) {
            auto [coeff, remainder] = isolate_linear_coeff(constant_part, variables[j], context);
            matrix[i][j] = LMCAS::detail::make_expression_ptr(coeff);
 
            constant_part = remainder;
        }
 
        std::vector<std::shared_ptr<const SymbolicNode>> ops;
        ops.push_back(SymbolicFactory::create_number(BigInt(-1)));
        ops.push_back(LMCAS::detail::node(constant_part));
        auto neg_const = SymbolicFactory::create_multiply(ops);
        matrix[i][num_vars] = LMCAS::detail::make_expression_ptr(neg_const);
    }
 
    detail::ExactMatrixData augmented{
        num_eqs, num_vars + 1, {}};
    augmented.entries.reserve(num_eqs * (num_vars + 1));
    for (const auto& row : matrix) {
        augmented.entries.insert(
            augmented.entries.end(), row.begin(), row.end());
    }
 
    auto solved = detail::solve_linear_exact(
        std::move(augmented), num_vars, context,
        "solve_linear_system");
    if (!solved) throw solved.error();
    if (std::holds_alternative<detail::InconsistentLinearSolution>(solved.value())) {
        return {};
    }
 
    std::vector<std::shared_ptr<SymbolicExpr>> values;
    if (auto* unique =
            std::get_if<detail::UniqueLinearSolution>(&solved.value())) {
        values = std::move(unique->values);
    } else {
        auto& parametric =
            std::get<detail::ParametricLinearSolution>(solved.value());
        values = parametric.particular;
        for (std::size_t parameter = 0;
             parameter < parametric.free_columns.size(); ++parameter) {
            auto free_variable = SymbolicExpr::variable(
                variables[parametric.free_columns[parameter]]);
            for (std::size_t column = 0; column < num_vars; ++column) {
                auto term = SymbolicExpr::multiply(
                    parametric.nullspace_basis[parameter][column],
                    free_variable);
                values[column] = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(
                    values[column], term)), transform_budget));
            }
        }
    }
 
    std::map<std::string, SymbolicExpr> solution;
    for (std::size_t column = 0; column < num_vars; ++column) {
        solution.insert_or_assign(
            variables[column], *values[column]);
    }
    return solution;
}

引用了 LMCAS::context, LMCAS::SymbolicFactory::create_multiply(), LMCAS::SymbolicFactory::create_number(), LMCAS::detail::ExactMatrixData::entries, LMCAS::isolate_linear_coeff(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 LMCAS::detail::solve_linear_exact().

被这些函数引用 LMCAS::find_extrema_impl() , 以及 project_unconditional_linear_system().

函数调用图:

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

◆ solver_number_value()

bool LMCAS::solver_detail::solver_number_value	(	const NumberNode &	number,
		double &	value )

在文件 solver_imaginary.cpp 第 6 行定义.

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

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

被这些函数引用 solver_number_value() , 以及 LMCAS::anonymous_namespace{solver_assumptions.cpp}::try_get_numeric_value().

函数调用图:

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

◆ to_ptr()

std::shared_ptr< SymbolicExpr > LMCAS::solver_detail::to_ptr ( const SymbolicExpr & expression )

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

                                                                          {
    return LMCAS::detail::make_expression_ptr(expr);
}

引用了 LMCAS::detail::make_expression_ptr().

被这些函数引用 LMCAS::anonymous_namespace{solver_groebner_system.cpp}::clear_denominators() , 以及 LMCAS::isolate_linear_coeff().

函数调用图:

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

命名空间

函数

函数说明

◆ collect_denominator_factors()

◆ contains_imaginary()

◆ finite_midpoint()

◆ is_polynomial_node()

◆ multiply_no_expand()

◆ project_unconditional_linear_system()

◆ solve_linear_system_impl()

◆ solver_number_value()

◆ to_ptr()