LMCAS::equivalence_detail 命名空间参考

命名空间
namespace	anonymous_namespace{equivalence_complex.cpp}
namespace	anonymous_namespace{equivalence_exp_log.cpp}
namespace	anonymous_namespace{equivalence_proof.cpp}
namespace	anonymous_namespace{equivalence_trig.cpp}

函数
ExprPtr	canonicalize_complex_product (const SymbolicExpr &expression, detail::RewriteBudget &budget)
bool	exact_integer_node (const detail::SymbolicNodePtr &node, int expected)
bool	exact_integer_node (const std::shared_ptr< const SymbolicNode > &node, int expected)
ExprPtr	expand_equivalence (const ExprPtr &expression, detail::RewriteBudget &budget)
ExprPtr	normalize_equivalence (const ExprPtr &expression, detail::RewriteBudget &budget)
Result< std::optional< bool > >	prove_rational_polynomial_equivalence (const ExprPtr &difference, ComputationContext &context, const EqvOptions &options, detail::RewriteBudget &budget)
ExprPtr	rewrite_exp_log_basic_identity (const detail::SymbolicNodePtr &node, const AssumptionContext *assumptions, detail::RewriteBudget &budget)
ExprPtr	rewrite_trig_basic_identity (const detail::SymbolicNodePtr &node, detail::RewriteBudget &budget)
ExprPtr	rewritten_complex (const ExprPtr &real, const ExprPtr &imag, const detail::SymbolicNodePtr &original, detail::RewriteBudget &budget)
Result< void >	validate_eqv_options (const EqvOptions &options)

函数说明

canonicalize_complex_product()

ExprPtr LMCAS::equivalence_detail::canonicalize_complex_product	(	const SymbolicExpr &	expression,
		detail::RewriteBudget &	budget )

在文件 equivalence_complex.cpp 第 157 行定义.

                                                                  {
    detail::RewriteScope scope(&budget);
    const auto& node = detail::node(expression);
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        return canonicalize_sum(*add, node, budget);
    }
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        return canonicalize_power(*power, node, budget);
    }
    if (auto complex = std::dynamic_pointer_cast<const ComplexNode>(node)) {
        auto real = canonicalize_complex_product(
            *detail::make_expression_ptr(complex->real()), budget);
        auto imag = canonicalize_complex_product(
            *detail::make_expression_ptr(complex->imag()), budget);
        return rewritten_complex(real, imag, node, budget);
    }
    if (auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        return canonicalize_product(*multiply, node, budget);
    }
    budget.measure(node);
    return detail::make_expression_ptr(node);
}

