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

类 LMCAS::LogicalNode 继承关系图:

LMCAS::LogicalNode 的协作图:

Public 类型
enum class	Op { And , Or , Not , Implies }

Public 成员函数
void	accept (LMCAS::detail::SymbolicVisitor &visitor) const override
std::shared_ptr< const SymbolicNode >	clone () const override
int	compare (const SymbolicNode &other) const
	与另一个节点进行全序比较.
int	compare_same_type (const SymbolicNode &other) const override
std::size_t	compute_hash () const override
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::shared_ptr< const SymbolicNode > &	left () const noexcept
Op	op () const noexcept
const std::shared_ptr< const SymbolicNode > &	right () const noexcept
int	type_priority () const override

静态 Public 成员函数
static std::string	op_to_string (Op op)
	将逻辑运算符转换为字符串表示。

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

Private 成员函数
	LogicalNode (std::shared_ptr< const SymbolicNode > l, std::shared_ptr< const SymbolicNode > r, Op o)

Private 属性
const std::shared_ptr< const SymbolicNode >	left_
	LMCAS_AST_NODE_FACTORY_FRIEND
const Op	op_
const std::shared_ptr< const SymbolicNode >	right_

详细描述

在文件 relations.hpp 第 73 行定义.

成员枚举类型说明

◆ Op

enum class LMCAS::LogicalNode::Op

strong

枚举值
And	逻辑与。
Or	逻辑或。
Not	一元逻辑非，right 为 nullptr。
Implies	逻辑蕴含 A ⇒ B。

在文件 relations.hpp 第 75 行定义.

                  {
        And,     /**< 逻辑与。 */
        Or,      /**< 逻辑或。 */
        Not,     /**< 一元逻辑非，right 为 nullptr。 */
        Implies  /**< 逻辑蕴含 A ⇒ B。 */
    };

构造及析构函数说明

◆ LogicalNode()

LMCAS::LogicalNode::LogicalNode	(	std::shared_ptr< const SymbolicNode >	l,
		std::shared_ptr< const SymbolicNode >	r,
		Op	o )

inlineprivate

在文件 relations.hpp 第 89 行定义.

        : left_(std::move(l)), right_(std::move(r)), op_(o) {
        if (!left_) {
            throw std::invalid_argument("LogicalNode left operand cannot be null");
        }
        if (op_ != Op::Not && !right_) {
            throw std::invalid_argument("LogicalNode binary right operand cannot be null");
        }
    }

引用了 left_, Not, op_, LMCAS::r , 以及 right_.

被这些函数引用 compare_same_type().

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

成员函数说明

◆ accept()

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

inlineoverridevirtual

实现了 LMCAS::SymbolicNode.

在文件 relations.hpp 第 104 行定义.

