LMCAS::NormalizationVisitor类 参考

统一规范化数值幂。 精确操作数保留整数和有理数运算；近似求根要求指数精确等于 1/2。 有限浮点幂直接折叠，省去倒数中间值；非有限结果保留幂表达式。 更多...

#include </home/runner/work/docs/docs/LMCAS/src/internal/visitors/normalization_visitor.hpp>

类 LMCAS::NormalizationVisitor 继承关系图:

LMCAS::NormalizationVisitor 的协作图:

Public 成员函数
	NormalizationVisitor (detail::RewriteBudget &, FactsQuery &&, Domain)=delete
	NormalizationVisitor (detail::RewriteBudget &budget, const FactsQuery &facts, Domain domain)
std::shared_ptr< const SymbolicNode >	expand_product (const std::shared_ptr< const SymbolicNode > &lhs, const std::shared_ptr< const SymbolicNode > &rhs)
std::shared_ptr< const SymbolicNode >	get_result () const
void	visit (const AddNode &node) override
void	visit (const ComplexNode &node) override
void	visit (const FiniteSetNode &node) override
void	visit (const FunctionNode &node) override
void	visit (const IntegralNode &node) override
void	visit (const IntervalNode &node) override
void	visit (const LimitNode &node) override
void	visit (const LogicalNode &node) override
void	visit (const MatrixNode &node) override
void	visit (const MembershipNode &node) override
void	visit (const MultiplyNode &node) override
void	visit (const NumberNode &node) override
void	visit (const PiecewiseNode &node) override
void	visit (const PowerNode &node) override
void	visit (const ProductNode &node) override
void	visit (const QuantifierNode &node) override
void	visit (const QuantityNode &node) override
void	visit (const RelationalNode &node) override
void	visit (const RootOfNode &node) override
void	visit (const SetBuilderNode &node) override
void	visit (const SummationNode &node) override
void	visit (const TransformNode &node) override
void	visit (const UninterpretedFunctionNode &node) override
void	visit (const VariableNode &node) override

Protected 成员函数
RewriteBudget *	rewrite_budget () const noexcept

Protected 属性
int	current_depth = 0

静态 Protected 属性
static constexpr int	MAX_DEPTH = 200

Private 成员函数
bool	can_combine_nested_power (const PowerNode &inner, const std::shared_ptr< const NumberNode > &outer_exponent) const
std::shared_ptr< const SymbolicNode >	collect_expanded_product (const std::shared_ptr< const SymbolicNode > &lhs, const std::shared_ptr< const SymbolicNode > &rhs)
std::shared_ptr< const SymbolicNode >	collect_product (const std::vector< std::shared_ptr< const SymbolicNode > > &operands)
std::shared_ptr< const SymbolicNode >	collect_sum (const std::vector< std::shared_ptr< const SymbolicNode > > &operands)
void	distribute_power (const MultiplyNode &base, const std::shared_ptr< const SymbolicNode > &exponent)
std::shared_ptr< const SymbolicNode >	distribute_product (const std::shared_ptr< const SymbolicNode > &lhs, const std::shared_ptr< const SymbolicNode > &rhs)
std::shared_ptr< const SymbolicNode >	expand_complex_product (const std::shared_ptr< const SymbolicNode > &lhs, const std::shared_ptr< const SymbolicNode > &rhs)
std::shared_ptr< const NumberNode >	extract_term_coefficient (std::shared_ptr< const SymbolicNode > &term)
bool	finish_squared_norm (const SymbolicNode &node, std::shared_ptr< const SymbolicNode > &argument, bool normalize_argument)
std::shared_ptr< const SymbolicNode >	fuse_matrix_product (const std::shared_ptr< const SymbolicNode > &left, const std::shared_ptr< const SymbolicNode > &right)
std::shared_ptr< const SymbolicNode >	matrix_product_element (const MatrixNode &left, const MatrixNode &right, std::size_t row, std::size_t col)
void	merge_complex_terms (std::vector< std::shared_ptr< const SymbolicNode > > &operands)
std::shared_ptr< const SymbolicNode >	normalize_bound_body (const SymbolicNode &node)
bool	normalize_function_parity (FunctionNode::FuncType type, const std::shared_ptr< const SymbolicNode > &argument)
bool	normalize_logarithm (FunctionNode::FuncType type, const std::vector< std::shared_ptr< const SymbolicNode > > &arguments)
std::shared_ptr< const SymbolicNode >	normalize_matrix_product (const std::vector< std::shared_ptr< const SymbolicNode > > &operands)
bool	normalize_matrix_sum (const std::vector< std::shared_ptr< const SymbolicNode > > &operands)
bool	normalize_natural_logarithm (const std::shared_ptr< const SymbolicNode > &argument)
bool	normalize_nested_imaginary_power (const PowerNode &base, const std::shared_ptr< const NumberNode > &exponent)
bool	normalize_nested_power (const PowerNode &base, const std::shared_ptr< const SymbolicNode > &exponent)
bool	normalize_power_identity (const std::shared_ptr< const SymbolicNode > &base, const std::shared_ptr< const SymbolicNode > &exponent)
bool	normalize_product_power (const MultiplyNode &base, const std::shared_ptr< const SymbolicNode > &exponent)
bool	normalize_unary_function (FunctionNode::FuncType type, const std::shared_ptr< const SymbolicNode > &argument)
std::shared_ptr< const SymbolicNode >	scale_matrix (const MatrixNode &matrix, const std::shared_ptr< const NumberNode > &scalar)
void	set_result (std::shared_ptr< const SymbolicNode > candidate)
std::shared_ptr< const SymbolicNode >	simplify_assumed_absolute (const std::shared_ptr< const SymbolicNode > &argument) const
std::shared_ptr< const SymbolicNode >	simplify_assumed_square_root (const std::shared_ptr< const SymbolicNode > &argument) const
std::shared_ptr< const SymbolicNode >	try_assumption_simplify (const std::shared_ptr< const SymbolicNode > &node)
bool	try_normalize_squared_norm (const SymbolicNode &node, std::shared_ptr< const SymbolicNode > &argument)

静态 Private 成员函数
static bool	is_positive_integer_number (const std::shared_ptr< const NumberNode > &node)

Private 属性
ComputationContext &	context_
Domain	domain_ = Domain::Real
const FactsQuery &	facts_ = detail::no_facts()
std::shared_ptr< const SymbolicNode >	result
RewriteBudget *	rewrite_budget_ = nullptr

详细描述

统一规范化数值幂。 精确操作数保留整数和有理数运算；近似求根要求指数精确等于 1/2。 有限浮点幂直接折叠，省去倒数中间值；非有限结果保留幂表达式。

在文件 normalization_visitor.hpp 第 19 行定义.

构造及析构函数说明

NormalizationVisitor() [1/2]

LMCAS::NormalizationVisitor::NormalizationVisitor ( detail::RewriteBudget & budget, const FactsQuery & facts, Domain domain )

inline

在文件 normalization_visitor.hpp 第 21 行定义.

        : SymbolicVisitor(&budget), context_(budget.context()), facts_(facts),
          domain_(domain) {}

引用了 LMCAS::detail::SymbolicVisitor::SymbolicVisitor(), LMCAS::context, context_, LMCAS::domain, domain_ , 以及 facts_.

被这些函数引用 expand_complex_product(), extract_term_coefficient(), matrix_product_element(), merge_complex_terms(), normalize_bound_body(), normalize_logarithm(), normalize_natural_logarithm(), visit() , 以及 visit().

函数调用图:

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

NormalizationVisitor() [2/2]

LMCAS::NormalizationVisitor::NormalizationVisitor ( detail::RewriteBudget & , FactsQuery && , Domain  )

delete

引用了 expand_product(), get_result(), LMCAS::rhs , 以及 visit().

函数调用图:

成员函数说明

can_combine_nested_power()

bool LMCAS::NormalizationVisitor::can_combine_nested_power ( const PowerNode & inner, const std::shared_ptr< const NumberNode > & outer_exponent ) const

private

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

                                                                 {
    if (!is_positive_integer_number(outer_exponent)) {
        return false;
    }
    auto exponent = std::dynamic_pointer_cast<const NumberNode>(inner.exponent());
    if (is_positive_integer_number(exponent)) {
        return true;
    }
    if (!exponent) {
        return false;
    }
    const auto* rational = std::get_if<Rational>(&exponent->value());
    if (!rational || rational->get_numerator() <= BigInt(0)) {
        return false;
    }
    return normalization_proved(detail::query_nonnegative_value(inner.base(), facts_, context_));
}

引用了 LMCAS::PowerNode::base(), context_, LMCAS::exponent, LMCAS::PowerNode::exponent(), facts_, is_positive_integer_number(), LMCAS::normalization_proved(), LMCAS::detail::query_nonnegative_value() , 以及 LMCAS::rational().

被这些函数引用 collect_product() , 以及 normalize_nested_power().

函数调用图:

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

collect_expanded_product()

std::shared_ptr< const SymbolicNode > LMCAS::NormalizationVisitor::collect_expanded_product ( const std::shared_ptr< const SymbolicNode > & lhs, const std::shared_ptr< const SymbolicNode > & rhs )

private

在文件 normalization_products.cpp 第 247 行定义.

                                                  {
    ProductAccumulator accumulated;
    const auto process = [&](const std::shared_ptr<const SymbolicNode>& factor) {
        if (accumulated.add_number(factor)) {
            return;
        }
        auto base = factor;
        auto exponent = collectable_power_exponent(factor, base, facts_, domain_, context_);
        accumulated.add_base(factor, base, exponent, rewrite_budget());
    };
    for (const auto* node : {&lhs, &rhs}) {
        const auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(*node);
        if (!multiply) {
            process(*node);
            continue;
        }
        for (const auto& operand : multiply->operands()) {
            process(operand);
        }
    }
    return accumulated.finish(facts_, domain_, context_, true, rewrite_budget());
}

引用了 context_, domain_, LMCAS::exponent, facts_, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 LMCAS::rhs.

被这些函数引用 expand_product().

函数调用图:

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

collect_product()

std::shared_ptr< const SymbolicNode > LMCAS::NormalizationVisitor::collect_product ( const std::vector< std::shared_ptr< const SymbolicNode > > & operands )

private

在文件 normalization_products.cpp 第 132 行定义.

                                                                  {
    ProductAccumulator accumulated;
    for (const auto& operand : operands) {
        if (accumulated.add_number(operand)) {
            continue;
        }
        auto base = operand;
        auto exponent = collectable_power_exponent(operand, base, facts_, domain_, context_);
        if (base == operand) {
            const auto power = std::dynamic_pointer_cast<const PowerNode>(operand);
            if (power && can_combine_nested_power(*power, exponent)) {
                base = power->base();
                exponent = std::dynamic_pointer_cast<const NumberNode>(power->exponent());
            }
        }
        accumulated.add_base(operand, base, exponent, rewrite_budget());
    }
    return accumulated.finish(facts_, domain_, context_, false, rewrite_budget());
}

引用了 can_combine_nested_power(), context_, domain_, LMCAS::exponent, facts_ , 以及 LMCAS::detail::SymbolicVisitor::rewrite_budget().

被这些函数引用 visit().

函数调用图:

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

collect_sum()

std::shared_ptr< const SymbolicNode > LMCAS::NormalizationVisitor::collect_sum ( const std::vector< std::shared_ptr< const SymbolicNode > > & operands )