引用了 LMCAS::add(), canonicalize_complex_product(), LMCAS::complex(), LMCAS::imag, LMCAS::detail::make_expression_ptr(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::node(), LMCAS::real() , 以及 rewritten_complex().

被这些函数引用 canonicalize_complex_product(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::canonicalize_power(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::canonicalize_product(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::canonicalize_sum(), exact_integer_node() , 以及 LMCAS::anonymous_namespace{equivalence_engine.cpp}::prove_operands().

函数调用图:

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

exact_integer_node() [1/2]

bool LMCAS::equivalence_detail::exact_integer_node	(	const detail::SymbolicNodePtr &	node,
		int	expected )

引用了 canonicalize_complex_product(), LMCAS::context, exact_integer_node(), expand_equivalence(), LMCAS::imag, normalize_equivalence(), LMCAS::options, prove_rational_polynomial_equivalence(), LMCAS::real(), rewrite_exp_log_basic_identity(), rewrite_trig_basic_identity() , 以及 rewritten_complex().

函数调用图:

exact_integer_node() [2/2]

bool LMCAS::equivalence_detail::exact_integer_node	(	const std::shared_ptr< const SymbolicNode > &	node,
		int	expected )

在文件 equivalence_options.cpp 第 20 行定义.

                                      {
    auto number = std::dynamic_pointer_cast<const NumberNode>(node);
    if (!number) return false;
    if (std::holds_alternative<BigInt>(number->value())) {
        return std::get<BigInt>(number->value()) == BigInt(expected);
    }
    return std::get<Rational>(number->value()) == Rational(expected);
}

引用了 exact_integer_node().

被这些函数引用 exact_integer_node(), exact_integer_node(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_exp_log.cpp}::rewrite_exp_log_function(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_exp_log.cpp}::rewrite_negative_lambert_exponential(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_trig.cpp}::trig_square() , 以及 LMCAS::equivalence_detail::anonymous_namespace{equivalence_trig.cpp}::unwrap_trig_negated_argument().

函数调用图:

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

expand_equivalence()

ExprPtr LMCAS::equivalence_detail::expand_equivalence	(	const ExprPtr &	expression,
		detail::RewriteBudget &	budget )

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

                                                                                   {
    if (!expression || !detail::node(expression)) {
        throw CasError{CasErrc::InternalInvariant,
                       "equivalence expansion returned null", kEquivalentOperation};
    }
    auto result = detail::make_expression_ptr(
        detail::expand_node(detail::node(expression), budget));
    return result;
}

引用了 expand_equivalence(), LMCAS::detail::expand_node(), LMCAS::InternalInvariant, LMCAS::kEquivalentOperation, LMCAS::detail::make_expression_ptr() , 以及 LMCAS::detail::node().

被这些函数引用 exact_integer_node(), expand_equivalence() , 以及 prove_rational_polynomial_equivalence().

函数调用图:

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

normalize_equivalence()

ExprPtr LMCAS::equivalence_detail::normalize_equivalence	(	const ExprPtr &	expression,
		detail::RewriteBudget &	budget )

在文件 equivalence_engine.cpp 第 16 行定义.

                                                                                      {
    if (!expression || !detail::node(expression)) {
        throw CasError{CasErrc::InternalInvariant,
                       "equivalence normalization returned null", kEquivalentOperation};
    }
    auto result = detail::make_expression_ptr(
        detail::normalize_node(detail::node(expression), budget));
    return result;
}

引用了 LMCAS::InternalInvariant, LMCAS::kEquivalentOperation, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), normalize_equivalence() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::ComplexProduct::accumulate(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::apply_profile(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::canonicalize_power(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::canonicalize_product(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::canonicalize_sum(), exact_integer_node(), normalize_equivalence(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prove_operands(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_exp_log.cpp}::rewrite_negative_lambert_exponential() , 以及 rewritten_complex().

函数调用图:

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

prove_rational_polynomial_equivalence()

Result< std::optional< bool > > LMCAS::equivalence_detail::prove_rational_polynomial_equivalence	(	const ExprPtr &	difference,
		ComputationContext &	context,
		const EqvOptions &	options,
		detail::RewriteBudget &	budget )

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

                                                            {
    if (!difference) {
        return Result<std::optional<bool>>::failure(
            CasErrc::InternalInvariant,
            "equivalence difference is null",
            kEquivalentOperation);
    }
 
    if (options.budget.max_rewrite_steps < 4) {
        return Result<std::optional<bool>>::failure(
            CasErrc::ResourceLimit,
            "equivalence rewrite budget exhausted before polynomial normalization",
            kEquivalentOperation);
    }
 
    auto step = context.consume_steps(4, kEquivalentOperation);
    if (!step) { return Result<std::optional<bool>>::failure(step.error()); }
 
    std::set<std::string> variables;
    if (!collect_polynomial_variable_names(
            LMCAS::detail::node(difference), variables, budget)) {
        return Result<std::optional<bool>>::success(std::nullopt);
    }
    if (variables.size() > 1) {
        auto expanded = expand_equivalence(difference, budget);
        const auto value = detail::exact_rational_value(detail::node(expanded));
        return Result<std::optional<bool>>::success(
            value && value->is_zero() ? std::optional<bool>{true} : std::nullopt);
    }
    const std::string variable = variables.empty() ? "x" : *variables.begin();
    auto recognized = recognize_rational_polynomial(*difference, variable, context);
    if (!recognized) {
        return Result<std::optional<bool>>::failure(recognized.error());
    }
    if (!recognized.value()) {
        return Result<std::optional<bool>>::success(std::nullopt);
    }
    return Result<std::optional<bool>>::success(recognized.value()->is_zero());
}

引用了 LMCAS::context, LMCAS::detail::exact_rational_value(), expand_equivalence(), LMCAS::InternalInvariant, LMCAS::kEquivalentOperation, LMCAS::detail::node(), LMCAS::options, prove_rational_polynomial_equivalence(), LMCAS::recognize_rational_polynomial(), LMCAS::ResourceLimit, LMCAS::value , 以及 LMCAS::variable.

被这些函数引用 exact_integer_node(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prove_operands() , 以及 prove_rational_polynomial_equivalence().

函数调用图:

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

rewrite_exp_log_basic_identity()

ExprPtr LMCAS::equivalence_detail::rewrite_exp_log_basic_identity	(	const detail::SymbolicNodePtr &	node,
		const AssumptionContext *	assumptions,
		detail::RewriteBudget &	budget )

在文件 equivalence_exp_log.cpp 第 109 行定义.

                                                                    {
    if (!node) { return nullptr; }
    detail::RewriteScope scope(&budget);
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        return detail::make_expression_ptr(SymbolicFactory::create_add(
            rewrite_operands(add->operands(), assumptions, budget), &budget));
    }
    if (auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        return detail::make_expression_ptr(SymbolicFactory::create_multiply(
            rewrite_operands(multiply->operands(), assumptions, budget), &budget));
    }
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        auto base = rewrite_exp_log_basic_identity(power->base(), assumptions, budget);
        auto exponent = rewrite_exp_log_basic_identity(power->exponent(), assumptions, budget);
        budget.append_size(budget.append_size(1, budget.measure(detail::node(base))),
                           budget.measure(detail::node(exponent)));
        return SymbolicExpr::power(base, exponent);
    }
    if (auto function = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        return rewrite_exp_log_function(*function, assumptions, budget);
    }
    if (auto complex_node = std::dynamic_pointer_cast<const ComplexNode>(node)) {
        auto real = rewrite_exp_log_basic_identity(complex_node->real(), assumptions, budget);
        auto imag = rewrite_exp_log_basic_identity(complex_node->imag(), assumptions, budget);
        return rewritten_complex(real, imag, node, budget);
    }
    budget.measure(node);
    return detail::make_expression_ptr(node);
}

引用了 LMCAS::add(), LMCAS::detail::RewriteBudget::append_size(), LMCAS::SymbolicFactory::create_add(), LMCAS::SymbolicFactory::create_multiply(), LMCAS::exponent, LMCAS::function(), LMCAS::imag, LMCAS::detail::make_expression_ptr(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::node(), LMCAS::real(), rewrite_exp_log_basic_identity() , 以及 rewritten_complex().

被这些函数引用 LMCAS::anonymous_namespace{equivalence_engine.cpp}::apply_profile(), exact_integer_node(), rewrite_exp_log_basic_identity() , 以及 LMCAS::equivalence_detail::anonymous_namespace{equivalence_exp_log.cpp}::rewrite_operands().

函数调用图:

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

rewrite_trig_basic_identity()

ExprPtr LMCAS::equivalence_detail::rewrite_trig_basic_identity	(	const detail::SymbolicNodePtr &	node,
		detail::RewriteBudget &	budget )

在文件 equivalence_trig.cpp 第 167 行定义.

                                                                  {
    if (!node) { return nullptr; }
    detail::RewriteScope scope(&budget);
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        return rewrite_trig_sum(*add, budget);
    }
    if (auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        return detail::make_expression_ptr(SymbolicFactory::create_multiply(
            rewrite_operands(multiply->operands(), budget), &budget));
    }
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        auto base = rewrite_trig_basic_identity(power->base(), budget);
        auto exponent = rewrite_trig_basic_identity(power->exponent(), budget);
        budget.append_size(budget.append_size(1, budget.measure(detail::node(base))),
                           budget.measure(detail::node(exponent)));
        return SymbolicExpr::power(base, exponent);
    }
    if (auto function = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        return rewrite_trig_function(*function, budget);
    }
    if (auto complex_node = std::dynamic_pointer_cast<const ComplexNode>(node)) {
        auto real = rewrite_trig_basic_identity(complex_node->real(), budget);
        auto imag = rewrite_trig_basic_identity(complex_node->imag(), budget);
        return rewritten_complex(real, imag, node, budget);
    }
    budget.measure(node);
    return detail::make_expression_ptr(node);
}

引用了 LMCAS::add(), LMCAS::detail::RewriteBudget::append_size(), LMCAS::SymbolicFactory::create_multiply(), LMCAS::exponent, LMCAS::function(), LMCAS::imag, LMCAS::detail::make_expression_ptr(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::node(), LMCAS::real(), rewrite_trig_basic_identity() , 以及 rewritten_complex().

被这些函数引用 LMCAS::anonymous_namespace{equivalence_engine.cpp}::apply_profile(), exact_integer_node(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_trig.cpp}::rewrite_operands() , 以及 rewrite_trig_basic_identity().

函数调用图:

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

rewritten_complex()

ExprPtr LMCAS::equivalence_detail::rewritten_complex	(	const ExprPtr &	real,
		const ExprPtr &	imag,
		const detail::SymbolicNodePtr &	original,
		detail::RewriteBudget &	budget )

在文件 equivalence_complex.cpp 第 11 行定义.

                                                        {
    budget.append_size(budget.append_size(1, budget.measure(detail::node(real))),
                       budget.measure(detail::node(imag)));
    ExprPtr value;
    try {
        value = detail::make_expression_ptr(SymbolicFactory::create_complex(
            detail::node(real), detail::node(imag)));
    } catch (const std::invalid_argument&) {
        return detail::make_expression_ptr(original);
    }
    return normalize_equivalence(value, budget);
}

引用了 LMCAS::detail::RewriteBudget::append_size(), LMCAS::SymbolicFactory::create_complex(), LMCAS::imag, LMCAS::detail::make_expression_ptr(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::node(), normalize_equivalence(), LMCAS::real(), rewritten_complex() , 以及 LMCAS::value.

被这些函数引用 canonicalize_complex_product(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::canonicalize_product(), exact_integer_node(), rewrite_exp_log_basic_identity(), rewrite_trig_basic_identity() , 以及 rewritten_complex().

函数调用图:

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

validate_eqv_options()

Result< void > LMCAS::equivalence_detail::validate_eqv_options

(

const EqvOptions &

options

)

在文件 equivalence_options.cpp 第 8 行定义.

                                                             {
    if (options.budget.max_rewrite_steps == 0 ||
        options.budget.max_rewrite_depth == 0 ||
        options.budget.max_node_growth_factor == 0) {
        return Result<void>::failure(
            CasErrc::ResourceLimit,
            "equivalence rewrite budget exhausted before normalization",
            kEquivalentOperation);
    }
    return Result<void>::success();
}

引用了 LMCAS::Result< T >::failure(), LMCAS::kEquivalentOperation, LMCAS::options, LMCAS::ResourceLimit, LMCAS::Result< T >::success() , 以及 validate_eqv_options().

被这些函数引用 LMCAS::anonymous_namespace{equivalence_engine.cpp}::equivalent_with_budget(), LMCAS::set_eqv_budget() , 以及 validate_eqv_options().

函数调用图:

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