Lattice land propagators completion library
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | Friends | List of all members
lala::pc::Term< AD, Allocator > Class Template Reference

#include <terms.hpp>

Public Types

using A = AD
 
using U = typename A::local_universe
 
using allocator_type = Allocator
 
using this_type = Term<A, allocator_type>
 
using this_ptr = battery::unique_ptr<Term<A, allocator_type>, allocator_type>
 
using formula_ptr = battery::unique_ptr<Formula<A, allocator_type>, allocator_type>
 
using Neg = Unary<A, NegOp<U>, allocator_type>
 
using Abs = Unary<A, AbsOp<U>, allocator_type>
 
using Add = Binary<A, GroupAdd<U>, allocator_type>
 
using Sub = Binary<A, GroupSub<U>, allocator_type>
 
using Mul = Binary<A, GroupMul<U, EDIV>, allocator_type>
 
using TDiv = Binary<A, GroupDiv<U, TDIV>, allocator_type>
 
using FDiv = Binary<A, GroupDiv<U, FDIV>, allocator_type>
 
using CDiv = Binary<A, GroupDiv<U, CDIV>, allocator_type>
 
using EDiv = Binary<A, GroupDiv<U, EDIV>, allocator_type>
 
using Min = Binary<A, GroupMinMax<U, MIN>, allocator_type>
 
using Max = Binary<A, GroupMinMax<U, MAX>, allocator_type>
 
using NaryAdd = Nary<Add>
 
using NaryMul = Nary<Mul>
 

Public Member Functions

 Term ()=default
 
 Term (this_type &&)=default
 
this_type & operator= (this_type &&)=default
 
template<class A2 , class Alloc2 >
CUDA Term (const Term< A2, Alloc2 > &other, const allocator_type &allocator=allocator_type())
 
CUDA bool is (size_t kind) const
 
CUDA bool embed (A &a, const U &u) const
 
CUDA void project (const A &a, U &r) const
 
CUDA void print (const A &a) const
 
template<class Env , class Allocator2 = typename Env::allocator_type>
CUDA TFormula< Allocator2 > deinterpret (const A &a, const Env &env, AType apc, Allocator2 allocator=Allocator2()) const
 
CUDA size_t length () const
 

Static Public Member Functions

template<size_t I, class SubTerm >
static CUDA this_type make (SubTerm &&sub_term)
 
static CUDA this_type make_var (const AVar &avar)
 
static CUDA this_type make_constant (U &&sub_term)
 
static CUDA this_type make_formula (formula_ptr &&sub_term)
 
static CUDA this_type make_neg (this_ptr &&sub_term)
 
static CUDA this_type make_abs (this_ptr &&sub_term)
 
static CUDA this_type make_add (this_ptr &&left, this_ptr &&right)
 
static CUDA this_type make_sub (this_ptr &&left, this_ptr &&right)
 
static CUDA this_type make_mul (this_ptr &&left, this_ptr &&right)
 
static CUDA this_type make_tdiv (this_ptr &&left, this_ptr &&right)
 
static CUDA this_type make_fdiv (this_ptr &&left, this_ptr &&right)
 
static CUDA this_type make_cdiv (this_ptr &&left, this_ptr &&right)
 
static CUDA this_type make_ediv (this_ptr &&left, this_ptr &&right)
 
static CUDA this_type make_min (this_ptr &&left, this_ptr &&right)
 
static CUDA this_type make_max (this_ptr &&left, this_ptr &&right)
 
static CUDA this_type make_naryadd (battery::vector< this_type, allocator_type > &&sub_terms)
 
static CUDA this_type make_narymul (battery::vector< this_type, allocator_type > &&sub_terms)
 

Static Public Attributes

static constexpr size_t IVar = 0
 
static constexpr size_t IConstant = IVar + 1
 
static constexpr size_t IFormula = IConstant + 1
 
static constexpr size_t INeg = IFormula + 1
 
static constexpr size_t IAbs = INeg + 1
 
static constexpr size_t IAdd = IAbs + 1
 
static constexpr size_t ISub = IAdd + 1
 
static constexpr size_t IMul = ISub + 1
 
static constexpr size_t ITDiv = IMul + 1
 
static constexpr size_t IFDiv = ITDiv + 1
 
static constexpr size_t ICDiv = IFDiv + 1
 
static constexpr size_t IEDiv = ICDiv + 1
 
static constexpr size_t IMin = IEDiv + 1
 
static constexpr size_t IMax = IMin + 1
 
static constexpr size_t INaryAdd = IMax + 1
 
static constexpr size_t INaryMul = INaryAdd + 1
 

Friends

template<class A2 , class Alloc2 >
class Term
 

Member Typedef Documentation

◆ A

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::A = AD

◆ U

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::U = typename A::local_universe

