lala::pc::Inequality< AD, Allocator, neg > Class Template Reference

#include <formula.hpp>

Public Types
using	A = AD
using	U = typename A::local_universe
using	allocator_type = Allocator
using	this_type = Inequality<A, allocator_type, neg>
using	sub_type = Term<A, allocator_type>

Public Member Functions
CUDA	Inequality (sub_type &&left, sub_type &&right)
CUDA	Inequality (this_type &&other)
template<class A2 , class Alloc2 >
CUDA	Inequality (const Inequality< A2, Alloc2, neg > &other, const allocator_type &alloc)
CUDA local::B	ask (const A &a) const
CUDA local::B	nask (const A &a) const
CUDA bool	deduce (A &a) const
CUDA bool	contradeduce (A &a) const
CUDA NI void	print (const A &a) const
template<class Env , class Allocator2 = typename Env::allocator_type>
CUDA NI TFormula< Allocator2 >	deinterpret (const A &a, const Env &env, AType apc, Allocator2 allocator=Allocator2()) const
CUDA size_t	length () const

Friends
template<class A2 , class Alloc2 , bool neg2>
class	Inequality

Detailed Description

template<class AD, class Allocator, bool neg>
class lala::pc::Inequality< AD, Allocator, neg >

Implement the constraint t1 <= t2 or t1 > t2 if neg is true.

Member Typedef Documentation

A

template<class AD , class Allocator , bool neg>

using lala::pc::Inequality< AD, Allocator, neg >::A = AD

U

template<class AD , class Allocator , bool neg>

using lala::pc::Inequality< AD, Allocator, neg >::U = typename A::local_universe

allocator_type

template<class AD , class Allocator , bool neg>

using lala::pc::Inequality< AD, Allocator, neg >::allocator_type = Allocator

this_type

template<class AD , class Allocator , bool neg>

using lala::pc::Inequality< AD, Allocator, neg >::this_type = Inequality<A, allocator_type, neg>

sub_type

template<class AD , class Allocator , bool neg>

using lala::pc::Inequality< AD, Allocator, neg >::sub_type = Term<A, allocator_type>

Constructor & Destructor Documentation

Inequality() [1/3]

template<class AD , class Allocator , bool neg>

CUDA lala::pc::Inequality< AD, Allocator, neg >::Inequality ( sub_type && left, sub_type && right )

inline

Inequality() [2/3]

template<class AD , class Allocator , bool neg>

CUDA lala::pc::Inequality< AD, Allocator, neg >::Inequality ( this_type && other )

inline

Inequality() [3/3]

template<class AD , class Allocator , bool neg>

template<class A2 , class Alloc2 >

CUDA lala::pc::Inequality< AD, Allocator, neg >::Inequality ( const Inequality< A2, Alloc2, neg > & other, const allocator_type & alloc )

inline

Member Function Documentation

ask()

template<class AD , class Allocator , bool neg>

CUDA local::B lala::pc::Inequality< AD, Allocator, neg >::ask ( const A & a ) const

inline

nask()

template<class AD , class Allocator , bool neg>

CUDA local::B lala::pc::Inequality< AD, Allocator, neg >::nask ( const A & a ) const

inline

deduce()

template<class AD , class Allocator , bool neg>

CUDA bool lala::pc::Inequality< AD, Allocator, neg >::deduce ( A & a ) const

inline

contradeduce()

template<class AD , class Allocator , bool neg>

CUDA bool lala::pc::Inequality< AD, Allocator, neg >::contradeduce ( A & a ) const

inline

print()

template<class AD , class Allocator , bool neg>

CUDA NI void lala::pc::Inequality< AD, Allocator, neg >::print ( const A & a ) const

inline

deinterpret()

template<class AD , class Allocator , bool neg>

template<class Env , class Allocator2 = typename Env::allocator_type>

CUDA NI TFormula< Allocator2 > lala::pc::Inequality< AD, Allocator, neg >::deinterpret ( const A & a, const Env & env, AType apc, Allocator2 allocator = Allocator2() ) const

inline

length()

template<class AD , class Allocator , bool neg>

CUDA size_t lala::pc::Inequality< AD, Allocator, neg >::length ( ) const

inline

Friends And Related Symbol Documentation

Inequality

template<class AD , class Allocator , bool neg>

template<class A2 , class Alloc2 , bool neg2>

friend class Inequality

friend

---

The documentation for this class was generated from the following file:

• include/lala/formula.hpp