Parma_Polyhedra_Library::Poly_Con_Relation Class Reference
[C++ Language Interface]

The relation between a polyhedron and a constraint. More...

#include <Poly_Con_Relation.defs.hh>

List of all members.

Public Member Functions

flags_t get_flags () const
 Access the internal flags: this is needed for some language interfaces.
void ascii_dump () const
 Writes to std::cerr an ASCII representation of *this.
void ascii_dump (std::ostream &s) const
 Writes to s an ASCII representation of *this.
void print () const
 Prints *this to std::cerr using operator<<.
bool implies (const Poly_Con_Relation &y) const
 True if and only if *this implies y.
bool OK () const
 Checks if all the invariants are satisfied.

Static Public Member Functions

static Poly_Con_Relation nothing ()
 The assertion that says nothing.
static Poly_Con_Relation is_disjoint ()
 The polyhedron and the set of points satisfying the constraint are disjoint.
static Poly_Con_Relation strictly_intersects ()
 The polyhedron intersects the set of points satisfying the constraint, but it is not included in it.
static Poly_Con_Relation is_included ()
 The polyhedron is included in the set of points satisfying the constraint.
static Poly_Con_Relation saturates ()
 The polyhedron is included in the set of points saturating the constraint.

Private Types

typedef unsigned int flags_t
 Poly_Con_Relation is implemented by means of a finite bitset.

Private Member Functions

 Poly_Con_Relation (flags_t mask)
 Construct from a bit-mask.

Static Private Member Functions

static bool implies (flags_t x, flags_t y)
 True if and only if the conjunction x implies the conjunction y.

Private Attributes

flags_t flags
 This holds the current bitset.

Static Private Attributes

static const flags_t EVERYTHING
 All assertions together.
Bit-masks for the individual assertions

static const flags_t NOTHING = 0U
static const flags_t IS_DISJOINT = 1U << 0
static const flags_t STRICTLY_INTERSECTS = 1U << 1
static const flags_t IS_INCLUDED = 1U << 2
static const flags_t SATURATES = 1U << 3

Friends

bool operator== (const Poly_Con_Relation &x, const Poly_Con_Relation &y)
 True if and only if x and y are logically equivalent.
bool operator!= (const Poly_Con_Relation &x, const Poly_Con_Relation &y)
 True if and only if x and y are not logically equivalent.
Poly_Con_Relation operator&& (const Poly_Con_Relation &x, const Poly_Con_Relation &y)
 Yields the logical conjunction of x and y.
Poly_Con_Relation operator- (const Poly_Con_Relation &x, const Poly_Con_Relation &y)
 Yields the assertion with all the conjuncts of x that are not in y.
std::ostream & Parma_Polyhedra_Library::IO_Operators::operator<< (std::ostream &s, const Poly_Con_Relation &r)

Related Functions

(Note that these are not member functions.)



std::ostream & operator<< (std::ostream &s, const Poly_Con_Relation &r)
 Output operator.

Detailed Description

The relation between a polyhedron and a constraint.

This class implements conjunctions of assertions on the relation between a polyhedron and a constraint.

Definition at line 73 of file Poly_Con_Relation.defs.hh.


Member Typedef Documentation

Poly_Con_Relation is implemented by means of a finite bitset.

Definition at line 76 of file Poly_Con_Relation.defs.hh.


Constructor & Destructor Documentation

Parma_Polyhedra_Library::Poly_Con_Relation::Poly_Con_Relation ( flags_t  mask  )  [inline, private]

Construct from a bit-mask.

Definition at line 30 of file Poly_Con_Relation.inlines.hh.

Referenced by is_disjoint(), is_included(), nothing(), saturates(), and strictly_intersects().

00031   : flags(mask) {
00032 }


Member Function Documentation

void Parma_Polyhedra_Library::Poly_Con_Relation::ascii_dump ( std::ostream &  s  )  const