◆ allocator_type

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::allocator_type = Allocator

◆ this_type

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::this_type = Term<A, allocator_type>

◆ this_ptr

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::this_ptr = battery::unique_ptr<Term<A, allocator_type>, allocator_type>

◆ formula_ptr

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::formula_ptr = battery::unique_ptr<Formula<A, allocator_type>, allocator_type>

◆ Neg

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::Neg = Unary<A, NegOp<U>, allocator_type>

◆ Abs

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::Abs = Unary<A, AbsOp<U>, allocator_type>

◆ Add

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::Add = Binary<A, GroupAdd<U>, allocator_type>

◆ Sub

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::Sub = Binary<A, GroupSub<U>, allocator_type>

◆ Mul

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::Mul = Binary<A, GroupMul<U, EDIV>, allocator_type>

◆ TDiv

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::TDiv = Binary<A, GroupDiv<U, TDIV>, allocator_type>

◆ FDiv

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::FDiv = Binary<A, GroupDiv<U, FDIV>, allocator_type>

◆ CDiv

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::CDiv = Binary<A, GroupDiv<U, CDIV>, allocator_type>

◆ EDiv

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::EDiv = Binary<A, GroupDiv<U, EDIV>, allocator_type>

◆ Min

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::Min = Binary<A, GroupMinMax<U, MIN>, allocator_type>

◆ Max

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::Max = Binary<A, GroupMinMax<U, MAX>, allocator_type>

◆ NaryAdd

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::NaryAdd = Nary<Add>

◆ NaryMul

template<class AD , class Allocator >
using lala::pc::Term< AD, Allocator >::NaryMul = Nary<Mul>

Constructor & Destructor Documentation

◆ Term() [1/3]

template<class AD , class Allocator >
lala::pc::Term< AD, Allocator >::Term ( )
default

◆ Term() [2/3]

template<class AD , class Allocator >
lala::pc::Term< AD, Allocator >::Term ( this_type && )
default

◆ Term() [3/3]

template<class AD , class Allocator >
template<class A2 , class Alloc2 >
CUDA lala::pc::Term< AD, Allocator >::Term ( const Term< A2, Alloc2 > & other,
const allocator_type & allocator = allocator_type() )
inline

Member Function Documentation

◆ operator=()

template<class AD , class Allocator >
this_type & lala::pc::Term< AD, Allocator >::operator= ( this_type && )
default

◆ is()

template<class AD , class Allocator >
CUDA bool lala::pc::Term< AD, Allocator >::is ( size_t kind) const
inline

◆ make()

template<class AD , class Allocator >
template<size_t I, class SubTerm >
static CUDA this_type lala::pc::Term< AD, Allocator >::make ( SubTerm< AD, Allocator > && sub_term)
inlinestatic

◆ make_var()

template<class AD , class Allocator >
static CUDA this_type lala::pc::Term< AD, Allocator >::make_var ( const AVar & avar)
inlinestatic

◆ make_constant()

template<class AD , class Allocator >
static CUDA this_type lala::pc::Term< AD, Allocator >::make_constant ( U && sub_term)
inlinestatic

◆ make_formula()

template<class AD , class Allocator >
static CUDA this_type lala::pc::Term< AD, Allocator >::make_formula ( formula_ptr && sub_term)
inlinestatic

◆ make_neg()

template<class AD , class Allocator >
static CUDA this_type lala::pc::Term< AD, Allocator >::make_neg ( this_ptr && sub_term)
inlinestatic

◆ make_abs()

template<class AD , class Allocator >
static CUDA this_type lala::pc::Term< AD, Allocator >::make_abs ( this_ptr && sub_term)
inlinestatic

◆ make_add()

template<class AD , class Allocator >
static CUDA this_type lala::pc::Term< AD, Allocator >::make_add ( this_ptr && left,
this_ptr && right )
inlinestatic

◆ make_sub()

template<class AD , class Allocator >
static CUDA this_type lala::pc::Term< AD, Allocator >::make_sub ( this_ptr && left,
this_ptr && right )
inlinestatic

◆ make_mul()

template<class AD , class Allocator >
static CUDA this_type lala::pc::Term< AD, Allocator >::make_mul ( this_ptr && left,
this_ptr && right )
inlinestatic

◆ make_tdiv()

template<class AD , class Allocator >
static CUDA this_type lala::pc::Term< AD, Allocator >::make_tdiv ( this_ptr && left,
this_ptr && right )
inlinestatic

◆ make_fdiv()

template<class AD , class Allocator >
static CUDA this_type lala::pc::Term< AD, Allocator >::make_fdiv ( this_ptr && left,
this_ptr && right )
inlinestatic

◆ make_cdiv()

template<class AD , class Allocator >
static CUDA this_type lala::pc::Term< AD, Allocator >::make_cdiv ( this_ptr && left,
this_ptr && right )
inlinestatic

