Class Expr¶

Defined in File expr.hpp

Nested Relationships¶

Nested Types¶

Inheritance Relationships¶

Base Types¶

public std::enable_shared_from_this< Expr >
public ranges::view_facade< 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::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>, public ranges::view_facade<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::Product, sequant::Sum, sequant::Tensor, sequant::Variable, sequant::mbpt::Operator< void, S >

in-place arithmetic operators

Virtual in-place arithmetic operators to be overridden in expressions for which these make sense.

virtual Expr &operator*=(const Expr &that)¶

in-place multiply *this by that

Throws:: std::logic_error – if not implemented for this class, or cannot be implemented for the particular that
Returns:: reference to *this

virtual Expr &operator^=(const Expr &that)¶

in-place non-commutatively-multiply *this by that

Throws:: std::logic_error – if not implemented for this class, or cannot be implemented for the particular that
Returns:: reference to *this

virtual Expr &operator+=(const Expr &that)¶

in-place add that to *this

Throws:: std::logic_error – if not implemented for this class, or cannot be implemented for the particular that
Returns:: reference to *this

virtual Expr &operator-=(const Expr &that)¶

in-place subtract that from *this

Throws:: std::logic_error – if not implemented for this class, or cannot be implemented for the particular that
Returns:: reference to *this

Public Types

using range_type = ranges::view_facade<Expr>¶

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

virtual std::wstring to_latex() const¶

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

virtual std::wstring to_wolfram() const¶

Returns:: the string representation of this in the Wolfram Language format

virtual ExprPtr clone() const¶

Note

- must be overridden in the derived class.

the default implementation throws an exception

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

Throws:: std::bad_weak_ptr – if this object is not managed by a shared_ptr
Returns:: a shared_ptr to this object wrapped into ExprPtr

inline ExprPtr exprptr_from_this() const¶

like Expr::shared_from_this, but returns ExprPtr

Throws:: std::bad_weak_ptr – if this object is not managed by a shared_ptr
Returns:: a shared_ptr to this object wrapped into ExprPtr

inline virtual ExprPtr canonicalize()¶

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

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

inline virtual ExprPtr rapid_canonicalize()¶

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

Returns:: the biproduct of canonicalization, or nullptr if no biproduct 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.