Writes to s an ASCII representation of *this.

Definition at line 35 of file Poly_Con_Relation.cc.

References flags, implies(), IS_DISJOINT, IS_INCLUDED, NOTHING, SATURATES, and STRICTLY_INTERSECTS.

00035                                                     {
00036   flags_t f = flags;
00037   if (f == NOTHING) {
00038     s << "NOTHING";
00039     return;
00040   }
00041 
00042   while (true) {
00043     if (implies(f, IS_DISJOINT)) {
00044       s << "IS_DISJOINT";
00045       f &= ~IS_DISJOINT;
00046     }
00047     else if (implies(f, STRICTLY_INTERSECTS)) {
00048       s << "STRICTLY_INTERSECTS";
00049       f &= ~STRICTLY_INTERSECTS;
00050     }
00051     else if (implies(f, IS_INCLUDED)) {
00052       s << "IS_INCLUDED";
00053       f &= ~IS_INCLUDED;
00054     }
00055     else if (implies(f, SATURATES)) {
00056       s << "SATURATES";
00057       f &= ~SATURATES;
00058     }
00059     if (f != NOTHING)
00060       s << " & ";
00061     else
00062       break;
00063   }
00064 }

void Parma_Polyhedra_Library::Poly_Con_Relation::ascii_dump (  )  const

Writes to std::cerr an ASCII representation of *this.

Poly_Con_Relation::flags_t Parma_Polyhedra_Library::Poly_Con_Relation::get_flags (  )  const [inline]

Access the internal flags: this is needed for some language interfaces.

Definition at line 35 of file Poly_Con_Relation.inlines.hh.

References flags.

00035                                    {
00036   return flags;
00037 }

bool Parma_Polyhedra_Library::Poly_Con_Relation::implies ( const Poly_Con_Relation y  )  const [inline]

True if and only if *this implies y.

Definition at line 70 of file Poly_Con_Relation.inlines.hh.

References flags, and implies().

00070                                                            {
00071   return implies(flags, y.flags);
00072 }

bool Parma_Polyhedra_Library::Poly_Con_Relation::implies ( flags_t  x,
flags_t  y 
) [inline, static, private]
Poly_Con_Relation Parma_Polyhedra_Library::Poly_Con_Relation::is_disjoint (  )  [inline, static]
Poly_Con_Relation Parma_Polyhedra_Library::Poly_Con_Relation::is_included (  )  [inline, static]

The polyhedron is included in the set of points satisfying the constraint.

Definition at line 55 of file Poly_Con_Relation.inlines.hh.

References IS_INCLUDED, and Poly_Con_Relation().

Referenced by Parma_Polyhedra_Library::Polyhedron::BFT00_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::Polyhedron::BHZ09_C_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::Polyhedron::BHZ09_NNC_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::Octagonal_Shape< T >::difference_assign(), Parma_Polyhedra_Library::Grid::difference_assign(), Parma_Polyhedra_Library::BD_Shape< T >::difference_assign(), Parma_Polyhedra_Library::Box< ITV >::get_limiting_box(), Parma_Polyhedra_Library::interval_relation(), Parma_Polyhedra_Library::Grid::limited_congruence_extrapolation_assign(), Parma_Polyhedra_Library::Grid::limited_extrapolation_assign(), Parma_Polyhedra_Library::Grid::limited_generator_extrapolation_assign(), Parma_Polyhedra_Library::Polyhedron::poly_difference_assign(), Parma_Polyhedra_Library::Polyhedron::relation_with(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::relation_with(), Parma_Polyhedra_Library::Partially_Reduced_Product< D1, D2, R >::relation_with(), Parma_Polyhedra_Library::Octagonal_Shape< T >::relation_with(), Parma_Polyhedra_Library::Grid::relation_with(), Parma_Polyhedra_Library::Generator_System::relation_with(), Parma_Polyhedra_Library::Box< ITV >::relation_with(), Parma_Polyhedra_Library::BD_Shape< T >::relation_with(), Parma_Polyhedra_Library::shrink_to_congruence_no_check(), and Parma_Polyhedra_Library::Grid::simplify_using_context_assign().

00055                                {
00056   return Poly_Con_Relation(IS_INCLUDED);
00057 }

Poly_Con_Relation Parma_Polyhedra_Library::Poly_Con_Relation::nothing (  )  [inline, static]
bool Parma_Polyhedra_Library::Poly_Con_Relation::OK (  )  const

Checks if all the invariants are satisfied.

Definition at line 76 of file Poly_Con_Relation.cc.

00076                                {
00077   return true;
00078 }

void Parma_Polyhedra_Library::Poly_Con_Relation::print (  )  const

Prints *this to std::cerr using operator<<.

Poly_Con_Relation Parma_Polyhedra_Library::Poly_Con_Relation::saturates (  )  [inline, static]
Poly_Con_Relation Parma_Polyhedra_Library::Poly_Con_Relation::strictly_intersects (  )  [inline, static]

Friends And Related Function Documentation

bool operator!= ( const Poly_Con_Relation x,
const Poly_Con_Relation y 
) [friend]

True if and only if x and y are not logically equivalent.

Definition at line 82 of file Poly_Con_Relation.inlines.hh.

00082                                                                    {
00083   return x.flags != y.flags;
00084 }

Poly_Con_Relation operator&& ( const Poly_Con_Relation x,
const Poly_Con_Relation y 
) [friend]

Yields the logical conjunction of x and y.

Definition at line 88 of file Poly_Con_Relation.inlines.hh.

00088                                                                    {
00089   return Poly_Con_Relation(x.flags | y.flags);
00090 }

Poly_Con_Relation operator- ( const Poly_Con_Relation x,
const Poly_Con_Relation y 
) [friend]

Yields the assertion with all the conjuncts of x that are not in y.

Definition at line 94 of file Poly_Con_Relation.inlines.hh.

00094                                                                   {
00095   return Poly_Con_Relation(x.flags & ~y.flags);
00096 }

std::ostream & operator<< ( std::ostream &  s,
const Poly_Con_Relation r 
) [related]

Output operator.

Definition at line 70 of file Poly_Con_Relation.cc.

00070                                                                      {
00071   r.ascii_dump(s);
00072   return s;
00073 }

bool operator== ( const Poly_Con_Relation x,
const Poly_Con_Relation y 
) [friend]

True if and only if x and y are logically equivalent.

Definition at line 76 of file Poly_Con_Relation.inlines.hh.

00076                                                                    {
00077   return x.flags == y.flags;
00078 }

std::ostream& Parma_Polyhedra_Library::IO_Operators::operator<< ( std::ostream &  s,
const Poly_Con_Relation r 
) [friend]

Member Data Documentation

Initial value:

All assertions together.

Definition at line 89 of file Poly_Con_Relation.defs.hh.

This holds the current bitset.

Definition at line 95 of file Poly_Con_Relation.defs.hh.

Referenced by ascii_dump(), get_flags(), and implies().

Definition at line 81 of file Poly_Con_Relation.defs.hh.

Referenced by ascii_dump(), and is_disjoint().

Definition at line 83 of file Poly_Con_Relation.defs.hh.

Referenced by ascii_dump(), and is_included().

Definition at line 80 of file Poly_Con_Relation.defs.hh.

Referenced by ascii_dump(), and nothing().

Definition at line 84 of file Poly_Con_Relation.defs.hh.

Referenced by ascii_dump(), and saturates().

Definition at line 82 of file Poly_Con_Relation.defs.hh.

Referenced by ascii_dump(), and strictly_intersects().


The documentation for this class was generated from the following files:
Generated on Sun Feb 27 16:20:26 2011 for PPL by  doxygen 1.6.3