104{ 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::LogicalNode::clone ( ) const

inlineoverridevirtual

实现了 LMCAS::SymbolicNode.

在文件 relations.hpp 第 106 行定义.

                                                             {
        return LMCAS::detail::make_node<LogicalNode>(
            left_ ? left_->clone() : nullptr,
            right_ ? right_->clone() : nullptr,
            op_);
    }

引用了 left_, LMCAS::detail::make_node(), op_ , 以及 right_.

函数调用图:

◆ 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_same_type()

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

inlineoverridevirtual

实现了 LMCAS::SymbolicNode.

在文件 relations.hpp 第 122 行定义.

                                                                    {
        const auto& o = static_cast<const LogicalNode&>(other);
        if (op_ != o.op_) {
            return (int)op_ < (int)o.op_ ? -1 : 1;
        }
        bool l_null = !left_;
        bool ol_null = !o.left_;
        if (l_null != ol_null) {
            return l_null ? -1 : 1;
        }
        if (!l_null) {
            int cmp = left_->compare(*o.left_);
            if (cmp != 0) {
                return cmp;
            }
        }
        bool r_null = !right_;
        bool or_null = !o.right_;
        if (r_null != or_null) {
            return r_null ? -1 : 1;
        }
        if (!r_null) {
            return right_->compare(*o.right_);
        }
        return 0;
    }

引用了 LogicalNode(), LMCAS::SymbolicNode::SymbolicNode(), left_, op_ , 以及 right_.

函数调用图:

◆ compute_hash()

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

inlineoverridevirtual

实现了 LMCAS::SymbolicNode.

在文件 relations.hpp 第 115 行定义.

                                            {
        std::size_t h = std::hash<int>{}((int)op_);
        if (left_) hash_combine(h, left_->hash());
        if (right_) hash_combine(h, right_->hash());
        return h;
    }

引用了 LMCAS::hash_combine(), left_, op_ , 以及 right_.

函数调用图:

◆ 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().

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

◆ left()

const std::shared_ptr< const SymbolicNode > & LMCAS::LogicalNode::left ( ) const

inlinenoexcept

在文件 relations.hpp 第 100 行定义.

100{ return left_; }

引用了 left_.

被这些函数引用 LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::logical_condition_truth(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::logical_predicate_truth(), LMCAS::anonymous_namespace{expr_serialization.cpp}::Writer::visit() , 以及 LMCAS::anonymous_namespace{mixed_transcendental_classification.cpp}::TranscendentalDetector::visit().

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

◆ op()

Op LMCAS::LogicalNode::op ( ) const

inlinenoexcept

在文件 relations.hpp 第 102 行定义.

102{ return op_; }

引用了 op_.

被这些函数引用 LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::logical_condition_truth(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::logical_predicate_truth(), op_to_string() , 以及 LMCAS::anonymous_namespace{expr_serialization.cpp}::Writer::visit().

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

◆ op_to_string()

std::string LMCAS::LogicalNode::op_to_string ( Op op )

inlinestatic

将逻辑运算符转换为字符串表示。

参数

op 逻辑运算符

返回: "And"、"Or"、"Not" 或 "Implies"

在文件 relations.hpp 第 154 行定义.

                                         {
        switch(op) {
            case Op::And: return "And";
            case Op::Or: return "Or";
            case Op::Not: return "Not";
            case Op::Implies: return "Implies";
            default: return "?";
        }
    }

引用了 And, Implies, Not, op() , 以及 Or.

函数调用图:

◆ right()

const std::shared_ptr< const SymbolicNode > & LMCAS::LogicalNode::right ( ) const

inlinenoexcept

在文件 relations.hpp 第 101 行定义.

101{ return right_; }

引用了 right_.

被这些函数引用 LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::logical_condition_truth(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::logical_predicate_truth(), LMCAS::anonymous_namespace{expr_serialization.cpp}::Writer::visit() , 以及 LMCAS::anonymous_namespace{mixed_transcendental_classification.cpp}::TranscendentalDetector::visit().

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

◆ type_priority()

int LMCAS::LogicalNode::type_priority ( ) const

inlineoverridevirtual

实现了 LMCAS::SymbolicNode.

在文件 relations.hpp 第 113 行定义.

113{ return 101; }

类成员变量说明

◆ 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().

◆ left_

const std::shared_ptr<const SymbolicNode> LMCAS::LogicalNode::left_

private

在文件 relations.hpp 第 85 行定义.

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

◆ LMCAS_AST_NODE_FACTORY_FRIEND

LMCAS::LogicalNode::LMCAS_AST_NODE_FACTORY_FRIEND

private

在文件 relations.hpp 第 83 行定义.

◆ op_

const Op LMCAS::LogicalNode::op_

private

在文件 relations.hpp 第 87 行定义.

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

◆ right_

const std::shared_ptr<const SymbolicNode> LMCAS::LogicalNode::right_

private

在文件 relations.hpp 第 86 行定义.

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

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

src/internal/symbolic_ast/relations.hpp

Public 类型

Public 成员函数

静态 Public 成员函数

Protected 属性

Private 成员函数

Private 属性

详细描述

成员枚举类型说明

◆ Op

构造及析构函数说明

◆ LogicalNode()

成员函数说明

◆ accept()

◆ clone()

◆ compare()

◆ compare_same_type()

◆ compute_hash()

◆ equals()

◆ hash()

◆ is_number()

◆ is_one()

◆ is_positive()

◆ is_zero()

◆ left()

◆ op()

◆ op_to_string()

◆ right()

◆ type_priority()

类成员变量说明

◆ cached_hash

◆ hash_computed

◆ left_

◆ LMCAS_AST_NODE_FACTORY_FRIEND

◆ op_

◆ right_