private

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

                                                                  {
    auto constant = detail::make_node<NumberNode>(BigInt(0));
    struct TermAccum {
        std::shared_ptr<const NumberNode> coefficient;
        std::vector<std::shared_ptr<const SymbolicNode>> originals;
        std::size_t nodes;
    };
    std::map<std::shared_ptr<const SymbolicNode>, TermAccum, NodeCompare> terms;
    for (const auto& operand : operands) {
        if (const auto number = std::dynamic_pointer_cast<const NumberNode>(operand)) {
            constant = add_numbers(constant, number);
            continue;
        }
        auto term = operand;
        auto coefficient = extract_term_coefficient(term);
        auto found = terms.find(term);
        if (found == terms.end()) {
            const auto nodes = rewrite_budget() ? rewrite_budget()->measure(operand) : 0;
            terms.emplace(term, TermAccum{coefficient, {operand}, nodes});
        } else {
            found->second.coefficient = add_numbers(found->second.coefficient, coefficient);
            normalization_append(rewrite_budget(), found->second.nodes, found->second.originals, operand);
        }
    }
    std::vector<std::shared_ptr<const SymbolicNode>> collected;
    std::size_t nodes = 0;
    if (!constant->is_zero()) {
        normalization_append(rewrite_budget(), nodes, collected, constant);
    }
    for (const auto& [term, accumulated] : terms) {
        if (!accumulated.coefficient->is_zero()) {
            normalization_append(rewrite_budget(), nodes, collected,
                                 weighted_term(term, accumulated.coefficient, rewrite_budget()));
        } else if (!normalization_can_discard(term, facts_, domain_, context_)) {
            for (const auto& original : accumulated.originals) {
                normalization_append(rewrite_budget(), nodes, collected, original);
            }
        }
    }
    if (collected.empty()) {
        return detail::make_node<NumberNode>(BigInt(0));
    }
    if (collected.size() == 1) {
        return collected.front();
    }
    normalization_check_arithmetic<AddNode>(rewrite_budget(), collected, nodes);
    std::sort(collected.begin(), collected.end(), sum_term_less);
    return detail::make_node<AddNode>(collected);
}

引用了 LMCAS::add_numbers(), context_, domain_, extract_term_coefficient(), facts_, LMCAS::detail::make_node(), LMCAS::detail::RewriteBudget::measure(), LMCAS::normalization_append(), LMCAS::normalization_can_discard(), LMCAS::normalization_check_arithmetic() , 以及 LMCAS::detail::SymbolicVisitor::rewrite_budget().

被这些函数引用 visit().

函数调用图:

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

distribute_power()

void LMCAS::NormalizationVisitor::distribute_power ( const MultiplyNode & base, const std::shared_ptr< const SymbolicNode > & exponent )

private

在文件 normalization_powers.cpp 第 70 行定义.

                                                                                 {
    std::vector<std::shared_ptr<const SymbolicNode>> operands;
    std::size_t nodes = 0;
    normalization_check_count(rewrite_budget(), base.operands().size(), 1, false);
    for (const auto& operand : base.operands()) {
        normalization_check_children(rewrite_budget(), 1, operand, exponent);
        detail::make_node<PowerNode>(operand, exponent)->accept(*this);
        if (const auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(result)) {
            for (const auto& child : multiply->operands()) {
                normalization_append(rewrite_budget(), nodes, operands, child);
            }
        } else {
            normalization_append(rewrite_budget(), nodes, operands, result);
        }
    }
    make_normalized_multiply_node(operands, rewrite_budget())->accept(*this);
}

引用了 LMCAS::exponent, LMCAS::detail::make_node(), LMCAS::make_normalized_multiply_node(), LMCAS::normalization_append(), LMCAS::normalization_check_children(), LMCAS::normalization_check_count(), LMCAS::MultiplyNode::operands(), result , 以及 LMCAS::detail::SymbolicVisitor::rewrite_budget().

被这些函数引用 normalize_product_power().

函数调用图:

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

distribute_product()

std::shared_ptr< const SymbolicNode > LMCAS::NormalizationVisitor::distribute_product ( const std::shared_ptr< const SymbolicNode > & lhs, const std::shared_ptr< const SymbolicNode > & rhs )

private

在文件 normalization_products.cpp 第 221 行定义.

                                                  {
    const auto left = std::dynamic_pointer_cast<const AddNode>(lhs);
    const auto right = std::dynamic_pointer_cast<const AddNode>(rhs);
    std::size_t left_count = 1, right_count = 1;
    if (left) {
        left_count = left->operands().size();
    }
    if (right) {
        right_count = right->operands().size();
    }
    normalization_check_count(rewrite_budget(), left_count, right_count, false);
    std::vector<std::shared_ptr<const SymbolicNode>> terms;
    std::size_t nodes = 0;
    for (std::size_t i = 0; i < left_count; ++i) {
        const auto& a = left ? left->operands()[i] : lhs;
        for (std::size_t j = 0; j < right_count; ++j) {
            const auto& b = right ? right->operands()[j] : rhs;
            normalization_append(rewrite_budget(), nodes, terms, expand_product(a, b));
        }
    }
    normalization_check_arithmetic<AddNode>(rewrite_budget(), terms, nodes);
    return detail::make_node<AddNode>(terms);
}

引用了 LMCAS::a, LMCAS::b, expand_product(), LMCAS::detail::make_node(), LMCAS::normalization_append(), LMCAS::normalization_check_arithmetic(), LMCAS::normalization_check_count(), LMCAS::detail::SymbolicVisitor::rewrite_budget(), LMCAS::rhs , 以及 LMCAS::right.

被这些函数引用 expand_product().

函数调用图:

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

expand_complex_product()

std::shared_ptr< const SymbolicNode > LMCAS::NormalizationVisitor::expand_complex_product ( const std::shared_ptr< const SymbolicNode > & lhs, const std::shared_ptr< const SymbolicNode > & rhs )

private

在文件 normalization_products.cpp 第 173 行定义.

                                                  {
    const auto left = std::dynamic_pointer_cast<const ComplexNode>(lhs);
    const auto right = std::dynamic_pointer_cast<const ComplexNode>(rhs);
    if (!left && !right) {
        return nullptr;
    }
    std::shared_ptr<const SymbolicNode> real;
    std::shared_ptr<const SymbolicNode> imag;
    if (left && right) {
        auto ac = expand_product(left->real(), right->real());
        auto bd = expand_product(left->imag(), right->imag());
        auto ad = expand_product(left->real(), right->imag());
        auto bc = expand_product(left->imag(), right->real());
        auto negative_bd = expand_product(detail::make_node<NumberNode>(BigInt(-1)), bd);
        real = SymbolicFactory::create_add({ac, negative_bd}, rewrite_budget());
        imag = SymbolicFactory::create_add({ad, bc}, rewrite_budget());
    } else if (left) {
        real = expand_product(left->real(), rhs);
        imag = expand_product(left->imag(), rhs);
    } else {
        real = expand_product(lhs, right->real());
        imag = expand_product(lhs, right->imag());
    }
    NormalizationVisitor visitor(*rewrite_budget(), facts_, domain_);
    real->accept(visitor);
    auto normalized_real = visitor.get_result();
    imag->accept(visitor);
    normalization_check_children(rewrite_budget(), 1, normalized_real, visitor.get_result());
    return SymbolicFactory::create_complex(normalized_real, visitor.get_result());
}

引用了 NormalizationVisitor(), LMCAS::SymbolicFactory::create_add(), LMCAS::SymbolicFactory::create_complex(), domain_, expand_product(), facts_, get_result(), LMCAS::imag, LMCAS::detail::make_node(), LMCAS::normalization_check_children(), LMCAS::real(), LMCAS::detail::SymbolicVisitor::rewrite_budget(), LMCAS::rhs , 以及 LMCAS::right.

被这些函数引用 expand_product().

函数调用图:

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

expand_product()

std::shared_ptr< const SymbolicNode > LMCAS::NormalizationVisitor::expand_product	(	const std::shared_ptr< const SymbolicNode > &	lhs,
		const std::shared_ptr< const SymbolicNode > &	rhs )

在文件 normalization_products.cpp 第 206 行定义.

                                                  {
    detail::RewriteScope scope(rewrite_budget());
    if (auto complex = expand_complex_product(lhs, rhs)) {
        return complex;
    }
    const auto left = std::dynamic_pointer_cast<const AddNode>(lhs);
    const auto right = std::dynamic_pointer_cast<const AddNode>(rhs);
    if (left || right) {
        return distribute_product(lhs, rhs);
    }
    return collect_expanded_product(lhs, rhs);
}

引用了 collect_expanded_product(), LMCAS::complex(), distribute_product(), expand_complex_product(), LMCAS::detail::SymbolicVisitor::rewrite_budget(), LMCAS::rhs , 以及 LMCAS::right.

被这些函数引用 NormalizationVisitor(), distribute_product(), expand_complex_product(), LMCAS::ExpandVisitor::visit() , 以及 LMCAS::ExpandVisitor::visit().

函数调用图:

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

extract_term_coefficient()

std::shared_ptr< const NumberNode > LMCAS::NormalizationVisitor::extract_term_coefficient ( std::shared_ptr< const SymbolicNode > & term )

private

在文件 normalization_arithmetic.cpp 第 107 行定义.

                                             {
    auto coefficient = detail::make_node<NumberNode>(BigInt(1));
    const auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(term);
    if (!multiply || multiply->operands().empty()) {
        return coefficient;
    }
    const auto& operands = multiply->operands();
    auto number = std::dynamic_pointer_cast<const NumberNode>(operands.front());
    std::size_t index = 0;
    if (!number) {
        number = std::dynamic_pointer_cast<const NumberNode>(operands.back());
        index = operands.size() - 1;
    }
    if (!number) {
        return coefficient;
    }
    coefficient = number;
    if (operands.size() == 2) {
        term = operands[index == 0 ? 1 : 0];
        return coefficient;
    }
    std::vector<std::shared_ptr<const SymbolicNode>> rest;
    std::size_t nodes = 0;
    normalization_check_count(rewrite_budget(), operands.size() - 1, 1, false);
    rest.reserve(operands.size() - 1);
    for (std::size_t k = 0; k < operands.size(); ++k) {
        if (k != index) {
            normalization_append(rewrite_budget(), nodes, rest, operands[k]);
        }
    }
    auto rest_product = make_normalized_multiply_node(rest, rewrite_budget());
    NormalizationVisitor visitor(*rewrite_budget(), facts_, domain_);
    rest_product->accept(visitor);
    term = visitor.get_result();
    return coefficient;
}

引用了 NormalizationVisitor(), domain_, facts_, get_result(), LMCAS::detail::make_node(), LMCAS::make_normalized_multiply_node(), LMCAS::normalization_append(), LMCAS::normalization_check_count() , 以及 LMCAS::detail::SymbolicVisitor::rewrite_budget().

被这些函数引用 collect_sum().

函数调用图:

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

finish_squared_norm()

bool LMCAS::NormalizationVisitor::finish_squared_norm ( const SymbolicNode & node, std::shared_ptr< const SymbolicNode > & argument, bool normalize_argument )

private

在文件 normalization_norms.cpp 第 85 行定义.

                                                                                                    {
    if (normalize_argument) {
        argument->accept(*this);
        argument = result;
        return false;
    }
    if (const auto* power = dynamic_cast<const PowerNode*>(&node)) {
        normalization_check_children(rewrite_budget(), 1, argument, power->exponent());
        set_result(detail::make_node<PowerNode>(argument, power->exponent()));
    } else {
        normalization_check_children(rewrite_budget(), 1, argument);
        auto norm = detail::make_node<FunctionNode>(FunctionNode::FuncType::Sqrt,
            std::vector<std::shared_ptr<const SymbolicNode>>{argument});
        auto simplified = try_assumption_simplify(norm);
        set_result(simplified ? simplified : norm);
    }
    return true;
}

引用了 LMCAS::detail::make_node(), LMCAS::normalization_check_children(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget(), set_result(), LMCAS::FunctionNode::Sqrt , 以及 try_assumption_simplify().

被这些函数引用 try_normalize_squared_norm().

函数调用图:

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

fuse_matrix_product()

std::shared_ptr< const SymbolicNode > LMCAS::NormalizationVisitor::fuse_matrix_product ( const std::shared_ptr< const SymbolicNode > & left, const std::shared_ptr< const SymbolicNode > & right )

private

在文件 normalization_matrices.cpp 第 88 行定义.

                                                    {
    const auto a = std::dynamic_pointer_cast<const MatrixNode>(left);
    const auto b = std::dynamic_pointer_cast<const MatrixNode>(right);
    if (!a || !b) {
        return nullptr;
    }
    if (a->cols() != b->rows()) {
        return nullptr;
    }
    MatrixNode::DenseStorage elements;
    const auto count = normalization_check_count(rewrite_budget(), a->rows(), b->cols());
    std::size_t nodes = 1;
    elements.reserve(count);
    for (std::size_t row = 0; row < a->rows(); ++row) {
        for (std::size_t col = 0; col < b->cols(); ++col) {
            normalization_append(rewrite_budget(), nodes, elements,
                                 matrix_product_element(*a, *b, row, col));
        }
    }
    return detail::make_node<MatrixNode>(a->rows(), b->cols(), elements);
}

引用了 LMCAS::a, LMCAS::b, LMCAS::detail::make_node(), matrix_product_element(), LMCAS::normalization_append(), LMCAS::normalization_check_count(), LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 LMCAS::right.

被这些函数引用 normalize_matrix_product().

函数调用图:

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

get_result()

std::shared_ptr< const SymbolicNode > LMCAS::NormalizationVisitor::get_result ( ) const

nodiscard

在文件 normalization_arithmetic.cpp 第 41 行定义.

                                                                         {
    return result;
}

引用了 result.

被这些函数引用 NormalizationVisitor(), expand_complex_product(), extract_term_coefficient(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_complex_at_point(), matrix_product_element(), merge_complex_terms(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::normalize(), normalize_bound_body(), LMCAS::detail::normalize_node(), visit() , 以及 visit().

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

is_positive_integer_number()

bool LMCAS::NormalizationVisitor::is_positive_integer_number ( const std::shared_ptr< const NumberNode > & node )

staticprivate

在文件 normalization_powers.cpp 第 163 行定义.

                                                                                                 {
        BigInt value;
        return try_get_integer_value(node, value) && value > BigInt(0);
    }

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

被这些函数引用 can_combine_nested_power().

函数调用图:

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

matrix_product_element()

std::shared_ptr< const SymbolicNode > LMCAS::NormalizationVisitor::matrix_product_element ( const MatrixNode & left, const MatrixNode & right, std::size_t row, std::size_t col )

private

在文件 normalization_matrices.cpp 第 68 行定义.

                                                                                   {
    const auto* a = std::get_if<MatrixNode::DenseStorage>(&left.storage());
    const auto* b = std::get_if<MatrixNode::DenseStorage>(&right.storage());
    std::vector<std::shared_ptr<const SymbolicNode>> terms;
    std::size_t nodes = 0;
    normalization_check_count(rewrite_budget(), left.cols(), 1, false);
    terms.reserve(left.cols());
    for (std::size_t k = 0; k < left.cols(); ++k) {
        auto first = a ? (*a)[row * left.cols() + k] : matrix_element(left, row * left.cols() + k);
        auto second = b ? (*b)[k * right.cols() + col] : matrix_element(right, k * right.cols() + col);
        normalization_append(rewrite_budget(), nodes, terms,
                             make_normalized_multiply_node({first, second}, rewrite_budget()));
    }
    NormalizationVisitor visitor(*rewrite_budget(), facts_, domain_);
    normalization_check_arithmetic<AddNode>(rewrite_budget(), terms, nodes);
    detail::make_node<AddNode>(terms)->accept(visitor);
    return visitor.get_result();
}

引用了 NormalizationVisitor(), LMCAS::a, LMCAS::b, LMCAS::MatrixNode::cols(), domain_, facts_, get_result(), LMCAS::detail::make_node(), LMCAS::make_normalized_multiply_node(), LMCAS::normalization_append(), LMCAS::normalization_check_arithmetic(), LMCAS::normalization_check_count(), LMCAS::detail::SymbolicVisitor::rewrite_budget(), LMCAS::right , 以及 LMCAS::MatrixNode::storage().

被这些函数引用 fuse_matrix_product().

函数调用图:

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

merge_complex_terms()

void LMCAS::NormalizationVisitor::merge_complex_terms ( std::vector< std::shared_ptr< const SymbolicNode > > & operands )

private

在文件 normalization_arithmetic.cpp 第 70 行定义.

                                                            {
    std::vector<std::shared_ptr<const SymbolicNode>> real;
    std::vector<std::shared_ptr<const SymbolicNode>> imag;
    std::vector<std::shared_ptr<const SymbolicNode>> remaining;
    std::size_t real_nodes = 0, imag_nodes = 0, remaining_nodes = 0;
    bool has_complex = false;
    for (const auto& operand : operands) {
        if (const auto complex = std::dynamic_pointer_cast<const ComplexNode>(operand)) {
            has_complex = true;
            normalization_append(rewrite_budget(), real_nodes, real, complex->real());
            normalization_append(rewrite_budget(), imag_nodes, imag, complex->imag());
        } else if (std::dynamic_pointer_cast<const NumberNode>(operand)) {
            normalization_append(rewrite_budget(), real_nodes, real, operand);
            normalization_append(rewrite_budget(), imag_nodes, imag,
                                 SymbolicFactory::create_number(BigInt(0)));
        } else {
            normalization_append(rewrite_budget(), remaining_nodes, remaining, operand);
        }
    }
    if (!has_complex) {
        return;
    }
    auto real_sum = SymbolicFactory::create_add(real, rewrite_budget());
    auto imag_sum = SymbolicFactory::create_add(imag, rewrite_budget());
    NormalizationVisitor visitor(*rewrite_budget(), facts_, domain_);
    real_sum->accept(visitor);
    auto normalized_real = visitor.get_result();
    imag_sum->accept(visitor);
    normalization_check_children(rewrite_budget(), 1, normalized_real, visitor.get_result());
    auto merged = SymbolicFactory::create_complex(normalized_real, visitor.get_result());
    if (!merged->is_zero()) {
        normalization_append(rewrite_budget(), remaining_nodes, remaining, merged);
    }
    operands = std::move(remaining);
}

引用了 NormalizationVisitor(), LMCAS::complex(), LMCAS::SymbolicFactory::create_add(), LMCAS::SymbolicFactory::create_complex(), LMCAS::SymbolicFactory::create_number(), domain_, facts_, get_result(), LMCAS::imag, LMCAS::normalization_append(), LMCAS::normalization_check_children(), LMCAS::real() , 以及 LMCAS::detail::SymbolicVisitor::rewrite_budget().

被这些函数引用 visit().

函数调用图:

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

normalize_bound_body()

std::shared_ptr< const SymbolicNode > LMCAS::NormalizationVisitor::normalize_bound_body ( const SymbolicNode & node )

private

在文件 normalization_structural.cpp 第 9 行定义.

                              {
    const auto binder = detail::binder_view(node);
    if (&facts_ == &detail::no_facts()) {
        binder->scoped_body->accept(*this);
        return result;
    }
    const detail::ScopedFacts scoped(facts_, binder->bound_name);
    NormalizationVisitor inner(*rewrite_budget(), scoped, domain_);
    binder->scoped_body->accept(inner);
    return inner.get_result();
}

引用了 NormalizationVisitor(), LMCAS::detail::binder_view(), domain_, facts_, get_result(), LMCAS::detail::no_facts(), result , 以及 LMCAS::detail::SymbolicVisitor::rewrite_budget().

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

函数调用图:

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

normalize_function_parity()

bool LMCAS::NormalizationVisitor::normalize_function_parity ( FunctionNode::FuncType type, const std::shared_ptr< const SymbolicNode > & argument )

private

在文件 normalization_functions.cpp 第 70 行定义.

                                                                                  {
    std::shared_ptr<const SymbolicNode> positive;
    if (!check_negative_arg(argument, positive, rewrite_budget())) {
        return false;
    }
    switch (type) {
        case FunctionNode::FuncType::Sin:
        case FunctionNode::FuncType::Tan:
        case FunctionNode::FuncType::ArcTan:
        case FunctionNode::FuncType::ArcSin: {
            normalization_check_children(rewrite_budget(), 1, positive);
            auto function = detail::make_node<FunctionNode>(type,
                std::vector<std::shared_ptr<const SymbolicNode>>{positive});
            set_result(make_normalized_multiply_node(
                {detail::make_node<NumberNode>(BigInt(-1)), function}, rewrite_budget()));
            return true;
        }
        case FunctionNode::FuncType::Cos:
            normalization_check_children(rewrite_budget(), 1, positive);
            set_result(detail::make_node<FunctionNode>(type,
                std::vector<std::shared_ptr<const SymbolicNode>>{positive}));
            return true;
        default:
            return false;
    }
}

引用了 LMCAS::FunctionNode::ArcSin, LMCAS::FunctionNode::ArcTan, LMCAS::check_negative_arg(), LMCAS::FunctionNode::Cos, LMCAS::function(), LMCAS::detail::make_node(), LMCAS::make_normalized_multiply_node(), LMCAS::normalization_check_children(), LMCAS::detail::SymbolicVisitor::rewrite_budget(), set_result(), LMCAS::FunctionNode::Sin , 以及 LMCAS::FunctionNode::Tan.

被这些函数引用 normalize_unary_function().

函数调用图:

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

normalize_logarithm()

bool LMCAS::NormalizationVisitor::normalize_logarithm ( FunctionNode::FuncType type, const std::vector< std::shared_ptr< const SymbolicNode > > & arguments )

private

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

                                                                   {
    if (type == FunctionNode::FuncType::Ln && arguments.size() == 1) {
        return normalize_natural_logarithm(arguments.front());
    }
    if (type != FunctionNode::FuncType::Log || arguments.size() != 2) {
        return false;
    }
    if (const auto power = std::dynamic_pointer_cast<const PowerNode>(arguments.front())) {
        normalization_check_children(rewrite_budget(), 1, arguments[1]);
        auto logarithm = detail::make_node<FunctionNode>(FunctionNode::FuncType::Ln,
            std::vector<std::shared_ptr<const SymbolicNode>>{arguments[1]});
        if (power->base()->compare(*arguments[1]) == 0 &&
            normalization_proved(detail::query_positive_value(arguments[1], facts_, context_)) &&
            normalization_proved(detail::query_real_value(power->exponent(), facts_, context_)) &&
            normalization_proved(detail::query_nonzero_value(logarithm, facts_, Domain::Real, context_))) {
            set_result(power->exponent());
            return true;
        }
    }
    normalization_check_children(rewrite_budget(), 1, arguments[0]);
    auto numerator = detail::make_node<FunctionNode>(FunctionNode::FuncType::Ln,
        std::vector<std::shared_ptr<const SymbolicNode>>{arguments[0]});
    normalization_check_children(rewrite_budget(), 1, arguments[1]);
    auto denominator = detail::make_node<FunctionNode>(FunctionNode::FuncType::Ln,
        std::vector<std::shared_ptr<const SymbolicNode>>{arguments[1]});
    normalization_check_children(rewrite_budget(), 2, denominator);
    auto reciprocal = detail::make_node<PowerNode>(denominator, detail::make_node<NumberNode>(BigInt(-1)));
    auto quotient = make_normalized_multiply_node({numerator, reciprocal}, rewrite_budget());
    NormalizationVisitor visitor(*rewrite_budget(), facts_, domain_);
    quotient->accept(visitor);
    set_result(visitor.get_result());
    return true;
}

引用了 NormalizationVisitor(), context_, LMCAS::denominator, domain_, facts_, LMCAS::FunctionNode::Ln, LMCAS::FunctionNode::Log, LMCAS::detail::make_node(), LMCAS::make_normalized_multiply_node(), LMCAS::normalization_check_children(), LMCAS::normalization_proved(), normalize_natural_logarithm(), LMCAS::detail::query_nonzero_value(), LMCAS::detail::query_positive_value(), LMCAS::detail::query_real_value(), LMCAS::Real, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

被这些函数引用 visit().

函数调用图:

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

normalize_matrix_product()

std::shared_ptr< const SymbolicNode > LMCAS::NormalizationVisitor::normalize_matrix_product ( const std::vector< std::shared_ptr< const SymbolicNode > > & operands )

private

在文件 normalization_matrices.cpp 第 128 行定义.

                                                                  {
    std::vector<std::shared_ptr<const SymbolicNode>> nonscalar;
    std::size_t nonscalar_nodes = 0;
    auto scalar = detail::make_node<NumberNode>(BigInt(1));
    for (const auto& operand : operands) {
        if (const auto number = std::dynamic_pointer_cast<const NumberNode>(operand)) {
            scalar = multiply_numbers(scalar, number);
        } else {
            normalization_append(rewrite_budget(), nonscalar_nodes, nonscalar, operand);
        }
    }
    std::vector<std::shared_ptr<const SymbolicNode>> fused;
    std::size_t fused_nodes = 0;
    std::size_t last_nodes = 0;
    if (!nonscalar.empty()) {
        normalization_append(rewrite_budget(), fused_nodes, fused, nonscalar.front());
        last_nodes = fused_nodes;
    }
    for (std::size_t i = 1; i < nonscalar.size(); ++i) {
        if (auto product = fuse_matrix_product(fused.back(), nonscalar[i])) {
            if (rewrite_budget()) {
                const auto replacement_nodes = rewrite_budget()->measure(product);
                fused_nodes = rewrite_budget()->append_size(fused_nodes - last_nodes, replacement_nodes);
                last_nodes = replacement_nodes;
            }
            fused.back() = std::move(product);
        } else {
            const auto previous_nodes = fused_nodes;
            normalization_append(rewrite_budget(), fused_nodes, fused, nonscalar[i]);
            last_nodes = fused_nodes - previous_nodes;
        }
    }
    if (fused.size() == 1 && !scalar->is_one()) {
        if (const auto matrix = std::dynamic_pointer_cast<const MatrixNode>(fused.front())) {
            return scale_matrix(*matrix, scalar);
        }
    }
    if (!scalar->is_one()) {
        if (rewrite_budget()) { (void)rewrite_budget()->append_size(fused_nodes, 1); }
        fused.insert(fused.begin(), scalar);
    }
    return make_normalized_multiply_node(fused, rewrite_budget());
}

引用了 LMCAS::detail::RewriteBudget::append_size(), fuse_matrix_product(), LMCAS::detail::make_node(), LMCAS::make_normalized_multiply_node(), LMCAS::detail::RewriteBudget::measure(), LMCAS::multiply_numbers(), LMCAS::normalization_append(), LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 scale_matrix().

被这些函数引用 visit().

函数调用图:

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

normalize_matrix_sum()

bool LMCAS::NormalizationVisitor::normalize_matrix_sum ( const std::vector< std::shared_ptr< const SymbolicNode > > & operands )

private

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

                                                                  {
    if (operands.empty()) {
        return false;
    }
    const auto first = std::dynamic_pointer_cast<const MatrixNode>(operands.front());
    if (!first) {
        return false;
    }
    const auto rows = first->rows();
    const auto cols = first->cols();
    if (!matching_matrix_shapes(operands, rows, cols)) {
        return false;
    }
    MatrixNode::DenseStorage elements;
    const auto count = normalization_check_count(rewrite_budget(), rows, cols);
    std::size_t nodes = 1;
    elements.reserve(count);
    for (std::size_t i = 0; i < count; ++i) {
        std::vector<std::shared_ptr<const SymbolicNode>> terms;
        std::size_t term_nodes = 0;
        normalization_check_count(rewrite_budget(), operands.size(), 1, false);
        for (const auto& operand : operands) {
            const auto matrix = std::dynamic_pointer_cast<const MatrixNode>(operand);
            normalization_append(rewrite_budget(), term_nodes, terms, matrix_element(*matrix, i));
        }
        normalization_check_arithmetic<AddNode>(rewrite_budget(), terms, term_nodes);
        detail::make_node<AddNode>(terms)->accept(*this);
        normalization_append(rewrite_budget(), nodes, elements, result);
    }
    set_result(detail::make_node<MatrixNode>(rows, cols, elements));
    return true;
}

引用了 LMCAS::detail::make_node(), LMCAS::normalization_append(), LMCAS::normalization_check_arithmetic(), LMCAS::normalization_check_count(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

被这些函数引用 visit().

函数调用图:

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

normalize_natural_logarithm()

bool LMCAS::NormalizationVisitor::normalize_natural_logarithm ( const std::shared_ptr< const SymbolicNode > & argument )

private

在文件 normalization_functions.cpp 第 42 行定义.

                                                       {
    if (const auto power = std::dynamic_pointer_cast<const PowerNode>(argument)) {
        if (!normalization_proved(detail::query_positive_value(power->base(), facts_, context_)) ||
            !normalization_proved(detail::query_real_value(power->exponent(), facts_, context_))) {
            return false;
        }
        normalization_check_children(rewrite_budget(), 1, power->base());
        auto logarithm = detail::make_node<FunctionNode>(FunctionNode::FuncType::Ln,
            std::vector<std::shared_ptr<const SymbolicNode>>{power->base()});
        auto product = make_normalized_multiply_node({power->exponent(), logarithm}, rewrite_budget());
        NormalizationVisitor visitor(*rewrite_budget(), facts_, domain_);
        product->accept(visitor);
        set_result(visitor.get_result());
        return true;
    }
    const auto function = std::dynamic_pointer_cast<const FunctionNode>(argument);
    if (!function || function->type() != FunctionNode::FuncType::Exp) {
        return false;
    }
    if (function->arguments().size() != 1 ||
        !normalization_proved(detail::query_real_value(function->arguments().front(), facts_, context_))) {
        return false;
    }
    set_result(function->arguments().front());
    return true;
}

引用了 NormalizationVisitor(), context_, domain_, LMCAS::FunctionNode::Exp, facts_, LMCAS::function(), LMCAS::FunctionNode::Ln, LMCAS::detail::make_node(), LMCAS::make_normalized_multiply_node(), LMCAS::normalization_check_children(), LMCAS::normalization_proved(), LMCAS::detail::query_positive_value(), LMCAS::detail::query_real_value(), LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

被这些函数引用 normalize_logarithm().

函数调用图:

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

normalize_nested_imaginary_power()

bool LMCAS::NormalizationVisitor::normalize_nested_imaginary_power ( const PowerNode & base, const std::shared_ptr< const NumberNode > & exponent )

private

在文件 normalization_powers.cpp 第 89 行定义.

                                                                            {
    BigInt integer;
    if (!try_get_integer_value(exponent, integer)) {
        return false;
    }
    const auto inner_base = std::dynamic_pointer_cast<const NumberNode>(base.base());
    if (!inner_base || !inner_base->is_negative_one()) {
        return false;
    }
    const auto inner_exponent = std::dynamic_pointer_cast<const NumberNode>(base.exponent());
    if (!inner_exponent) {
        return false;
    }
    const auto* rational = std::get_if<Rational>(&inner_exponent->value());
    if (!rational || *rational != Rational(1, 2)) {
        return false;
    }
    set_result(normalization_imaginary_power(integer, rewrite_budget()));
    return true;
}

引用了 LMCAS::PowerNode::base(), LMCAS::exponent, LMCAS::PowerNode::exponent(), LMCAS::integer, LMCAS::normalization_imaginary_power(), LMCAS::rational(), LMCAS::detail::SymbolicVisitor::rewrite_budget(), set_result() , 以及 LMCAS::try_get_integer_value().

被这些函数引用 normalize_nested_power().

函数调用图:

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

normalize_nested_power()

bool LMCAS::NormalizationVisitor::normalize_nested_power ( const PowerNode & base, const std::shared_ptr< const SymbolicNode > & exponent )

private

在文件 normalization_powers.cpp 第 111 行定义.

                                                                              {
    const auto numeric = std::dynamic_pointer_cast<const NumberNode>(exponent);
    if (normalize_nested_imaginary_power(base, numeric)) {
        return true;
    }
    if (!can_combine_nested_power(base, numeric)) {
        return false;
    }
    make_normalized_multiply_node({base.exponent(), exponent}, rewrite_budget())->accept(*this);
    normalization_check_children(rewrite_budget(), 1, base.base(), result);
    detail::make_node<PowerNode>(base.base(), result)->accept(*this);
    return true;
}

引用了 LMCAS::PowerNode::base(), can_combine_nested_power(), LMCAS::exponent, LMCAS::PowerNode::exponent(), LMCAS::detail::make_node(), LMCAS::make_normalized_multiply_node(), LMCAS::normalization_check_children(), normalize_nested_imaginary_power(), result , 以及 LMCAS::detail::SymbolicVisitor::rewrite_budget().

被这些函数引用 visit().

函数调用图:

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

normalize_power_identity()

bool LMCAS::NormalizationVisitor::normalize_power_identity ( const std::shared_ptr< const SymbolicNode > & base, const std::shared_ptr< const SymbolicNode > & exponent )

private

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

                                                       {
    if (exponent->is_zero()) {
        if (normalization_can_discard(base, facts_, domain_, context_) &&
            (domain_ == Domain::Complex ||
             normalization_proved(detail::query_nonzero_value(base, facts_, Domain::Complex, context_)))) {
            set_result(detail::make_node<NumberNode>(BigInt(1)));
        } else {
            normalization_check_children(rewrite_budget(), 1, base, exponent);
            set_result(detail::make_node<PowerNode>(base, exponent));
        }
        return true;
    }
    if (exponent->is_one()) {
        set_result(base);
        return true;
    }
    if (base->is_zero()) {
        if (normalization_can_discard(exponent, facts_, domain_, context_) &&
            normalization_proved(detail::query_positive_value(exponent, facts_, context_))) {
            set_result(detail::make_node<NumberNode>(BigInt(0)));
        } else {
            normalization_check_children(rewrite_budget(), 1, base, exponent);
            set_result(detail::make_node<PowerNode>(base, exponent));
        }
        return true;
    }
    if (!base->is_one() || !normalization_can_discard(exponent, facts_, domain_, context_)) {
        return false;
    }
    set_result(detail::make_node<NumberNode>(BigInt(1)));
    return true;
}

引用了 LMCAS::Complex, context_, domain_, LMCAS::exponent, facts_, LMCAS::detail::make_node(), LMCAS::normalization_can_discard(), LMCAS::normalization_check_children(), LMCAS::normalization_proved(), LMCAS::detail::query_nonzero_value(), LMCAS::detail::query_positive_value(), LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

被这些函数引用 visit().

函数调用图:

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

normalize_product_power()

bool LMCAS::NormalizationVisitor::normalize_product_power ( const MultiplyNode & base, const std::shared_ptr< const SymbolicNode > & exponent )

private

在文件 normalization_powers.cpp 第 41 行定义.

                                                                                 {
    for (const auto& operand : base.operands()) {
        const auto* power = dynamic_cast<const PowerNode*>(operand.get());
        if (dynamic_cast<const MatrixNode*>(operand.get()) ||
            (power && dynamic_cast<const MatrixNode*>(power->base().get()))) {
            return false;
        }
    }
    BigInt integer;
    if (!try_get_integer_value(std::dynamic_pointer_cast<const NumberNode>(exponent), integer)) {
        if (!normalization_proved(detail::query_real_value(exponent, facts_, context_))) {
            return false;
        }
        const bool positive = normalization_proved(detail::query_positive_value(exponent, facts_, context_));
        for (const auto& operand : base.operands()) {
            if (!normalization_proved(positive
                    ? detail::query_nonnegative_value(operand, facts_, context_)
                    : detail::query_positive_value(operand, facts_, context_))) {
                return false;
            }
        }
    } else if (integer.is_zero()) {
        return false;
    }
    distribute_power(base, exponent);
    return true;
}

引用了 context_, distribute_power(), LMCAS::exponent, facts_, LMCAS::integer, LMCAS::normalization_proved(), LMCAS::MultiplyNode::operands(), LMCAS::detail::query_nonnegative_value(), LMCAS::detail::query_positive_value(), LMCAS::detail::query_real_value() , 以及 LMCAS::try_get_integer_value().

被这些函数引用 visit().

函数调用图:

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

normalize_unary_function()

bool LMCAS::NormalizationVisitor::normalize_unary_function ( FunctionNode::FuncType type, const std::shared_ptr< const SymbolicNode > & argument )

private

在文件 normalization_functions.cpp 第 98 行定义.

                                                                                  {
    Rational coefficient;
    if (get_pi_coeff(argument, coefficient)) {
        if (auto value = normalization_pi_function(type, coefficient, rewrite_budget())) {
            set_result(std::move(value));
            return true;
        }
    }
    return normalize_function_parity(type, argument);
}

引用了 LMCAS::get_pi_coeff(), LMCAS::normalization_pi_function(), normalize_function_parity(), LMCAS::detail::SymbolicVisitor::rewrite_budget(), set_result() , 以及 LMCAS::value.

被这些函数引用 visit().

函数调用图:

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

rewrite_budget()

RewriteBudget * LMCAS::detail::SymbolicVisitor::rewrite_budget ( ) const

inlineprotectednoexceptinherited

在文件 base.hpp 第 220 行定义.

{ return rewrite_budget_; }

引用了 rewrite_budget_.

被这些函数引用 LMCAS::ExpandVisitor::append_child(), LMCAS::DifferentiationVisitor::append_result(), LMCAS::ExpandVisitor::check_child_count(), LMCAS::NormalizationVisitor::collect_expanded_product(), LMCAS::NormalizationVisitor::collect_product(), LMCAS::NormalizationVisitor::collect_sum(), LMCAS::DifferentiationVisitor::differentiate_atan2(), LMCAS::NormalizationVisitor::distribute_power(), LMCAS::NormalizationVisitor::distribute_product(), LMCAS::NormalizationVisitor::expand_complex_product(), LMCAS::NormalizationVisitor::expand_product(), LMCAS::NormalizationVisitor::extract_term_coefficient(), LMCAS::NormalizationVisitor::finish_squared_norm(), LMCAS::NormalizationVisitor::fuse_matrix_product(), LMCAS::NormalizationVisitor::matrix_product_element(), LMCAS::NormalizationVisitor::merge_complex_terms(), LMCAS::NormalizationVisitor::normalize_bound_body(), LMCAS::NormalizationVisitor::normalize_function_parity(), LMCAS::NormalizationVisitor::normalize_logarithm(), LMCAS::NormalizationVisitor::normalize_matrix_product(), LMCAS::NormalizationVisitor::normalize_matrix_sum(), LMCAS::NormalizationVisitor::normalize_natural_logarithm(), LMCAS::NormalizationVisitor::normalize_nested_imaginary_power(), LMCAS::NormalizationVisitor::normalize_nested_power(), LMCAS::NormalizationVisitor::normalize_power_identity(), LMCAS::NormalizationVisitor::normalize_unary_function(), LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeSubstitution::rewrite_scoped(), LMCAS::NormalizationVisitor::scale_matrix(), LMCAS::DifferentiationVisitor::set_result(), LMCAS::ExpandVisitor::set_result(), LMCAS::ExpandVisitor::set_result(), LMCAS::NormalizationVisitor::set_result(), LMCAS::NormalizationVisitor::simplify_assumed_absolute(), LMCAS::NormalizationVisitor::simplify_assumed_square_root(), LMCAS::NormalizationVisitor::try_normalize_squared_norm(), LMCAS::groebner_detail::PolyBuilder::use_numeric_function(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::DifferentiationVisitor::visit(), LMCAS::DifferentiationVisitor::visit(), LMCAS::DifferentiationVisitor::visit(), LMCAS::DifferentiationVisitor::visit(), LMCAS::DifferentiationVisitor::visit(), LMCAS::DifferentiationVisitor::visit(), LMCAS::DifferentiationVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::groebner_detail::PolyBuilder::visit(), LMCAS::groebner_detail::PolyBuilder::visit(), LMCAS::groebner_detail::PolyBuilder::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit() , 以及 LMCAS::NormalizationVisitor::visit().

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

scale_matrix()

std::shared_ptr< const SymbolicNode > LMCAS::NormalizationVisitor::scale_matrix ( const MatrixNode & matrix, const std::shared_ptr< const NumberNode > & scalar )

private

在文件 normalization_matrices.cpp 第 112 行定义.

                                                                             {
    MatrixNode::DenseStorage elements;
    const auto count = normalization_check_count(rewrite_budget(), matrix.rows(), matrix.cols());
    std::size_t nodes = 1;
    elements.reserve(count);
    for (std::size_t i = 0; i < count; ++i) {
        auto element = matrix_element(matrix, i);
        normalization_check_arithmetic<MultiplyNode>(rewrite_budget(), 0, scalar, element);
        detail::make_node<MultiplyNode>(
            std::vector<std::shared_ptr<const SymbolicNode>>{scalar, element})->accept(*this);
        normalization_append(rewrite_budget(), nodes, elements, result);
    }
    return detail::make_node<MatrixNode>(matrix.rows(), matrix.cols(), std::move(elements));
}

引用了 LMCAS::MatrixNode::cols(), LMCAS::element, LMCAS::detail::make_node(), LMCAS::normalization_append(), LMCAS::normalization_check_arithmetic(), LMCAS::normalization_check_count(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 LMCAS::MatrixNode::rows().

被这些函数引用 normalize_matrix_product().

函数调用图:

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

set_result()

void LMCAS::NormalizationVisitor::set_result ( std::shared_ptr< const SymbolicNode > candidate )

private

在文件 normalization_arithmetic.cpp 第 45 行定义.

                                                                                 {
    if (auto* budget = rewrite_budget()) {
        budget->measure_result(candidate);
    }
    result.swap(candidate);
}

引用了 LMCAS::detail::RewriteBudget::measure_result(), result , 以及 LMCAS::detail::SymbolicVisitor::rewrite_budget().

被这些函数引用 finish_squared_norm(), normalize_function_parity(), normalize_logarithm(), normalize_matrix_sum(), normalize_natural_logarithm(), normalize_nested_imaginary_power(), normalize_power_identity(), normalize_unary_function(), try_normalize_squared_norm(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit() , 以及 visit().

函数调用图:

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

simplify_assumed_absolute()

std::shared_ptr< const SymbolicNode > LMCAS::NormalizationVisitor::simplify_assumed_absolute ( const std::shared_ptr< const SymbolicNode > & argument ) const

private

在文件 normalization_functions.cpp 第 190 行定义.

                                                             {
    auto positive = detail::query_nonnegative_value(argument, facts_, context_);
    if (normalization_proved(positive)) {
        return argument;
    }
    if (!normalization_proved(detail::query_real_value(argument, facts_, context_)) ||
        !normalization_proved(facts_.is_negative(argument, context_))) {
        return nullptr;
    }
    return make_normalized_multiply_node({
        detail::make_node<NumberNode>(BigInt(-1)), argument}, rewrite_budget());
}

引用了 context_, facts_, LMCAS::FactsQuery::is_negative(), LMCAS::detail::make_node(), LMCAS::make_normalized_multiply_node(), LMCAS::normalization_proved(), LMCAS::detail::query_nonnegative_value(), LMCAS::detail::query_real_value() , 以及 LMCAS::detail::SymbolicVisitor::rewrite_budget().

被这些函数引用 try_assumption_simplify().

函数调用图:

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

simplify_assumed_square_root()

std::shared_ptr< const SymbolicNode > LMCAS::NormalizationVisitor::simplify_assumed_square_root ( const std::shared_ptr< const SymbolicNode > & argument ) const

private

在文件 normalization_functions.cpp 第 160 行定义.

                                                             {
    const auto power = std::dynamic_pointer_cast<const PowerNode>(argument);
    if (!power) {
        return nullptr;
    }
    const auto exponent = std::dynamic_pointer_cast<const NumberNode>(power->exponent());
    BigInt value;
    if (!try_get_integer_value(exponent, value)) {
        return nullptr;
    }
    if (value != BigInt(2)) {
        return nullptr;
    }
    auto nonnegative = detail::query_nonnegative_value(power->base(), facts_, context_);
    if (normalization_proved(nonnegative)) {
        return power->base();
    }
    auto real = detail::query_real_value(power->base(), facts_, context_);
    if (!real) {
        throw real.error();
    }
    if (real.value() != Tribool::True) {
        return nullptr;
    }
    normalization_check_children(rewrite_budget(), 1, power->base());
    return detail::make_node<FunctionNode>(FunctionNode::FuncType::Abs,
        std::vector<std::shared_ptr<const SymbolicNode>>{power->base()});
}

引用了 LMCAS::FunctionNode::Abs, context_, LMCAS::Result< T >::error(), LMCAS::exponent, facts_, LMCAS::detail::make_node(), LMCAS::normalization_check_children(), LMCAS::normalization_proved(), LMCAS::detail::query_nonnegative_value(), LMCAS::detail::query_real_value(), LMCAS::real(), LMCAS::detail::SymbolicVisitor::rewrite_budget(), LMCAS::True, LMCAS::try_get_integer_value(), LMCAS::Result< T >::value() , 以及 LMCAS::value.

被这些函数引用 try_assumption_simplify().

函数调用图:

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

try_assumption_simplify()

std::shared_ptr< const SymbolicNode > LMCAS::NormalizationVisitor::try_assumption_simplify ( const std::shared_ptr< const SymbolicNode > & node )

private

在文件 normalization_functions.cpp 第 204 行定义.

                                                   {
    const auto function = std::dynamic_pointer_cast<const FunctionNode>(node);
    if (!function) {
        return nullptr;
    }
    if (function->arguments().size() != 1) {
        return nullptr;
    }
    const auto& argument = function->arguments().front();
    switch (function->type()) {
        case FunctionNode::FuncType::Sqrt:
            return simplify_assumed_square_root(argument);
        case FunctionNode::FuncType::Abs:
            return simplify_assumed_absolute(argument);
        default:
            return nullptr;
    }
}

引用了 LMCAS::FunctionNode::Abs, LMCAS::function(), simplify_assumed_absolute(), simplify_assumed_square_root() , 以及 LMCAS::FunctionNode::Sqrt.

被这些函数引用 finish_squared_norm() , 以及 visit().

函数调用图:

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

try_normalize_squared_norm()

bool LMCAS::NormalizationVisitor::try_normalize_squared_norm ( const SymbolicNode & node, std::shared_ptr< const SymbolicNode > & argument )

private

在文件 normalization_norms.cpp 第 54 行定义.

                                                                           {
    const auto squares = detail::squared_norm_terms(node);
    if (!squares[0]) {
        return false;
    }
    squares[0]->base()->accept(*this);
    auto first = result;
    std::shared_ptr<const SymbolicNode> second;
    if (squares[1]) {
        squares[1]->base()->accept(*this);
        second = result;
    }
    const auto* a = dynamic_cast<const NumberNode*>(first.get());
    const auto* b = dynamic_cast<const NumberNode*>(second.get());
    const bool numeric = numeric_norm_operands(a, b, second);
    argument = normalized_norm_argument(first, second, squares, rewrite_budget());
    if (numeric) {
        argument->accept(*this);
        const auto* number = dynamic_cast<const NumberNode*>(result.get());
        if (number) {
            if (auto root = normalization_exact_square_root(*number)) {
                set_result(std::move(root));
                return true;
            }
        }
        return finish_squared_norm(node, argument, false);
    }
    return finish_squared_norm(node, argument, complex_norm_operand(first, second));
}

引用了 LMCAS::a, LMCAS::b, finish_squared_norm(), LMCAS::normalization_exact_square_root(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget(), set_result() , 以及 LMCAS::detail::squared_norm_terms().

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

函数调用图:

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

visit() [1/24]

void LMCAS::NormalizationVisitor::visit ( const AddNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_arithmetic.cpp 第 196 行定义.

                                                    {
    std::vector<std::shared_ptr<const SymbolicNode>> operands;
    std::size_t nodes = 0;
    for (const auto& operand : node.operands()) {
        operand->accept(*this);
        if (const auto add = std::dynamic_pointer_cast<const AddNode>(result)) {
            for (const auto& child : add->operands()) {
                normalization_append(rewrite_budget(), nodes, operands, child);
            }
        } else {
            normalization_append(rewrite_budget(), nodes, operands, result);
        }
    }
    merge_complex_terms(operands);
    if (normalize_matrix_sum(operands)) {
        return;
    }
    set_result(collect_sum(operands));
}

引用了 LMCAS::add(), collect_sum(), merge_complex_terms(), LMCAS::normalization_append(), normalize_matrix_sum(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

函数调用图:

visit() [2/24]

void LMCAS::NormalizationVisitor::visit ( const ComplexNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_arithmetic.cpp 第 62 行定义.

                                                        {
    node.real()->accept(*this);
    auto real = result;
    node.imag()->accept(*this);
    normalization_check_children(rewrite_budget(), 1, real, result);
    set_result(SymbolicFactory::create_complex(real, result));
}

引用了 LMCAS::SymbolicFactory::create_complex(), LMCAS::normalization_check_children(), LMCAS::real(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

函数调用图:

visit() [3/24]

void LMCAS::NormalizationVisitor::visit ( const FiniteSetNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

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

                                                          {
    std::vector<std::shared_ptr<const SymbolicNode>> elements;
    std::size_t nodes = 1;
    normalization_check_count(rewrite_budget(), node.elements().size());
    elements.reserve(node.elements().size());
    for (const auto& element : node.elements()) {
        element->accept(*this);
        normalization_append(rewrite_budget(), nodes, elements, result);
    }
    set_result(LMCAS::detail::make_node<FiniteSetNode>(std::move(elements)));
}

引用了 LMCAS::element, LMCAS::detail::make_node(), LMCAS::normalization_append(), LMCAS::normalization_check_count(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

函数调用图:

visit() [4/24]

void LMCAS::NormalizationVisitor::visit ( const FunctionNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_functions.cpp 第 110 行定义.

                                                         {
    std::shared_ptr<const SymbolicNode> argument;
    if (try_normalize_squared_norm(node, argument)) {
        return;
    }
    std::vector<std::shared_ptr<const SymbolicNode>> arguments;
    std::size_t nodes = 0;
    if (argument) {
        normalization_append(rewrite_budget(), nodes, arguments, argument);
    } else {
        for (const auto& operand : node.arguments()) {
            operand->accept(*this);
            normalization_append(rewrite_budget(), nodes, arguments, result);
        }
    }
    if (arguments.size() == 1) {
        if (const auto number = std::dynamic_pointer_cast<const NumberNode>(arguments.front())) {
            if (auto value = normalization_numeric_function(node.type(), number, rewrite_budget())) {
                set_result(std::move(value));
                return;
            }
        }
    }
    if (normalize_logarithm(node.type(), arguments)) {
        return;
    }
    if (arguments.size() == 1 && normalize_unary_function(node.type(), arguments.front())) {
        return;
    }
    if (rewrite_budget()) { rewrite_budget()->append_size(1, nodes); }
    auto function = detail::make_node<FunctionNode>(node.type(), arguments);
    if (auto simplified = try_assumption_simplify(function)) {
        simplified->accept(*this);
        return;
    }
    set_result(function);
}

引用了 LMCAS::detail::RewriteBudget::append_size(), LMCAS::function(), LMCAS::detail::make_node(), LMCAS::normalization_append(), LMCAS::normalization_numeric_function(), normalize_logarithm(), normalize_unary_function(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget(), set_result(), try_assumption_simplify(), try_normalize_squared_norm() , 以及 LMCAS::value.

函数调用图:

visit() [5/24]

void LMCAS::NormalizationVisitor::visit ( const IntegralNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_structural.cpp 第 355 行定义.

                                                         {
    auto body = normalize_bound_body(node);
    std::shared_ptr<const SymbolicNode> lower;
    std::shared_ptr<const SymbolicNode> upper;
    if (node.lower()) {
        node.lower()->accept(*this);
        lower = result;
        node.upper()->accept(*this);
        upper = result;
    }
    normalization_check_children(rewrite_budget(), 1, body, lower, upper);
    set_result(LMCAS::detail::make_node<IntegralNode>(
        std::move(body), node.variable(), std::move(lower), std::move(upper)));
}

引用了 LMCAS::lower, LMCAS::detail::make_node(), LMCAS::normalization_check_children(), normalize_bound_body(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget(), set_result() , 以及 LMCAS::upper.

函数调用图:

visit() [6/24]

void LMCAS::NormalizationVisitor::visit ( const IntervalNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_structural.cpp 第 325 行定义.

                                                         {
    node.lower()->accept(*this);
    auto lower = result;
    node.upper()->accept(*this);
    normalization_check_children(rewrite_budget(), 1, lower, result);
    set_result(LMCAS::detail::make_node<IntervalNode>(
        lower, result, node.lower_closed(), node.upper_closed()));
}

引用了 LMCAS::lower, LMCAS::detail::make_node(), LMCAS::normalization_check_children(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

函数调用图:

visit() [7/24]

void LMCAS::NormalizationVisitor::visit ( const LimitNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_structural.cpp 第 370 行定义.

                                                      {
    auto body = normalize_bound_body(node);
    node.point()->accept(*this);
    normalization_check_children(rewrite_budget(), 1, body, result);
    set_result(LMCAS::detail::make_node<LimitNode>(
        body, node.variable(), result, node.direction()));
}

引用了 LMCAS::detail::make_node(), LMCAS::normalization_check_children(), normalize_bound_body(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

函数调用图:

visit() [8/24]

void LMCAS::NormalizationVisitor::visit ( const LogicalNode & node )

overridevirtual

Implication: A ⇒ B = ¬A ∨ B

NOT handling: De Morgan's laws and double negation

Normalize the operand first

Double negation: ¬(¬A) = A

De Morgan's law: ¬(A∧B) = ¬A∨¬B

De Morgan's law: ¬(A∨B) = ¬A∧¬B

And / Or: normalize operands

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_structural.cpp 第 72 行定义.

                                                        {
        /// Implication: A ⇒ B = ¬A ∨ B
        if (node.op() == LogicalNode::Op::Implies) {
            normalization_check_children(rewrite_budget(), 1, node.left());
            auto not_left = LMCAS::detail::make_node<LogicalNode>(node.left(), nullptr, LogicalNode::Op::Not);
            normalization_check_children(rewrite_budget(), 1, not_left, node.right());
            auto or_node = LMCAS::detail::make_node<LogicalNode>(not_left, node.right(), LogicalNode::Op::Or);
            or_node->accept(*this);
            return;
        }
 
        /// NOT handling: De Morgan's laws and double negation
        if (node.op() == LogicalNode::Op::Not) {
            /// Normalize the operand first
            std::shared_ptr<const SymbolicNode> new_left = nullptr;
            if (node.left()) {
                node.left()->accept(*this);
                new_left = result;
            }
            if (!new_left) new_left = node.left();
 
            /// Double negation: ¬(¬A) = A
            if (auto inner_logical = std::dynamic_pointer_cast<const LogicalNode>(new_left)) {
                if (inner_logical->op() == LogicalNode::Op::Not) {
                    set_result(inner_logical->left());
                    return;
                }
                /// De Morgan's law: ¬(A∧B) = ¬A∨¬B
                if (inner_logical->op() == LogicalNode::Op::And) {
                    normalization_check_children(rewrite_budget(), 1, inner_logical->left());
                    auto not_a = LMCAS::detail::make_node<LogicalNode>(inner_logical->left(), nullptr, LogicalNode::Op::Not);
                    normalization_check_children(rewrite_budget(), 1, inner_logical->right());
                    auto not_b = LMCAS::detail::make_node<LogicalNode>(inner_logical->right(), nullptr, LogicalNode::Op::Not);
                    normalization_check_children(rewrite_budget(), 1, not_a, not_b);
                    auto or_node = LMCAS::detail::make_node<LogicalNode>(not_a, not_b, LogicalNode::Op::Or);
                    or_node->accept(*this);
                    return;
                }
                /// De Morgan's law: ¬(A∨B) = ¬A∧¬B
                if (inner_logical->op() == LogicalNode::Op::Or) {
                    normalization_check_children(rewrite_budget(), 1, inner_logical->left());
                    auto not_a = LMCAS::detail::make_node<LogicalNode>(inner_logical->left(), nullptr, LogicalNode::Op::Not);
                    normalization_check_children(rewrite_budget(), 1, inner_logical->right());
                    auto not_b = LMCAS::detail::make_node<LogicalNode>(inner_logical->right(), nullptr, LogicalNode::Op::Not);
                    normalization_check_children(rewrite_budget(), 1, not_a, not_b);
                    auto and_node = LMCAS::detail::make_node<LogicalNode>(not_a, not_b, LogicalNode::Op::And);
                    and_node->accept(*this);
                    return;
                }
            }
 
            normalization_check_children(rewrite_budget(), 1, new_left);
            set_result(LMCAS::detail::make_node<LogicalNode>(new_left, nullptr, LogicalNode::Op::Not));
            return;
        }
 
        /// And / Or: normalize operands
        std::shared_ptr<const SymbolicNode> new_left = nullptr;
        std::shared_ptr<const SymbolicNode> new_right = nullptr;
 
        if (node.left()) {
            node.left()->accept(*this);
            new_left = result;
        }
        if (node.right()) {
            node.right()->accept(*this);
            new_right = result;
        }
 
        if (!new_left) new_left = node.left();
        if (!new_right) new_right = node.right();
 
        normalization_check_children(rewrite_budget(), 1, new_left, new_right);
        set_result(LMCAS::detail::make_node<LogicalNode>(new_left, new_right, node.op()));
    }

引用了 LMCAS::LogicalNode::And, LMCAS::LogicalNode::Implies, LMCAS::detail::make_node(), LMCAS::normalization_check_children(), LMCAS::LogicalNode::Not, LMCAS::LogicalNode::Or, result, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

函数调用图:

visit() [9/24]

void LMCAS::NormalizationVisitor::visit ( const MatrixNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_structural.cpp 第 22 行定义.

                                                       {
        std::size_t nodes = 1;
        if (std::holds_alternative<MatrixNode::DenseStorage>(node.storage())) {
             auto& dense = std::get<MatrixNode::DenseStorage>(node.storage());
             MatrixNode::DenseStorage new_dense;
             for(auto& item : dense) {
                 if(item) {
                    item->accept(*this);
                    normalization_append(rewrite_budget(), nodes, new_dense, result);
                 } else {
                    normalization_append(rewrite_budget(), nodes, new_dense, nullptr);
                 }
             }
             set_result(LMCAS::detail::make_node<MatrixNode>(node.rows(), node.cols(), new_dense));
        } else {
             auto& sparse = std::get<MatrixNode::SparseStorage>(node.storage());
             MatrixNode::SparseStorage new_sparse;
             for(auto& [idx, item] : sparse) {
                 item->accept(*this);
                 if (!result->is_zero()) {
                     if (rewrite_budget()) {
                         nodes = rewrite_budget()->append_size(nodes, rewrite_budget()->measure(result));
                     }
                     new_sparse[idx] = result;
                 }
             }
             set_result(LMCAS::detail::make_node<MatrixNode>(node.rows(), node.cols(), new_sparse));
        }
    }

引用了 LMCAS::detail::RewriteBudget::append_size(), LMCAS::detail::make_node(), LMCAS::normalization_append(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

函数调用图:

visit() [10/24]

void LMCAS::NormalizationVisitor::visit ( const MembershipNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_structural.cpp 第 334 行定义.

                                                           {
    node.element()->accept(*this);
    auto element = result;
    node.set()->accept(*this);
    auto set = result;
    if (auto finite = std::dynamic_pointer_cast<const FiniteSetNode>(set)) {
        set_result(LMCAS::detail::make_node<NumberNode>(
            BigInt(finite->contains(*element) ? 1 : 0)));
        return;
    }
    normalization_check_children(rewrite_budget(), 1, element, set);
    set_result(LMCAS::detail::make_node<MembershipNode>(element, set));
}

引用了 LMCAS::element, LMCAS::detail::make_node(), LMCAS::normalization_check_children(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget(), LMCAS::set , 以及 set_result().

函数调用图:

visit() [11/24]

void LMCAS::NormalizationVisitor::visit ( const MultiplyNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_products.cpp 第 153 行定义.

                                                         {
    std::vector<std::shared_ptr<const SymbolicNode>> operands;
    std::size_t nodes = 0;
    for (const auto& operand : node.operands()) {
        operand->accept(*this);
        if (const auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(result)) {
            for (const auto& child : multiply->operands()) {
                normalization_append(rewrite_budget(), nodes, operands, child);
            }
        } else {
            normalization_append(rewrite_budget(), nodes, operands, result);
        }
    }
    if (has_matrix_factor(operands)) {
        set_result(normalize_matrix_product(operands));
        return;
    }
    set_result(collect_product(operands));
}

引用了 collect_product(), LMCAS::normalization_append(), normalize_matrix_product(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

函数调用图:

visit() [12/24]

void LMCAS::NormalizationVisitor::visit ( const NumberNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_arithmetic.cpp 第 52 行定义.

                                                       {
    if (rewrite_budget()) { rewrite_budget()->require_nodes(1); }
    set_result(node.clone());
}

引用了 LMCAS::detail::RewriteBudget::require_nodes(), LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

被这些函数引用 NormalizationVisitor().

函数调用图:

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

visit() [13/24]

void LMCAS::NormalizationVisitor::visit ( const PiecewiseNode & node )

overridevirtual

Normalize expression

Normalize condition

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_structural.cpp 第 147 行定义.

                                                          {
        std::vector<PiecewiseNode::Branch> new_branches;
        std::size_t nodes = 1;
        normalization_check_count(rewrite_budget(), node.branches().size(), 2);
        new_branches.reserve(node.branches().size());
 
        for (const auto& b : node.branches()) {
            /// Normalize expression
            b.expression->accept(*this);
            auto new_expr = result;
 
            /// Normalize condition
            b.condition->accept(*this);
            auto new_cond = result;
 
            if (rewrite_budget()) {
                nodes = rewrite_budget()->append_size(nodes, rewrite_budget()->measure(new_expr));
                nodes = rewrite_budget()->append_size(nodes, rewrite_budget()->measure(new_cond));
            }
            new_branches.push_back({new_expr, new_cond});
        }
 
        std::shared_ptr<const SymbolicNode> new_default = nullptr;
        if (node.default_expr()) {
            node.default_expr()->accept(*this);
            new_default = result;
            if (rewrite_budget()) {
                (void)rewrite_budget()->append_size(nodes, rewrite_budget()->measure(new_default));
            }
        }
 
        set_result(LMCAS::detail::make_node<PiecewiseNode>(std::move(new_branches), new_default));
    }

引用了 LMCAS::detail::RewriteBudget::append_size(), LMCAS::b, LMCAS::detail::make_node(), LMCAS::normalization_check_count(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

函数调用图:

visit() [14/24]

void LMCAS::NormalizationVisitor::visit ( const PowerNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_powers.cpp 第 126 行定义.

                                                      {
    std::shared_ptr<const SymbolicNode> base;
    if (try_normalize_squared_norm(node, base)) {
        return;
    }
    if (!base) {
        node.base()->accept(*this);
        base = result;
    }
    node.exponent()->accept(*this);
    auto exponent = result;
    if (normalize_power_identity(base, exponent)) {
        return;
    }
    const auto base_number = std::dynamic_pointer_cast<const NumberNode>(base);
    const auto exponent_number = std::dynamic_pointer_cast<const NumberNode>(exponent);
    if (base_number && exponent_number &&
        normalization_can_discard(base, facts_, domain_, context_) && normalization_can_discard(exponent, facts_, domain_, context_)) {
        if (auto folded = normalization_numeric_power(base_number, exponent_number, rewrite_budget())) {
            set_result(std::move(folded));
            return;
        }
    }
    if (const auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(base)) {
        if (normalize_product_power(*multiply, exponent)) {
            return;
        }
    }
    if (const auto power = std::dynamic_pointer_cast<const PowerNode>(base)) {
        if (normalize_nested_power(*power, exponent)) {
            return;
        }
    }
    normalization_check_children(rewrite_budget(), 1, base, exponent);
    set_result(detail::make_node<PowerNode>(base, exponent));
}

引用了 context_, domain_, LMCAS::exponent, facts_, LMCAS::detail::make_node(), LMCAS::normalization_can_discard(), LMCAS::normalization_check_children(), LMCAS::normalization_numeric_power(), normalize_nested_power(), normalize_power_identity(), normalize_product_power(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget(), set_result() , 以及 try_normalize_squared_norm().

函数调用图:

visit() [15/24]

void LMCAS::NormalizationVisitor::visit ( const ProductNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

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

                                                        {
        auto new_body = normalize_bound_body(node);
 
        node.lower_bound()->accept(*this);
        auto new_lower = result;
 
        node.upper_bound()->accept(*this);
        auto new_upper = result;
 
        auto lo_n = std::dynamic_pointer_cast<const NumberNode>(new_lower);
        auto hi_n = std::dynamic_pointer_cast<const NumberNode>(new_upper);
        BigInt lo;
        BigInt hi;
        if (try_get_integer_value(lo_n, lo) && try_get_integer_value(hi_n, hi)) {
            if (hi < lo) {
                set_result(LMCAS::detail::make_node<NumberNode>(BigInt(1)));
                return;
            }
            const BigInt span = hi - lo;
            if (span < BigInt(1000)) {
                const auto count = span.try_to_uint64();
                std::vector<std::shared_ptr<const SymbolicNode>> factors;
                std::size_t nodes = 0;
                normalization_check_count(rewrite_budget(), static_cast<std::size_t>(*count) + 1, 1, false);
                factors.reserve(static_cast<std::size_t>(*count) + 1);
                BigInt index = lo;
                for (std::uint64_t offset = 0; offset <= *count; ++offset, index += BigInt(1)) {
                    auto kval = LMCAS::detail::make_node<NumberNode>(index);
                    auto term = norm_subst_index(new_body, node.index_var(), kval, rewrite_budget());
                    normalization_check_children(rewrite_budget(), 0, term);
                    NormalizationVisitor inner(*rewrite_budget(), facts_, domain_);
                    term->accept(inner);
                    normalization_append(rewrite_budget(), nodes, factors, inner.get_result());
                }
                if (factors.empty()) { set_result(LMCAS::detail::make_node<NumberNode>(BigInt(1))); return; }
                auto prod_node = make_normalized_multiply_node(factors, rewrite_budget());
                prod_node->accept(*this);
                return;
            }
        }
 
        normalization_check_children(rewrite_budget(), 1, new_body, new_lower, new_upper);
        set_result(LMCAS::detail::make_node<ProductNode>(new_body, node.index_var(), new_lower, new_upper));
    }

引用了 NormalizationVisitor(), domain_, facts_, get_result(), LMCAS::detail::make_node(), LMCAS::make_normalized_multiply_node(), LMCAS::norm_subst_index(), LMCAS::normalization_append(), LMCAS::normalization_check_children(), LMCAS::normalization_check_count(), normalize_bound_body(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget(), set_result() , 以及 LMCAS::try_get_integer_value().

函数调用图:

visit() [16/24]

void LMCAS::NormalizationVisitor::visit ( const QuantifierNode & node )

overridevirtual

Simplify ∀x∈S: true → true

Simplify ∃x∈S: false → false

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_structural.cpp 第 278 行定义.

                                                           {
        node.domain()->accept(*this);
        auto new_domain = result;
 
        auto new_predicate = normalize_bound_body(node);
 
        /// Simplify ∀x∈S: true → true
        if (node.quantifier_type() == QuantifierNode::Type::ForAll) {
            if (new_predicate->is_one()) {
                set_result(LMCAS::detail::make_node<NumberNode>(BigInt(1)));
                return;
            }
        }
 
        /// Simplify ∃x∈S: false → false
        if (node.quantifier_type() == QuantifierNode::Type::Exists) {
            if (new_predicate->is_zero()) {
                set_result(LMCAS::detail::make_node<NumberNode>(BigInt(0)));
                return;
            }
        }
 
        normalization_check_children(rewrite_budget(), 1, new_domain, new_predicate);
        set_result(LMCAS::detail::make_node<QuantifierNode>(node.quantifier_type(), node.bound_var(), new_domain, new_predicate));
    }

引用了 LMCAS::QuantifierNode::Exists, LMCAS::QuantifierNode::ForAll, LMCAS::detail::make_node(), LMCAS::normalization_check_children(), normalize_bound_body(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

函数调用图:

visit() [17/24]

void LMCAS::NormalizationVisitor::visit ( const QuantityNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_structural.cpp 第 348 行定义.

                                                         {
    node.value()->accept(*this);
    normalization_check_children(rewrite_budget(), 1, result);
    set_result(LMCAS::detail::make_node<QuantityNode>(
        result, node.dimension(), node.scale_to_base(), node.display_unit()));
}

引用了 LMCAS::detail::make_node(), LMCAS::normalization_check_children(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

函数调用图:

visit() [18/24]

void LMCAS::NormalizationVisitor::visit ( const RelationalNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_structural.cpp 第 51 行定义.

                                                           {
 
        std::shared_ptr<const SymbolicNode> new_left = nullptr;
        std::shared_ptr<const SymbolicNode> new_right = nullptr;
 
        if (node.left()) {
            node.left()->accept(*this);
            new_left = result;
        }
        if (node.right()) {
 
            node.right()->accept(*this);
            new_right = result;
        }
 
        if (!new_left) new_left = node.left();
        if (!new_right) new_right = node.right();
 
        normalization_check_children(rewrite_budget(), 1, new_left, new_right);
        set_result(LMCAS::detail::make_node<RelationalNode>(new_left, new_right, node.op()));
    }

引用了 LMCAS::detail::make_node(), LMCAS::normalization_check_children(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

函数调用图:

visit() [19/24]

void LMCAS::NormalizationVisitor::visit ( const RootOfNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_structural.cpp 第 378 行定义.

                                                       {
    if (rewrite_budget()) { rewrite_budget()->require_nodes(1); }
    set_result(node.clone());
}

引用了 LMCAS::detail::RewriteBudget::require_nodes(), LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

函数调用图:

visit() [20/24]

void LMCAS::NormalizationVisitor::visit ( const SetBuilderNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_structural.cpp 第 303 行定义.

                                                           {
        node.domain()->accept(*this);
        auto new_domain = result;
 
        auto new_predicate = normalize_bound_body(node);
 
        normalization_check_children(rewrite_budget(), 1, new_domain, new_predicate);
        set_result(LMCAS::detail::make_node<SetBuilderNode>(node.element_var(), new_domain, new_predicate));
    }

引用了 LMCAS::detail::make_node(), LMCAS::normalization_check_children(), normalize_bound_body(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

函数调用图:

visit() [21/24]

void LMCAS::NormalizationVisitor::visit ( const SummationNode & node )

overridevirtual

当上下界均为具体整数且范围较小时，展开求和为显式和。

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_structural.cpp 第 180 行定义.

                                                          {
        auto new_body = normalize_bound_body(node);
 
        node.lower_bound()->accept(*this);
        auto new_lower = result;
 
        node.upper_bound()->accept(*this);
        auto new_upper = result;
 
        /// 当上下界均为具体整数且范围较小时，展开求和为显式和。
        auto lo_n = std::dynamic_pointer_cast<const NumberNode>(new_lower);
        auto hi_n = std::dynamic_pointer_cast<const NumberNode>(new_upper);
        BigInt lo;
        BigInt hi;
        if (try_get_integer_value(lo_n, lo) && try_get_integer_value(hi_n, hi)) {
            if (hi < lo) {
                set_result(LMCAS::detail::make_node<NumberNode>(BigInt(0)));
                return;
            }
            const BigInt span = hi - lo;
            if (span < BigInt(1000)) {
                const auto count = span.try_to_uint64();
                std::vector<std::shared_ptr<const SymbolicNode>> terms;
                std::size_t nodes = 0;
                normalization_check_count(rewrite_budget(), static_cast<std::size_t>(*count) + 1, 1, false);
                terms.reserve(static_cast<std::size_t>(*count) + 1);
                BigInt index = lo;
                for (std::uint64_t offset = 0; offset <= *count; ++offset, index += BigInt(1)) {
                    auto kval = LMCAS::detail::make_node<NumberNode>(index);
                    auto term = norm_subst_index(new_body, node.index_var(), kval, rewrite_budget());
                    normalization_check_children(rewrite_budget(), 0, term);
                    NormalizationVisitor inner(*rewrite_budget(), facts_, domain_);
                    term->accept(inner);
                    normalization_append(rewrite_budget(), nodes, terms, inner.get_result());
                }
                if (terms.empty()) { set_result(LMCAS::detail::make_node<NumberNode>(BigInt(0))); return; }
                normalization_check_arithmetic<AddNode>(rewrite_budget(), terms, nodes);
                auto sum_node = LMCAS::detail::make_node<AddNode>(terms);
                sum_node->accept(*this);
                return;
            }
        }
 
        normalization_check_children(rewrite_budget(), 1, new_body, new_lower, new_upper);
        set_result(LMCAS::detail::make_node<SummationNode>(new_body, node.index_var(), new_lower, new_upper));
    }

引用了 NormalizationVisitor(), domain_, facts_, get_result(), LMCAS::detail::make_node(), LMCAS::norm_subst_index(), LMCAS::normalization_append(), LMCAS::normalization_check_arithmetic(), LMCAS::normalization_check_children(), LMCAS::normalization_check_count(), normalize_bound_body(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget(), set_result() , 以及 LMCAS::try_get_integer_value().

函数调用图:

visit() [22/24]

void LMCAS::NormalizationVisitor::visit ( const TransformNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_structural.cpp 第 270 行定义.

                                                          {
        auto new_body = normalize_bound_body(node);
        node.target()->accept(*this);
        auto new_target = result;
        normalization_check_children(rewrite_budget(), 1, new_body, new_target);
        set_result(LMCAS::detail::make_node<TransformNode>(
            node.transform_type(), new_body, node.source_var(), new_target));
    }

引用了 LMCAS::detail::make_node(), LMCAS::normalization_check_children(), normalize_bound_body(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

函数调用图:

visit() [23/24]

void LMCAS::NormalizationVisitor::visit ( const UninterpretedFunctionNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_functions.cpp 第 148 行定义.

                                                                      {
    std::vector<std::shared_ptr<const SymbolicNode>> arguments;
    std::size_t nodes = 1;
    normalization_check_count(rewrite_budget(), node.arguments().size());
    arguments.reserve(node.arguments().size());
    for (const auto& argument : node.arguments()) {
        argument->accept(*this);
        normalization_append(rewrite_budget(), nodes, arguments, result);
    }
    set_result(LMCAS::detail::make_node<UninterpretedFunctionNode>(
        node.name(), std::move(arguments)));
}

引用了 LMCAS::detail::make_node(), LMCAS::normalization_append(), LMCAS::normalization_check_count(), result, LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

函数调用图:

visit() [24/24]

void LMCAS::NormalizationVisitor::visit ( const VariableNode & node )

overridevirtual

实现了 LMCAS::detail::SymbolicVisitor.

在文件 normalization_arithmetic.cpp 第 57 行定义.

                                                         {
    if (rewrite_budget()) { rewrite_budget()->require_nodes(1); }
    set_result(node.clone());
}

引用了 LMCAS::detail::RewriteBudget::require_nodes(), LMCAS::detail::SymbolicVisitor::rewrite_budget() , 以及 set_result().

函数调用图:

类成员变量说明

context_

ComputationContext& LMCAS::NormalizationVisitor::context_

private

在文件 normalization_visitor.hpp 第 59 行定义.

被这些函数引用 NormalizationVisitor(), can_combine_nested_power(), collect_expanded_product(), collect_product(), collect_sum(), normalize_logarithm(), normalize_natural_logarithm(), normalize_power_identity(), normalize_product_power(), simplify_assumed_absolute(), simplify_assumed_square_root() , 以及 visit().

current_depth

int LMCAS::detail::SymbolicVisitor::current_depth = 0

protectedinherited

在文件 base.hpp 第 218 行定义.

被这些函数引用 LMCAS::detail::SymbolicVisitor::DepthGuard::DepthGuard() , 以及 LMCAS::detail::SymbolicVisitor::DepthGuard::~DepthGuard().

domain_

Domain LMCAS::NormalizationVisitor::domain_ = Domain::Real

private

在文件 normalization_visitor.hpp 第 62 行定义.

被这些函数引用 NormalizationVisitor(), collect_expanded_product(), collect_product(), collect_sum(), expand_complex_product(), extract_term_coefficient(), matrix_product_element(), merge_complex_terms(), normalize_bound_body(), normalize_logarithm(), normalize_natural_logarithm(), normalize_power_identity(), visit(), visit() , 以及 visit().

facts_

const FactsQuery& LMCAS::NormalizationVisitor::facts_ = detail::no_facts()

private

在文件 normalization_visitor.hpp 第 61 行定义.

被这些函数引用 NormalizationVisitor(), can_combine_nested_power(), collect_expanded_product(), collect_product(), collect_sum(), expand_complex_product(), extract_term_coefficient(), matrix_product_element(), merge_complex_terms(), normalize_bound_body(), normalize_logarithm(), normalize_natural_logarithm(), normalize_power_identity(), normalize_product_power(), simplify_assumed_absolute(), simplify_assumed_square_root(), visit(), visit() , 以及 visit().

MAX_DEPTH

int LMCAS::detail::SymbolicVisitor::MAX_DEPTH = 200

staticconstexprprotectedinherited

在文件 base.hpp 第 219 行定义.

被这些函数引用 LMCAS::detail::SymbolicVisitor::DepthGuard::DepthGuard().

result

std::shared_ptr<const SymbolicNode> LMCAS::NormalizationVisitor::result

private

在文件 normalization_visitor.hpp 第 60 行定义.

被这些函数引用 distribute_power(), finish_squared_norm(), get_result(), normalize_bound_body(), normalize_matrix_sum(), normalize_nested_power(), scale_matrix(), set_result(), try_normalize_squared_norm(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit(), visit() , 以及 visit().

rewrite_budget_

RewriteBudget* LMCAS::detail::SymbolicVisitor::rewrite_budget_ = nullptr

privateinherited

在文件 base.hpp 第 223 行定义.

被这些函数引用 LMCAS::detail::SymbolicVisitor::DepthGuard::DepthGuard(), SymbolicVisitor(), LMCAS::detail::SymbolicVisitor::DepthGuard::~DepthGuard() , 以及 rewrite_budget().

---

该类的文档由以下文件生成:

• src/internal/visitors/normalization_visitor.hpp
• src/normalization_arithmetic.cpp
• src/normalization_functions.cpp
• src/normalization_matrices.cpp
• src/normalization_norms.cpp
• src/normalization_powers.cpp
• src/normalization_products.cpp
• src/normalization_structural.cpp