Class Expr¶

Defined in File expr.hpp

Nested Relationships¶

Nested Types¶

Inheritance Relationships¶

Base Type¶

public std::enable_shared_from_this< Expr >

Derived Types¶

public sequant::NormalOperatorSequence< S > (Template Class NormalOperatorSequence)
public sequant::Operator< S > (Template Class Operator)
public sequant::Operator< void, S > (Template Class Operator)
public sequant::Constant (Class Constant)
public sequant::NormalOperatorSequence< S > (Template Class NormalOperatorSequence)
public sequant::Operator< S > (Template Class Operator)
public sequant::Power (Class Power)
public sequant::Product (Class Product)
public sequant::Sum (Class Sum)
public sequant::Tensor (Class Tensor)
public sequant::Variable (Class Variable)
public sequant::mbpt::Operator< void, S > (Template Class Operator< void, S >)

Class Documentation¶

class Expr : public std::enable_shared_from_this<Expr>¶

Base expression class.

Expr represents the interface needed to form expression trees. Classes that represent expressions should publicly derive from this class. Each Expr on a tree has links to its children Expr objects. The lifetime of Expr objects is expected to be managed by std::shared_ptr . Expr is an Iterable over subexpressions (each of which is an Expr itself). More precisely, Expr meets the SizedIterable concept (see https://raw.githubusercontent.com/ericniebler/range-v3/master/doc/std/D4128.md). Specifically, iterators to subexpressions dereference to ExprPtr. Since Expr is a range, it provides begin/end/etc. that can participate in overloads with other functions in the derived class. Consider a Container class derived from a BaseContainer class:

template <typename T> class Container : public BaseContainer, public Expr
{
  // WARNING: BaseContainer::begin clashes with Expr::begin
  // WARNING: BaseContainer::end clashes with Expr::end
  // etc.
};

There are two possible scenarios:

if Container is a container of Expr objects, BaseContainer will iterate over ExprPtr objects already and both ranges will be equivalent; it is sufficient to add using BaseContainer::begin, etc. to Container’s public API.
if Container is a container of non-Expr objects, iteration over BaseContainer is likely to be more commonly used in practice, hence again adding using BaseContainer::begin, etc. will suffice. To be able to iterate over subexpression range (in this case it is empty) Expr provides Expr::expr member to cast to Expr:
```
Container c(...);
for(const auto& e: c) {  // iterates over elements of BaseContainer
}
for(const auto& e: c.expr()) {  // iterates over subexpressions
}
```

Subclassed by sequant::NormalOperatorSequence< S >, sequant::Operator< S >, sequant::Operator< void, S >, sequant::Constant, sequant::NormalOperatorSequence< S >, sequant::Operator< S >, sequant::Power, sequant::Product, sequant::Sum, sequant::Tensor, sequant::Variable, sequant::mbpt::Operator< void, S >

Public Types

using hash_type = std::size_t¶

using type_id_type = int¶

Public Functions

Expr() = default¶

virtual ~Expr() = default¶

inline bool is_atom() const¶

Returns:: true if this is a leaf

inline virtual bool is_zero() const¶

Returns:: true if this is zero

virtual std::wstring to_latex() const¶

Returns:: the string representation of this in the LaTeX format

virtual ExprPtr clone() const = 0¶

Returns:: a clone of this object, i.e. an object that is equal to this

inline ExprPtr exprptr_from_this()¶

like Expr::shared_from_this, but returns ExprPtr

Returns:: a shared_ptr to this object wrapped into ExprPtr, if this object is already managed by a shared_ptr, else returns a shared_ptr to a clone of this object wrapped into ExprPtr

inline ExprPtr exprptr_from_this() const¶

like Expr::shared_from_this, but returns ExprPtr

Returns:: a shared_ptr to this object wrapped into ExprPtr, if this object is already managed by a shared_ptr, else returns a shared_ptr to a clone of this object wrapped into ExprPtr

inline virtual ExprPtr canonicalize(CanonicalizeOptions = CanonicalizeOptions::default_options())¶

Canonicalizes this and returns the byproduct of canonicalization (e.g. phase)

Returns:: the byproduct of canonicalization, or nullptr if no byproduct generated

inline virtual ExprPtr rapid_canonicalize(CanonicalizeOptions = CanonicalizeOptions::default_options().copy_and_set(CanonicalizationMethod::Rapid))¶

Performs approximate, but fast, canonicalization of this and returns the byproduct of canonicalization (e.g. phase) The default is to use canonicalize(), unless overridden in the derived class.

Returns:: the byproduct of canonicalization, or nullptr if no byproduct generated

template<typename Visitor> inline bool visit(Visitor &&visitor, const bool atoms_only = false)¶

recursively visit this expression, i.e. call visitor on each subexpression in depth-first fashion.