◆ make_ediv()

template<class AD , class Allocator >
static CUDA this_type lala::pc::Term< AD, Allocator >::make_ediv ( this_ptr && left,
this_ptr && right )
inlinestatic

◆ make_min()

template<class AD , class Allocator >
static CUDA this_type lala::pc::Term< AD, Allocator >::make_min ( this_ptr && left,
this_ptr && right )
inlinestatic

◆ make_max()

template<class AD , class Allocator >
static CUDA this_type lala::pc::Term< AD, Allocator >::make_max ( this_ptr && left,
this_ptr && right )
inlinestatic

◆ make_naryadd()

template<class AD , class Allocator >
static CUDA this_type lala::pc::Term< AD, Allocator >::make_naryadd ( battery::vector< this_type, allocator_type > && sub_terms)
inlinestatic

◆ make_narymul()

template<class AD , class Allocator >
static CUDA this_type lala::pc::Term< AD, Allocator >::make_narymul ( battery::vector< this_type, allocator_type > && sub_terms)
inlinestatic

◆ embed()

template<class AD , class Allocator >
CUDA bool lala::pc::Term< AD, Allocator >::embed ( A & a,
const U & u ) const
inline

◆ project()

template<class AD , class Allocator >
CUDA void lala::pc::Term< AD, Allocator >::project ( const A & a,
U & r ) const
inline

◆ print()

template<class AD , class Allocator >
CUDA void lala::pc::Term< AD, Allocator >::print ( const A & a) const
inline

◆ deinterpret()

template<class AD , class Allocator >
template<class Env , class Allocator2 = typename Env::allocator_type>
CUDA TFormula< Allocator2 > lala::pc::Term< AD, Allocator >::deinterpret ( const A & a,
const Env & env,
AType apc,
Allocator2 allocator = Allocator2() ) const
inline

◆ length()

template<class AD , class Allocator >
CUDA size_t lala::pc::Term< AD, Allocator >::length ( ) const
inline

Friends And Related Symbol Documentation

◆ Term

template<class AD , class Allocator >
template<class A2 , class Alloc2 >
friend class Term
friend

Member Data Documentation

◆ IVar

template<class AD , class Allocator >
size_t lala::pc::Term< AD, Allocator >::IVar = 0
staticconstexpr

◆ IConstant

template<class AD , class Allocator >
size_t lala::pc::Term< AD, Allocator >::IConstant = IVar + 1
staticconstexpr

◆ IFormula

template<class AD , class Allocator >
size_t lala::pc::Term< AD, Allocator >::IFormula = IConstant + 1
staticconstexpr

◆ INeg

template<class AD , class Allocator >
size_t lala::pc::Term< AD, Allocator >::INeg = IFormula + 1
staticconstexpr

◆ IAbs

template<class AD , class Allocator >
size_t lala::pc::Term< AD, Allocator >::IAbs = INeg + 1
staticconstexpr

◆ IAdd

template<class AD , class Allocator >
size_t lala::pc::Term< AD, Allocator >::IAdd = IAbs + 1
staticconstexpr

◆ ISub

template<class AD , class Allocator >
size_t lala::pc::Term< AD, Allocator >::ISub = IAdd + 1
staticconstexpr

◆ IMul

template<class AD , class Allocator >
size_t lala::pc::Term< AD, Allocator >::IMul = ISub + 1
staticconstexpr

◆ ITDiv

template<class AD , class Allocator >
size_t lala::pc::Term< AD, Allocator >::ITDiv = IMul + 1
staticconstexpr

◆ IFDiv

template<class AD , class Allocator >
size_t lala::pc::Term< AD, Allocator >::IFDiv = ITDiv + 1
staticconstexpr

◆ ICDiv

template<class AD , class Allocator >
size_t lala::pc::Term< AD, Allocator >::ICDiv = IFDiv + 1
staticconstexpr

◆ IEDiv

template<class AD , class Allocator >
size_t lala::pc::Term< AD, Allocator >::IEDiv = ICDiv + 1
staticconstexpr

◆ IMin

template<class AD , class Allocator >
size_t lala::pc::Term< AD, Allocator >::IMin = IEDiv + 1
staticconstexpr

◆ IMax

template<class AD , class Allocator >
size_t lala::pc::Term< AD, Allocator >::IMax = IMin + 1
staticconstexpr

◆ INaryAdd

template<class AD , class Allocator >
size_t lala::pc::Term< AD, Allocator >::INaryAdd = IMax + 1
staticconstexpr

◆ INaryMul

template<class AD , class Allocator >
size_t lala::pc::Term< AD, Allocator >::INaryMul = INaryAdd + 1
staticconstexpr
The documentation for this class was generated from the following file: