乘法节点，表示多个操作数的乘积。更多...

#include </home/runner/work/docs/docs/LMCAS/src/internal/symbolic_ast/arithmetic.hpp>

类 LMCAS::MultiplyNode 继承关系图:

LMCAS::MultiplyNode 的协作图:

Public 成员函数
void	accept (LMCAS::detail::SymbolicVisitor &visitor) const override
std::shared_ptr< const SymbolicNode >	clone () const override
int	compare (const SymbolicNode &other) const
	与另一个节点进行全序比较.
bool	equals (const SymbolicNode &other) const
	判断两个节点是否结构相等.
std::size_t	hash () const
	获取节点哈希值(带缓存).
virtual bool	is_number () const
virtual bool	is_one () const
virtual bool	is_positive () const
virtual bool	is_zero () const
const std::vector< std::shared_ptr< const SymbolicNode > > &	operands () const noexcept
int	type_priority () const override

Protected 成员函数
int	compare_same_type (const SymbolicNode &other) const override
std::size_t	compute_hash () const override

Protected 属性
std::atomic< std::size_t >	cached_hash {0}
std::atomic< bool >	hash_computed {false}

Private 成员函数
	MultiplyNode (std::vector< std::shared_ptr< const SymbolicNode > > ops)

静态 Private 成员函数
static bool	compare_operands (const std::shared_ptr< const SymbolicNode > &lhs, const std::shared_ptr< const SymbolicNode > &rhs)
static bool	contains_matrix (const SymbolicNode &node)
static std::vector< std::shared_ptr< const SymbolicNode > >	normalize_operands (std::vector< std::shared_ptr< const SymbolicNode > > ops)

Private 属性
	LMCAS_AST_NODE_FACTORY_FRIEND
const std::vector< std::shared_ptr< const SymbolicNode > >	operands_

详细描述

乘法节点，表示多个操作数的乘积。

构造时扁平化嵌套乘积；纯标量因子按规范顺序排序，包含矩阵的乘积保留因子的输入顺序。

在文件 arithmetic.hpp 第 134 行定义.

构造及析构函数说明

◆ MultiplyNode()

LMCAS::MultiplyNode::MultiplyNode ( std::vector< std::shared_ptr< const SymbolicNode > > ops )

inlineexplicitprivate

在文件 arithmetic.hpp 第 173 行定义.

174 : operands_(normalize_operands(std::move(ops))) {}

LMCAS::MultiplyNode::normalize_operands

static std::vector< std::shared_ptr< const SymbolicNode > > normalize_operands(std::vector< std::shared_ptr< const SymbolicNode > > ops)

定义 arithmetic.hpp:145

LMCAS::MultiplyNode::operands_

const std::vector< std::shared_ptr< const SymbolicNode > > operands_

定义 arithmetic.hpp:171

引用了 normalize_operands() , 以及 operands_.

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

函数调用图:

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

成员函数说明

◆ accept()

void LMCAS::MultiplyNode::accept ( LMCAS::detail::SymbolicVisitor & visitor ) const

inlineoverridevirtual

实现了 LMCAS::SymbolicNode.

在文件 arithmetic.hpp 第 206 行定义.

206{ LMCAS::detail::SymbolicVisitor::DepthGuard guard(visitor); visitor.visit(*this); }

LMCAS::detail::SymbolicVisitor::visit

virtual void visit(const NumberNode &node)=0

引用了 LMCAS::detail::SymbolicVisitor::visit().

函数调用图:

◆ clone()

std::shared_ptr< const SymbolicNode > LMCAS::MultiplyNode::clone ( ) const

inlineoverridevirtual

实现了 LMCAS::SymbolicNode.

在文件 arithmetic.hpp 第 207 行定义.

                                                             {
        std::vector<std::shared_ptr<const SymbolicNode>> new_ops;
        new_ops.reserve(operands_.size());
        for (const auto& op : operands_) new_ops.push_back(op->clone());
        return LMCAS::detail::make_node<MultiplyNode>(std::move(new_ops));
    }

引用了 LMCAS::detail::make_node(), LMCAS::op , 以及 operands_.

函数调用图:

◆ compare()

int LMCAS::SymbolicNode::compare ( const SymbolicNode & other ) const

inlineinherited

与另一个节点进行全序比较.

参数

other 待比较的节点

返回: 小于返回 -1,等于返回 0,大于返回 1

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

                                                 {
        if (type_priority() != other.type_priority()) {
            return type_priority() < other.type_priority() ? -1 : 1;
        }
        return compare_same_type(other);
    }

引用了 SymbolicNode(), compare_same_type() , 以及 type_priority().

被这些函数引用 LMCAS::anonymous_namespace{symbolic_cancel.cpp}::combine_fraction_terms() , 以及 LMCAS::endpoints_equivalent().

函数调用图:

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

◆ compare_operands()

bool LMCAS::MultiplyNode::compare_operands	(	const std::shared_ptr< const SymbolicNode > &	lhs,
		const std::shared_ptr< const SymbolicNode > &	rhs )

inlinestaticprivate

在文件 arithmetic.hpp 第 139 行定义.

                                                      {
        return lhs->compare(*rhs) < 0;
    }

引用了 LMCAS::rhs.

被这些函数引用 normalize_operands().

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

◆ compare_same_type()

int LMCAS::MultiplyNode::compare_same_type ( const SymbolicNode & other ) const

inlineoverrideprotectedvirtual

实现了 LMCAS::SymbolicNode.

在文件 arithmetic.hpp 第 193 行定义.

                                                                    {
        const auto& o = static_cast<const MultiplyNode&>(other);
        if (operands_.size() != o.operands_.size()) {
            return operands_.size() < o.operands_.size() ? -1 : 1;
        }
        for (size_t i = 0; i < operands_.size(); ++i) {
            int cmp = operands_[i]->compare(*o.operands_[i]);
            if (cmp != 0) return cmp;
        }
        return 0;
    }

引用了 MultiplyNode(), LMCAS::SymbolicNode::SymbolicNode() , 以及 operands_.

函数调用图:

◆ compute_hash()

std::size_t LMCAS::MultiplyNode::compute_hash ( ) const

inlineoverrideprotectedvirtual

实现了 LMCAS::SymbolicNode.

在文件 arithmetic.hpp 第 184 行定义.

                                            {
        std::size_t seed = 0;
        hash_combine(seed, type_priority());
        for (const auto& op : operands_) {
            hash_combine(seed, op->hash());
        }
        return seed;
    }

引用了 LMCAS::hash_combine(), LMCAS::op, operands_ , 以及 type_priority().

函数调用图:

◆ contains_matrix()

bool LMCAS::MultiplyNode::contains_matrix ( const SymbolicNode & node )

inlinestaticprivate

在文件 matrix.hpp 第 202 行定义.

                                                                  {
    if (dynamic_cast<const MatrixNode*>(&node)) return true;
    if (const auto* power = dynamic_cast<const PowerNode*>(&node)) {
        return contains_matrix(*power->base());
    }
    const std::vector<std::shared_ptr<const SymbolicNode>>* children = nullptr;
    if (const auto* sum = dynamic_cast<const AddNode*>(&node)) {
        children = &sum->operands();
    } else if (const auto* product = dynamic_cast<const MultiplyNode*>(&node)) {
        children = &product->operands();
    } else if (const auto* function = dynamic_cast<const FunctionNode*>(&node)) {
        children = &function->arguments();
    } else if (const auto* function = dynamic_cast<const UninterpretedFunctionNode*>(&node)) {
        children = &function->arguments();
    }
    return children && std::any_of(
        children->begin(), children->end(),
        [](const auto& child) { return contains_matrix(*child); });
}

引用了 MultiplyNode(), LMCAS::SymbolicNode::SymbolicNode(), contains_matrix() , 以及 LMCAS::function().

被这些函数引用 contains_matrix().

函数调用图:

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

◆ equals()

bool LMCAS::SymbolicNode::equals ( const SymbolicNode & other ) const

inlineinherited

判断两个节点是否结构相等.

参数

other 待比较的节点

返回: 相等返回 true

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

                                                 {
        if (this == &other) return true;
        if (hash() != other.hash()) return false;
        if (type_priority() != other.type_priority()) return false;
        return compare_same_type(other) == 0;
    }

引用了 SymbolicNode(), compare_same_type(), hash() , 以及 type_priority().

被这些函数引用 LMCAS::complementary_square(), LMCAS::anonymous_namespace{relation_store.cpp}::expr_equals(), LMCAS::match_recursive(), LMCAS::tf_remove_exp_factor() , 以及 LMCAS::tf_substitute_expr().

函数调用图:

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

◆ hash()

std::size_t LMCAS::SymbolicNode::hash ( ) const

inlineinherited

获取节点哈希值(带缓存).

返回: 哈希值

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

                           {
        if (!hash_computed.load(std::memory_order_acquire)) {
            std::size_t h = compute_hash();
            cached_hash.store(h, std::memory_order_relaxed);
            hash_computed.store(true, std::memory_order_release);
            return h;
        }
        return cached_hash.load(std::memory_order_relaxed);
    }

引用了 cached_hash, compute_hash() , 以及 hash_computed.

被这些函数引用 LMCAS::MatrixNode::compute_hash(), LMCAS::VariableNode::compute_hash() , 以及 equals().

函数调用图:

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

◆ is_number()

virtual bool LMCAS::SymbolicNode::is_number ( ) const

inlinevirtualinherited

被 LMCAS::NumberNode 重载.

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

201{ return false; }

◆ is_one()

virtual bool LMCAS::SymbolicNode::is_one ( ) const

inlinevirtualinherited

被 LMCAS::NumberNode 重载.

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

202{ return false; }

◆ is_positive()

virtual bool LMCAS::SymbolicNode::is_positive ( ) const

inlinevirtualinherited

被 LMCAS::NumberNode 重载.

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

204{ return false; }

◆ is_zero()

virtual bool LMCAS::SymbolicNode::is_zero ( ) const

inlinevirtualinherited

被 LMCAS::ComplexNode , 以及 LMCAS::NumberNode 重载.

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

203{ return false; }

被这些函数引用 LMCAS::complex_div_checked(), LMCAS::MatrixNode::compute_hash(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_complex(), LMCAS::is_analytic_impl(), LMCAS::is_euler_equation(), LMCAS::anonymous_namespace{matrix_quadratic_form.cpp}::reconstructs_expression(), LMCAS::anonymous_namespace{complex_analysis.cpp}::split_real_imag() , 以及 LMCAS::symbolic_poly_to_expr().

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

◆ normalize_operands()

std::vector< std::shared_ptr< const SymbolicNode > > LMCAS::MultiplyNode::normalize_operands ( std::vector< std::shared_ptr< const SymbolicNode > > ops )

inlinestaticprivate

在文件 arithmetic.hpp 第 145 行定义.

                                                          {
        if (ops.empty()) {
            throw std::invalid_argument("MultiplyNode requires at least one operand");
        }
        std::vector<std::shared_ptr<const SymbolicNode>> flattened;
        for (const auto& op : ops) {
            if (!op) {
                throw std::invalid_argument("MultiplyNode operand cannot be null");
            }
            if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(op)) {
                flattened.insert(flattened.end(), mul->operands_.begin(), mul->operands_.end());
            } else {
                flattened.push_back(op);
            }
        }
        const bool scalar_product = std::none_of(
            flattened.begin(), flattened.end(),
            [](const auto& factor) { return contains_matrix(*factor); });
        if (scalar_product) {
            std::sort(
                flattened.begin(), flattened.end(), compare_operands);
        }
        return flattened;
    }

引用了 compare_operands(), LMCAS::mul() , 以及 LMCAS::op.

被这些函数引用 MultiplyNode().

函数调用图:

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

◆ operands()

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

inlinenoexcept

在文件 arithmetic.hpp 第 177 行定义.

                                                                                  {
        return operands_;
    }

引用了 operands_.

被这些函数引用 LMCAS::anonymous_namespace{transcendental_rewrite.cpp}::FactorSimplification::append_product(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_product(), LMCAS::NormalizationVisitor::distribute_power(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::lambert_inner(), LMCAS::NormalizationVisitor::normalize_product_power(), LMCAS::anonymous_namespace{mixed_transcendental_classification.cpp}::product_degree(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::product_exp_multiplier(), LMCAS::anonymous_namespace{mixed_transcendental_search.cpp}::product_linear_coefficient(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::product_without(), LMCAS::product_without_factor(), LMCAS::anonymous_namespace{limit_result.cpp}::scaled_one_sided_limit(), LMCAS::separable_product(), LMCAS::transform_detail::anonymous_namespace{transform_support.cpp}::te_gaussian_product_rate(), LMCAS::anonymous_namespace{expr_serialization.cpp}::Writer::visit() , 以及 LMCAS::anonymous_namespace{mixed_transcendental_classification.cpp}::TranscendentalDetector::visit().

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

◆ type_priority()

int LMCAS::MultiplyNode::type_priority ( ) const

inlineoverridevirtual

实现了 LMCAS::SymbolicNode.

在文件 arithmetic.hpp 第 181 行定义.

181{ return 4; }

被这些函数引用 compute_hash().

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

类成员变量说明

◆ cached_hash

std::atomic<std::size_t> LMCAS::SymbolicNode::cached_hash {0}

mutableprotectedinherited

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

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

◆ hash_computed

std::atomic<bool> LMCAS::SymbolicNode::hash_computed {false}

mutableprotectedinherited

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

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

◆ LMCAS_AST_NODE_FACTORY_FRIEND

LMCAS::MultiplyNode::LMCAS_AST_NODE_FACTORY_FRIEND

private

在文件 arithmetic.hpp 第 136 行定义.

◆ operands_

const std::vector<std::shared_ptr<const SymbolicNode> > LMCAS::MultiplyNode::operands_

private

在文件 arithmetic.hpp 第 171 行定义.

被这些函数引用 MultiplyNode(), clone(), compare_same_type(), compute_hash() , 以及 operands().

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

src/internal/symbolic_ast/arithmetic.hpp
src/internal/symbolic_ast/matrix.hpp

Public 成员函数

Protected 成员函数

Protected 属性

Private 成员函数

静态 Private 成员函数

Private 属性

详细描述

构造及析构函数说明

◆ MultiplyNode()

成员函数说明

◆ accept()

◆ clone()

◆ compare()

◆ compare_operands()

◆ compare_same_type()

◆ compute_hash()

◆ contains_matrix()

◆ equals()

◆ hash()

◆ is_number()

◆ is_one()

◆ is_positive()

◆ is_zero()

◆ normalize_operands()

◆ operands()

◆ type_priority()

类成员变量说明

◆ cached_hash

◆ hash_computed

◆ LMCAS_AST_NODE_FACTORY_FRIEND

◆ operands_