Parma_Polyhedra_Library::Polyhedron::Status Class Reference
[C++ Language Interface]

A conjunctive assertion about a polyhedron. More...

List of all members.

Public Member Functions

 Status ()
 By default Status is the zero-dim universe assertion.
bool OK () const
 Checks if all the invariants are satisfied.
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 ascii_load (std::istream &s)
 Loads from s an ASCII representation (as produced by ascii_dump(std::ostream&) const) and sets *this accordingly. Returns true if successful, false otherwise.
Test, remove or add an individual assertion from the conjunction

bool test_zero_dim_univ () const
void reset_zero_dim_univ ()
void set_zero_dim_univ ()
bool test_empty () const
void reset_empty ()
void set_empty ()
bool test_c_up_to_date () const
void reset_c_up_to_date ()
void set_c_up_to_date ()
bool test_g_up_to_date () const
void reset_g_up_to_date ()
void set_g_up_to_date ()
bool test_c_minimized () const
void reset_c_minimized ()
void set_c_minimized ()
bool test_g_minimized () const
void reset_g_minimized ()
void set_g_minimized ()
bool test_sat_c_up_to_date () const
void reset_sat_c_up_to_date ()
void set_sat_c_up_to_date ()
bool test_sat_g_up_to_date () const
void reset_sat_g_up_to_date ()
void set_sat_g_up_to_date ()
bool test_c_pending () const
void reset_c_pending ()
void set_c_pending ()
bool test_g_pending () const
void reset_g_pending ()
void set_g_pending ()

Private Types

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

Private Member Functions

 Status (flags_t mask)
 Construct from a bit-mask.
bool test_all (flags_t mask) const
 Check whether all bits in mask are set.
bool test_any (flags_t mask) const
 Check whether at least one bit in mask is set.
void set (flags_t mask)
 Set the bits in mask.
void reset (flags_t mask)
 Reset the bits in mask.

Private Attributes

flags_t flags
 This holds the current bitset.

Static Private Attributes

Bit-masks for the individual assertions

static const flags_t ZERO_DIM_UNIV = 0U
static const flags_t EMPTY = 1U << 0
static const flags_t C_UP_TO_DATE = 1U << 1
static const flags_t G_UP_TO_DATE = 1U << 2
static const flags_t C_MINIMIZED = 1U << 3
static const flags_t G_MINIMIZED = 1U << 4
static const flags_t SAT_C_UP_TO_DATE = 1U << 5
static const flags_t SAT_G_UP_TO_DATE = 1U << 6
static const flags_t CS_PENDING = 1U << 7
static const flags_t GS_PENDING = 1U << 8

Related Functions

(Note that these are not member functions.)



bool get_field (std::istream &s, const char *keyword, bool &positive)

Detailed Description

A conjunctive assertion about a polyhedron.

The assertions supported are:

Not all the conjunctions of these elementary assertions constitute a legal Status. In fact:

Definition at line 87 of file Polyhedron.defs.hh.


Member Typedef Documentation

Status is implemented by means of a finite bitset.

Definition at line 64 of file Polyhedron.defs.hh.


Constructor & Destructor Documentation

Parma_Polyhedra_Library::Polyhedron::Status::Status (  )  [inline]

By default Status is the zero-dim universe assertion.

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

00036   : flags(ZERO_DIM_UNIV) {
00037 }

Parma_Polyhedra_Library::Polyhedron::Status::Status ( flags_t  mask  )  [inline, private]

Construct from a bit-mask.

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

00031   : flags(mask) {
00032 }


Member Function Documentation

void Parma_Polyhedra_Library::Polyhedron::Status::ascii_dump ( std::ostream &  s  )  const

Writes to s an ASCII representation of *this.

Definition at line 68 of file Ph_Status.cc.

References test_c_minimized(), test_c_pending(), test_c_up_to_date(), test_empty(), test_g_minimized(), test_g_pending(), test_g_up_to_date(), test_sat_c_up_to_date(), test_sat_g_up_to_date(), and test_zero_dim_univ().

00068                                                    {
00069   s << (test_zero_dim_univ() ? '+' : '-') << zero_dim_univ << ' '
00070     << (test_empty() ? '+' : '-') << empty << ' '
00071     << ' '
00072     << (test_c_minimized() ? '+' : '-') << consys_min << ' '
00073     << (test_g_minimized() ? '+' : '-') << gensys_min << ' '
00074     << ' '
00075     << (test_c_up_to_date() ? '+' : '-') << consys_upd << ' '
00076     << (test_g_up_to_date() ? '+' : '-') << gensys_upd << ' '
00077     << ' '
00078     << (test_c_pending() ? '+' : '-') << consys_pending << ' '
00079     << (test_g_pending() ? '+' : '-') << gensys_pending << ' '
00080     << ' '
00081     << (test_sat_c_up_to_date() ? '+' : '-') << satc_upd << ' '
00082     << (test_sat_g_up_to_date() ? '+' : '-') << satg_upd << ' ';
00083 }

void Parma_Polyhedra_Library::Polyhedron::Status::ascii_dump (  )  const

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

Referenced by Parma_Polyhedra_Library::Polyhedron::ascii_dump().

bool Parma_Polyhedra_Library::Polyhedron::Status::ascii_load ( std::istream &  s  ) 

Loads from s an ASCII representation (as produced by ascii_dump(std::ostream&) const) and sets *this accordingly. Returns true if successful, false otherwise.

Definition at line 88 of file Ph_Status.cc.

References Parma_Polyhedra_Library::Polyhedron::OK(), Parma_Polyhedra_Library::Polyhedron::set_empty(), Parma_Polyhedra_Library::Polyhedron::set_sat_c_up_to_date(), Parma_Polyhedra_Library::Polyhedron::set_sat_g_up_to_date(), and Parma_Polyhedra_Library::Polyhedron::set_zero_dim_univ().

00088                                              {
00089   PPL_UNINITIALIZED(bool, positive);
00090 
00091   if (!get_field(s, zero_dim_univ, positive))
00092     return false;
00093   if (positive)
00094     set_zero_dim_univ();
00095 
00096   if (!get_field(s, empty, positive))
00097     return false;
00098   if (positive)
00099     set_empty();
00100 
00101   if (!get_field(s, consys_min, positive))
00102     return false;
00103   if (positive)
00104     set_c_minimized();
00105   else
00106     reset_c_minimized();
00107 
00108   if (!get_field(s, gensys_min, positive))
00109     return false;
00110   if (positive)
00111     set_g_minimized();
00112   else
00113     reset_g_minimized();
00114 
00115   if (!get_field(s, consys_upd, positive))
00116     return false;
00117   if (positive)
00118     set_c_up_to_date();
00119   else
00120     reset_c_up_to_date();
00121 
00122   if (!get_field(s, gensys_upd, positive))
00123     return false;
00124   if (positive)
00125     set_g_up_to_date();
00126   else
00127     reset_g_up_to_date();
00128 
00129   if (!get_field(s, consys_pending, positive))
00130     return false;
00131   if (positive)
00132     set_c_pending();
00133   else
00134     reset_c_pending();
00135 
00136   if (!get_field(s, gensys_pending, positive))
00137     return false;
00138   if (positive)
00139     set_g_pending();
00140   else
00141     reset_g_pending();
00142 
00143   if (!get_field(s, satc_upd, positive))
00144     return false;
00145   if (positive)
00146     set_sat_c_up_to_date();
00147   else
00148     reset_sat_c_up_to_date();
00149 
00150   if (!get_field(s, satg_upd, positive))
00151     return false;
00152   if (positive)
00153     set_sat_g_up_to_date();
00154   else
00155     reset_sat_g_up_to_date();
00156 
00157   // Check invariants.
00158   PPL_ASSERT(OK());
00159   return true;
00160 }

bool Parma_Polyhedra_Library::Polyhedron::Status::OK (  )  const

Checks if all the invariants are satisfied.

Definition at line 163 of file Ph_Status.cc.

References reset_empty(), test_c_minimized(), test_c_pending(), test_c_up_to_date(), test_empty(), test_g_minimized(), test_g_pending(), test_g_up_to_date(), test_sat_c_up_to_date(), test_sat_g_up_to_date(), and test_zero_dim_univ().

Referenced by Parma_Polyhedra_Library::Polyhedron::OK().

00163                               {
00164 #ifndef NDEBUG
00165   using std::endl;
00166   using std::cerr;
00167 #endif
00168 
00169   if (test_zero_dim_univ())
00170     // Zero-dim universe is OK.
00171     return true;
00172 
00173   if (test_empty()) {
00174     Status copy = *this;
00175     copy.reset_empty();
00176     if (copy.test_zero_dim_univ())
00177       return true;
00178     else {
00179 #ifndef NDEBUG
00180       cerr << "The empty flag is incompatible with any other one."
00181            << endl;
00182 #endif
00183       return false;
00184     }
00185   }
00186 
00187   if ((test_sat_c_up_to_date() || test_sat_g_up_to_date())
00188       && !(test_c_up_to_date() && test_g_up_to_date())) {
00189 #ifndef NDEBUG
00190     cerr <<
00191       "If a saturation matrix is up-to-date, constraints and\n"
00192       "generators have to be both up-to-date."
00193          << endl;
00194 #endif
00195     return false;
00196   }
00197 
00198   if (test_c_minimized() && !test_c_up_to_date()) {
00199 #ifndef NDEBUG
00200     cerr << "If constraints are minimized they must be up-to-date."
00201          << endl;
00202 #endif
00203     return false;
00204   }
00205 
00206   if (test_g_minimized() && !test_g_up_to_date()) {
00207 #ifndef NDEBUG
00208     cerr << "If generators are minimized they must be up-to-date."
00209          << endl;
00210 #endif
00211     return false;
00212   }
00213 
00214   if (test_c_pending() && test_g_pending()) {
00215 #ifndef NDEBUG
00216     cerr << "There cannot be both pending constraints and pending generators."
00217          << endl;
00218 #endif
00219     return false;
00220   }
00221 
00222   if (test_c_pending() || test_g_pending()) {
00223     if (!test_c_minimized() || !test_g_minimized()) {
00224 #ifndef NDEBUG
00225     cerr <<
00226       "If there are pending constraints or generators, constraints\n"
00227       "and generators must be minimized."
00228          << endl;
00229 #endif
00230       return false;
00231     }
00232 
00233     if (!test_sat_c_up_to_date() && !test_sat_g_up_to_date()) {
00234 #ifndef NDEBUG
00235     cerr <<
00236       "If there are pending constraints or generators, there must\n"
00237       "be at least a saturation matrix up-to-date."
00238          << endl;
00239 #endif
00240       return false;
00241     }
00242   }
00243 
00244   // Any other case is OK.
00245   return true;
00246 }

void Parma_Polyhedra_Library::Polyhedron::Status::print (  )  const

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

void Parma_Polyhedra_Library::Polyhedron::Status::reset ( flags_t  mask  )  [inline, private]

Reset the bits in mask.

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

References flags.

Referenced by reset_c_minimized(), reset_c_pending(), reset_c_up_to_date(), reset_empty(), reset_g_minimized(), reset_g_pending(), reset_g_up_to_date(), reset_sat_c_up_to_date(), and reset_sat_g_up_to_date().

00055                                     {
00056   flags &= ~mask;
00057 }

void Parma_Polyhedra_Library::Polyhedron::Status::reset_c_minimized (  )  [inline]

Definition at line 129 of file Ph_Status.inlines.hh.

References C_MINIMIZED, and reset().

Referenced by Parma_Polyhedra_Library::Polyhedron::clear_constraints_minimized().

00129                                     {
00130   reset(C_MINIMIZED);
00131 }

void Parma_Polyhedra_Library::Polyhedron::Status::reset_c_pending (  )  [inline]

Definition at line 160 of file Ph_Status.inlines.hh.

References CS_PENDING, and reset().

Referenced by Parma_Polyhedra_Library::Polyhedron::clear_pending_constraints().

00160                                   {
00161   reset(CS_PENDING);
00162 }

void Parma_Polyhedra_Library::Polyhedron::Status::reset_c_up_to_date (  )  [inline]

Definition at line 99 of file Ph_Status.inlines.hh.

References C_UP_TO_DATE, and reset().

Referenced by Parma_Polyhedra_Library::Polyhedron::clear_constraints_up_to_date().

00099                                      {
00100   reset(C_UP_TO_DATE);
00101 }

void Parma_Polyhedra_Library::Polyhedron::Status::reset_empty (  )  [inline]

Definition at line 84 of file Ph_Status.inlines.hh.

References EMPTY, and reset().

Referenced by Parma_Polyhedra_Library::Polyhedron::clear_empty(), and OK().

00084                               {
00085   reset(EMPTY);
00086 }

void Parma_Polyhedra_Library::Polyhedron::Status::reset_g_minimized (  )  [inline]

Definition at line 144 of file Ph_Status.inlines.hh.

References G_MINIMIZED, and reset().

Referenced by Parma_Polyhedra_Library::Polyhedron::clear_generators_minimized().

00144                                     {
00145   reset(G_MINIMIZED);
00146 }

void Parma_Polyhedra_Library::Polyhedron::Status::reset_g_pending (  )  [inline]

Definition at line 175 of file Ph_Status.inlines.hh.

References GS_PENDING, and reset().

Referenced by Parma_Polyhedra_Library::Polyhedron::clear_pending_generators().

00175                                   {
00176   reset(GS_PENDING);
00177 }

void Parma_Polyhedra_Library::Polyhedron::Status::reset_g_up_to_date (  )  [inline]

Definition at line 114 of file Ph_Status.inlines.hh.

References G_UP_TO_DATE, and reset().

Referenced by Parma_Polyhedra_Library::Polyhedron::clear_generators_up_to_date().

00114                                      {
00115   reset(G_UP_TO_DATE);
00116 }

void Parma_Polyhedra_Library::Polyhedron::Status::reset_sat_c_up_to_date (  )  [inline]

Definition at line 191 of file Ph_Status.inlines.hh.

References reset(), and SAT_C_UP_TO_DATE.

Referenced by Parma_Polyhedra_Library::Polyhedron::clear_sat_c_up_to_date().

00191                                          {
00192   reset(SAT_C_UP_TO_DATE);
00193 }

void Parma_Polyhedra_Library::Polyhedron::Status::reset_sat_g_up_to_date (  )  [inline]

Definition at line 206 of file Ph_Status.inlines.hh.

References reset(), and SAT_G_UP_TO_DATE.

Referenced by Parma_Polyhedra_Library::Polyhedron::clear_sat_g_up_to_date().

00206                                          {
00207   reset(SAT_G_UP_TO_DATE);
00208 }

void Parma_Polyhedra_Library::Polyhedron::Status::reset_zero_dim_univ (  )  [inline]

Definition at line 65 of file Ph_Status.inlines.hh.

References EMPTY, flags, and ZERO_DIM_UNIV.

00065                                       {
00066   // This is a no-op if the current status is not zero-dim.
00067   if (flags == ZERO_DIM_UNIV)
00068     // In the zero-dim space, if it is not the universe it is empty.
00069     flags = EMPTY;
00070 }

void Parma_Polyhedra_Library::Polyhedron::Status::set ( flags_t  mask  )  [inline, private]

Set the bits in mask.

Definition at line 50 of file Ph_Status.inlines.hh.

References flags.

00050                                   {
00051   flags |= mask;
00052 }

void Parma_Polyhedra_Library::Polyhedron::Status::set_c_minimized (  )  [inline]

Definition at line 134 of file Ph_Status.inlines.hh.

References C_MINIMIZED.

Referenced by Parma_Polyhedra_Library::Polyhedron::set_constraints_minimized().

00134                                   {
00135   set(C_MINIMIZED);
00136 }

void Parma_Polyhedra_Library::Polyhedron::Status::set_c_pending (  )  [inline]

Definition at line 165 of file Ph_Status.inlines.hh.

References CS_PENDING.

Referenced by Parma_Polyhedra_Library::Polyhedron::set_constraints_pending().

00165                                 {
00166   set(CS_PENDING);
00167 }

void Parma_Polyhedra_Library::Polyhedron::Status::set_c_up_to_date (  )  [inline]

Definition at line 104 of file Ph_Status.inlines.hh.

References C_UP_TO_DATE.

Referenced by Parma_Polyhedra_Library::Polyhedron::set_constraints_up_to_date().

00104                                    {
00105   set(C_UP_TO_DATE);
00106 }

void Parma_Polyhedra_Library::Polyhedron::Status::set_empty (  )  [inline]
void Parma_Polyhedra_Library::Polyhedron::Status::set_g_minimized (  )  [inline]

Definition at line 149 of file Ph_Status.inlines.hh.

References G_MINIMIZED.

Referenced by Parma_Polyhedra_Library::Polyhedron::set_generators_minimized().

00149                                   {
00150   set(G_MINIMIZED);
00151 }

void Parma_Polyhedra_Library::Polyhedron::Status::set_g_pending (  )  [inline]

Definition at line 180 of file Ph_Status.inlines.hh.

References GS_PENDING.

Referenced by Parma_Polyhedra_Library::Polyhedron::set_generators_pending().

00180                                 {
00181   set(GS_PENDING);
00182 }

void Parma_Polyhedra_Library::Polyhedron::Status::set_g_up_to_date (  )  [inline]

Definition at line 119 of file Ph_Status.inlines.hh.

References G_UP_TO_DATE.

Referenced by Parma_Polyhedra_Library::Polyhedron::set_generators_up_to_date().

00119                                    {
00120   set(G_UP_TO_DATE);
00121 }

void Parma_Polyhedra_Library::Polyhedron::Status::set_sat_c_up_to_date (  )  [inline]

Definition at line 196 of file Ph_Status.inlines.hh.

References SAT_C_UP_TO_DATE.

Referenced by Parma_Polyhedra_Library::Polyhedron::set_sat_c_up_to_date().

00196                                        {
00197   set(SAT_C_UP_TO_DATE);
00198 }

void Parma_Polyhedra_Library::Polyhedron::Status::set_sat_g_up_to_date (  )  [inline]

Definition at line 211 of file Ph_Status.inlines.hh.

References SAT_G_UP_TO_DATE.

Referenced by Parma_Polyhedra_Library::Polyhedron::set_sat_g_up_to_date().

00211                                        {
00212   set(SAT_G_UP_TO_DATE);
00213 }

void Parma_Polyhedra_Library::Polyhedron::Status::set_zero_dim_univ (  )  [inline]

Definition at line 73 of file Ph_Status.inlines.hh.

References flags, and ZERO_DIM_UNIV.

Referenced by Parma_Polyhedra_Library::Polyhedron::set_zero_dim_univ().

00073                                     {
00074   // Zero-dim universe is incompatible with anything else.
00075   flags = ZERO_DIM_UNIV;
00076 }

bool Parma_Polyhedra_Library::Polyhedron::Status::test_all ( flags_t  mask  )  const [inline, private]

Check whether all bits in mask are set.

Definition at line 40 of file Ph_Status.inlines.hh.

References flags.

00040                                              {
00041   return (flags & mask) == mask;
00042 }

bool Parma_Polyhedra_Library::Polyhedron::Status::test_any ( flags_t  mask  )  const [inline, private]

Check whether at least one bit in mask is set.

Definition at line 45 of file Ph_Status.inlines.hh.

References flags.

Referenced by test_c_minimized(), test_c_pending(), test_c_up_to_date(), test_empty(), test_g_minimized(), test_g_pending(), test_g_up_to_date(), test_sat_c_up_to_date(), and test_sat_g_up_to_date().

00045                                              {
00046   return flags & mask;
00047 }

bool Parma_Polyhedra_Library::Polyhedron::Status::test_c_minimized (  )  const [inline]

Definition at line 124 of file Ph_Status.inlines.hh.

References C_MINIMIZED, and test_any().

Referenced by ascii_dump(), Parma_Polyhedra_Library::Polyhedron::constraints_are_minimized(), and OK().

00124                                          {
00125   return test_any(C_MINIMIZED);
00126 }

bool Parma_Polyhedra_Library::Polyhedron::Status::test_c_pending (  )  const [inline]
bool Parma_Polyhedra_Library::Polyhedron::Status::test_c_up_to_date (  )  const [inline]

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

References C_UP_TO_DATE, and test_any().

Referenced by ascii_dump(), Parma_Polyhedra_Library::Polyhedron::constraints_are_up_to_date(), and OK().

00094                                           {
00095   return test_any(C_UP_TO_DATE);
00096 }

bool Parma_Polyhedra_Library::Polyhedron::Status::test_empty (  )  const [inline]

Definition at line 79 of file Ph_Status.inlines.hh.

References EMPTY, and test_any().

Referenced by ascii_dump(), Parma_Polyhedra_Library::Polyhedron::marked_empty(), and OK().

00079                                    {
00080   return test_any(EMPTY);
00081 }

bool Parma_Polyhedra_Library::Polyhedron::Status::test_g_minimized (  )  const [inline]

Definition at line 139 of file Ph_Status.inlines.hh.

References G_MINIMIZED, and test_any().

Referenced by ascii_dump(), Parma_Polyhedra_Library::Polyhedron::generators_are_minimized(), and OK().

00139                                          {
00140   return test_any(G_MINIMIZED);
00141 }

bool Parma_Polyhedra_Library::Polyhedron::Status::test_g_pending (  )  const [inline]
bool Parma_Polyhedra_Library::Polyhedron::Status::test_g_up_to_date (  )  const [inline]

Definition at line 109 of file Ph_Status.inlines.hh.

References G_UP_TO_DATE, and test_any().

Referenced by ascii_dump(), Parma_Polyhedra_Library::Polyhedron::generators_are_up_to_date(), and OK().

00109                                           {
00110   return test_any(G_UP_TO_DATE);
00111 }

bool Parma_Polyhedra_Library::Polyhedron::Status::test_sat_c_up_to_date (  )  const [inline]

Definition at line 186 of file Ph_Status.inlines.hh.

References SAT_C_UP_TO_DATE, and test_any().

Referenced by ascii_dump(), OK(), and Parma_Polyhedra_Library::Polyhedron::sat_c_is_up_to_date().

00186                                               {
00187   return test_any(SAT_C_UP_TO_DATE);
00188 }

bool Parma_Polyhedra_Library::Polyhedron::Status::test_sat_g_up_to_date (  )  const [inline]

Definition at line 201 of file Ph_Status.inlines.hh.

References SAT_G_UP_TO_DATE, and test_any().

Referenced by ascii_dump(), OK(), and Parma_Polyhedra_Library::Polyhedron::sat_g_is_up_to_date().

00201                                               {
00202   return test_any(SAT_G_UP_TO_DATE);
00203 }

bool Parma_Polyhedra_Library::Polyhedron::Status::test_zero_dim_univ (  )  const [inline]

Friends And Related Function Documentation

bool get_field ( std::istream &  s,
const char *  keyword,
bool &  positive 
) [related]

Reads a keyword and its associated on/off, +/- flag from s. Returns true if the operation is successful, returns false otherwise. When successful, positive is set to true if the flag is on; it is set to false otherwise.

Definition at line 55 of file Ph_Status.cc.

00055                                                               {
00056   std::string str;
00057   if (!(s >> str)
00058       || (str[0] != '+' && str[0] != '-')
00059       || str.substr(1) != keyword)
00060     return false;
00061   positive = (str[0] == '+');
00062   return true;
00063 }


Member Data Documentation

Definition at line 72 of file Polyhedron.defs.hh.

Referenced by reset_c_minimized(), set_c_minimized(), and test_c_minimized().

Definition at line 70 of file Polyhedron.defs.hh.

Referenced by reset_c_up_to_date(), set_c_up_to_date(), and test_c_up_to_date().

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

Referenced by reset_c_pending(), set_c_pending(), and test_c_pending().

Definition at line 69 of file Polyhedron.defs.hh.

Referenced by reset_empty(), reset_zero_dim_univ(), set_empty(), and test_empty().

This holds the current bitset.

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

Referenced by reset(), reset_zero_dim_univ(), set(), set_empty(), set_zero_dim_univ(), test_all(), test_any(), and test_zero_dim_univ().

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

Referenced by reset_g_minimized(), set_g_minimized(), and test_g_minimized().

Definition at line 71 of file Polyhedron.defs.hh.

Referenced by reset_g_up_to_date(), set_g_up_to_date(), and test_g_up_to_date().

Definition at line 77 of file Polyhedron.defs.hh.

Referenced by reset_g_pending(), set_g_pending(), and test_g_pending().

Definition at line 68 of file Polyhedron.defs.hh.

Referenced by reset_zero_dim_univ(), set_zero_dim_univ(), and test_zero_dim_univ().


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