Parma_Polyhedra_Library::PIP_Decision_Node Class Reference

A tree node representing a decision in the space of solutions. More...

#include <PIP_Tree.defs.hh>

Inheritance diagram for Parma_Polyhedra_Library::PIP_Decision_Node:
Inheritance graph
[legend]
Collaboration diagram for Parma_Polyhedra_Library::PIP_Decision_Node:
Collaboration graph
[legend]

List of all members.

Public Member Functions

virtual PIP_Tree_Nodeclone () const
 Returns a pointer to a dynamically-allocated copy of *this.
virtual ~PIP_Decision_Node ()
 Destructor.
virtual bool OK () const
 Returns true if and only if *this is well formed.
virtual const PIP_Decision_Nodeas_decision () const
 Returns this.
const PIP_Tree_Nodechild_node (bool b) const
 Returns a const pointer to the b (true or false) branch of *this.
PIP_Tree_Nodechild_node (bool b)
 Returns a pointer to the b (true or false) branch of *this.
void ascii_dump (std::ostream &s) const
 Dumps to s an ASCII representation of *this.
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.
virtual memory_size_type total_memory_in_bytes () const
 Returns the total size in bytes of the memory occupied by *this.
virtual memory_size_type external_memory_in_bytes () const
 Returns the size in bytes of the memory managed by *this.

Protected Member Functions

 PIP_Decision_Node (const PIP_Decision_Node &y)
 Copy constructor.
virtual void update_tableau (const PIP_Problem &pip, dimension_type external_space_dim, dimension_type first_pending_constraint, const Constraint_Sequence &input_cs, const Variables_Set &parameters)
 Implements pure virtual method PIP_Tree_Node::update_tableau.
virtual PIP_Tree_Nodesolve (const PIP_Problem &pip, bool check_feasible_context, const Matrix &context, const Variables_Set &params, dimension_type space_dim, unsigned indent_level)
 Implements pure virtual method PIP_Tree_Node::solve.
virtual void print_tree (std::ostream &s, unsigned indent, const std::vector< bool > &pip_dim_is_param, dimension_type first_art_dim) const
 Prints on s the tree rooted in *this.

Private Member Functions

 PIP_Decision_Node (const PIP_Problem *owner, PIP_Tree_Node *fcp, PIP_Tree_Node *tcp)
 Builds a decision node having fcp and tcp as child.
virtual void set_owner (const PIP_Problem *owner)
 Sets the pointer to the PIP_Problem owning object.
virtual bool check_ownership (const PIP_Problem *owner) const
 Returns true if and only if all the nodes in the subtree rooted in *this is owned by *pip.

Private Attributes

PIP_Tree_Nodefalse_child
 Pointer to the "false" child of *this.
PIP_Tree_Nodetrue_child
 Pointer to the "true" child of *this.

Friends

class PIP_Solution_Node
bool PIP_Problem::ascii_load (std::istream &s)

Detailed Description

A tree node representing a decision in the space of solutions.

Definition at line 689 of file PIP_Tree.defs.hh.


Constructor & Destructor Documentation

Parma_Polyhedra_Library::PIP_Decision_Node::~PIP_Decision_Node (  )  [virtual]

Destructor.

Definition at line 557 of file PIP_Tree.cc.

References false_child, and true_child.

00557                                       {
00558   delete false_child;
00559   delete true_child;
00560 }

Parma_Polyhedra_Library::PIP_Decision_Node::PIP_Decision_Node ( const PIP_Problem owner,
PIP_Tree_Node fcp,
PIP_Tree_Node tcp 
) [explicit, private]

Builds a decision node having fcp and tcp as child.

The decision node will encode the structure "if \c cs then \p tcp else \p fcp", where the system of constraints cs is initially empty.

Parameters:
owner Pointer to the owning PIP_Problem object; it may be null if and only if both children are null.
fcp Pointer to "false" child; it may be null.
tcp Pointer to "true" child; it may be null.
Note:
If any of fcp or tcp is not null, then owner is required to be not null and equal to the owner of its non-null children; otherwise the behavior is undefined.

Definition at line 527 of file PIP_Tree.cc.

References false_child, Parma_Polyhedra_Library::PIP_Tree_Node::set_parent(), and true_child.

Referenced by ascii_load(), and clone().

00530   : PIP_Tree_Node(owner),
00531     false_child(fcp),
00532     true_child(tcp) {
00533   if (false_child != 0)
00534     false_child->set_parent(this);
00535   if (true_child != 0)
00536     true_child->set_parent(this);
00537 }

Parma_Polyhedra_Library::PIP_Decision_Node::PIP_Decision_Node ( const PIP_Decision_Node y  )  [protected]

Copy constructor.

Definition at line 539 of file PIP_Tree.cc.

References Parma_Polyhedra_Library::PIP_Tree_Node::clone(), false_child, Parma_Polyhedra_Library::PIP_Tree_Node::set_parent(), and true_child.

00540   : PIP_Tree_Node(y),
00541     false_child(0),
00542     true_child(0) {
00543   if (y.false_child != 0) {
00544     false_child = y.false_child->clone();
00545     false_child->set_parent(this);
00546   }
00547   // Protect false_child from exception safety issues via std::auto_ptr.
00548   std::auto_ptr<PIP_Tree_Node> wrapped_node(false_child);
00549   if (y.true_child != 0) {
00550     true_child = y.true_child->clone();
00551     true_child->set_parent(this);
00552   }
00553   // It is now safe to release false_child.
00554   wrapped_node.release();
00555 }


Member Function Documentation

const PIP_Decision_Node * Parma_Polyhedra_Library::PIP_Decision_Node::as_decision (  )  const [virtual]

Returns this.

Reimplemented from Parma_Polyhedra_Library::PIP_Tree_Node.

Definition at line 604 of file PIP_Tree.cc.

00604                                      {
00605   return this;
00606 }

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

Dumps to s an ASCII representation of *this.

Reimplemented from Parma_Polyhedra_Library::PIP_Tree_Node.

Definition at line 949 of file PIP_Tree.cc.

References Parma_Polyhedra_Library::PIP_Tree_Node::as_decision(), Parma_Polyhedra_Library::PIP_Tree_Node::as_solution(), Parma_Polyhedra_Library::PIP_Solution_Node::ascii_dump(), false_child, and true_child.

00949                                                  {
00950   // Dump base class info.
00951   PIP_Tree_Node::ascii_dump(s);
00952 
00953   // Dump true child (if any).
00954   s << "\ntrue_child: ";
00955   if (true_child == 0) {
00956     // Note: this branch should normally be unreachable code, since a
00957     // well-formed decision node always has a true child. We keep this code
00958     // for debugging purposes (since we want to dump broken nodes).
00959     s << "BOTTOM\n";
00960   }
00961   else if (const PIP_Decision_Node* dec = true_child->as_decision()) {
00962     s << "DECISION\n";
00963     dec->ascii_dump(s);
00964   }
00965   else {
00966     const PIP_Solution_Node* sol = true_child->as_solution();
00967     PPL_ASSERT(sol != 0);
00968     s << "SOLUTION\n";
00969     sol->ascii_dump(s);
00970   }
00971 
00972   // Dump false child (if any).
00973   s << "\nfalse_child: ";
00974   if (false_child == 0)
00975     s << "BOTTOM\n";
00976   else if (const PIP_Decision_Node* dec = false_child->as_decision()) {
00977     // Note: this branch should normally be unreachable code.
00978     // Since a well-formed decision node having a false child should have
00979     // a single context constraint, its false child will have no context
00980     // constraints at all, so that no further branch is possible.
00981     // We keep this code for debugging purposes.
00982     s << "DECISION\n";
00983     dec->ascii_dump(s);
00984   }
00985   else {
00986     const PIP_Solution_Node* sol = false_child->as_solution();
00987     PPL_ASSERT(sol != 0);
00988     s << "SOLUTION\n";
00989     sol->ascii_dump(s);
00990   }
00991 }

bool Parma_Polyhedra_Library::PIP_Decision_Node::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.

Reimplemented from Parma_Polyhedra_Library::PIP_Tree_Node.

Definition at line 994 of file PIP_Tree.cc.

References Parma_Polyhedra_Library::PIP_Solution_Node::ascii_load(), ascii_load(), Parma_Polyhedra_Library::PIP_Tree_Node::ascii_load(), false_child, OK(), PIP_Decision_Node(), PIP_Solution_Node, and true_child.

Referenced by ascii_load(), and Parma_Polyhedra_Library::PIP_Problem::ascii_load().

00994                                            {
00995   std::string str;
00996 
00997   // Load base class info.
00998   if (!PIP_Tree_Node::ascii_load(s))
00999     return false;
01000 
01001   // Release the "true" subtree (if any).
01002   delete true_child;
01003   true_child = 0;
01004 
01005   // Load true child (if any).
01006   if (!(s >> str) || str != "true_child:")
01007     return false;
01008   if (!(s >> str))
01009     return false;
01010   if (str == "BOTTOM")
01011     // Note: normally unreachable code (see comment on ascii_dump).
01012     true_child = 0;
01013   else if (str == "DECISION") {
01014     PIP_Decision_Node* dec = new PIP_Decision_Node(0, 0, 0);
01015     true_child = dec;
01016     if (!dec->ascii_load(s))
01017       return false;
01018   }
01019   else if (str == "SOLUTION") {
01020     PIP_Solution_Node* sol = new PIP_Solution_Node(0);
01021     true_child = sol;
01022     if (!sol->ascii_load(s))
01023       return false;
01024   }
01025   else
01026     // Unknown node kind.
01027     return false;
01028 
01029   // Release the "false" subtree (if any).
01030   delete false_child;
01031   false_child = 0;
01032 
01033   // Load false child (if any).
01034   if (!(s >> str) || str != "false_child:")
01035     return false;
01036   if (!(s >> str))
01037     return false;
01038   if (str == "BOTTOM")
01039     false_child = 0;
01040   else if (str == "DECISION") {
01041     // Note: normally unreachable code (see comment on ascii_dump).
01042     PIP_Decision_Node* dec = new PIP_Decision_Node(0, 0, 0);
01043     false_child = dec;
01044     if (!dec->ascii_load(s))
01045       return false;
01046   }
01047   else if (str == "SOLUTION") {
01048     PIP_Solution_Node* sol = new PIP_Solution_Node(0);
01049     false_child = sol;
01050     if (!sol->ascii_load(s))
01051       return false;
01052   }
01053   else
01054     // Unknown node kind.
01055     return false;
01056 
01057   // Loaded all info.
01058   PPL_ASSERT(OK());
01059   return true;
01060 }

bool Parma_Polyhedra_Library::PIP_Decision_Node::check_ownership ( const PIP_Problem owner  )  const [private, virtual]

Returns true if and only if all the nodes in the subtree rooted in *this is owned by *pip.

Implements Parma_Polyhedra_Library::PIP_Tree_Node.

Definition at line 582 of file PIP_Tree.cc.

References Parma_Polyhedra_Library::PIP_Tree_Node::check_ownership(), false_child, Parma_Polyhedra_Library::PIP_Tree_Node::get_owner(), and true_child.

00582                                                                  {
00583   return get_owner() == owner
00584     && (!false_child || false_child->check_ownership(owner))
00585     && (!true_child || true_child->check_ownership(owner));
00586 }

PIP_Tree_Node * Parma_Polyhedra_Library::PIP_Decision_Node::child_node ( bool  b  )  [inline]

Returns a pointer to the b (true or false) branch of *this.

Definition at line 102 of file PIP_Tree.inlines.hh.

References false_child, and true_child.

00102                                     {
00103   return v ? true_child : false_child;
00104 }

const PIP_Tree_Node * Parma_Polyhedra_Library::PIP_Decision_Node::child_node ( bool  b  )  const [inline]

Returns a const pointer to the b (true or false) branch of *this.

Definition at line 96 of file PIP_Tree.inlines.hh.

References false_child, and true_child.

00096                                           {
00097   return v ? true_child : false_child;
00098 }

PIP_Tree_Node * Parma_Polyhedra_Library::PIP_Decision_Node::clone (  )  const [virtual]

Returns a pointer to a dynamically-allocated copy of *this.

Implements Parma_Polyhedra_Library::PIP_Tree_Node.

Definition at line 1227 of file PIP_Tree.cc.

References PIP_Decision_Node().

01227                                {
01228   return new PIP_Decision_Node(*this);
01229 }

memory_size_type Parma_Polyhedra_Library::PIP_Decision_Node::external_memory_in_bytes (  )  const [virtual]

Returns the size in bytes of the memory managed by *this.

Implements Parma_Polyhedra_Library::PIP_Tree_Node.

Definition at line 2863 of file PIP_Tree.cc.

References false_child, Parma_Polyhedra_Library::PIP_Tree_Node::total_memory_in_bytes(), and true_child.

Referenced by total_memory_in_bytes().

02863                                                   {
02864   memory_size_type n = PIP_Tree_Node::external_memory_in_bytes();
02865   PPL_ASSERT(true_child != 0);
02866   n += true_child->total_memory_in_bytes();
02867   if (false_child)
02868     n += false_child->total_memory_in_bytes();
02869   return n;
02870 }

bool Parma_Polyhedra_Library::PIP_Decision_Node::OK (  )  const [virtual]

Returns true if and only if *this is well formed.

Reimplemented from Parma_Polyhedra_Library::PIP_Tree_Node.

Definition at line 765 of file PIP_Tree.cc.

References Parma_Polyhedra_Library::Constraint_System::begin(), Parma_Polyhedra_Library::PIP_Tree_Node::constraints_, Parma_Polyhedra_Library::Constraint_System::end(), false_child, Parma_Polyhedra_Library::PIP_Tree_Node::OK(), and true_child.

Referenced by ascii_load(), solve(), and update_tableau().

00765                             {
00766   // Perform base class well-formedness check on this node.
00767   if (!PIP_Tree_Node::OK())
00768     return false;
00769 
00770   // Recursively check if child nodes are well-formed.
00771   if (false_child && !false_child->OK())
00772     return false;
00773   if (true_child && !true_child->OK())
00774     return false;
00775 
00776   // Decision nodes should always have a true child.
00777   if (!true_child) {
00778 #ifndef NDEBUG
00779     std::cerr << "PIP_Decision_Node with no 'true' child.\n";
00780 #endif
00781     return false;
00782   }
00783 
00784   // Decision nodes with a false child must have exactly one constraint.
00785   if (false_child) {
00786     dimension_type
00787       dist = std::distance(constraints_.begin(), constraints_.end());
00788     if (dist != 1) {
00789 #ifndef NDEBUG
00790       std::cerr << "PIP_Decision_Node with a 'false' child has "
00791                 << dist << " parametric constraints (should be 1).\n";
00792 #endif
00793       return false;
00794     }
00795   }
00796 
00797   // All checks passed.
00798   return true;
00799 }

void Parma_Polyhedra_Library::PIP_Decision_Node::print_tree ( std::ostream &  s,
unsigned  indent,
const std::vector< bool > &  pip_dim_is_param,
dimension_type  first_art_dim 
) const [protected, virtual]

Prints on s the tree rooted in *this.

Reimplemented from Parma_Polyhedra_Library::PIP_Tree_Node.

Definition at line 2964 of file PIP_Tree.cc.

References Parma_Polyhedra_Library::PIP_Tree_Node::art_parameter_count(), false_child, Parma_Polyhedra_Library::PIP_Tree_Node::indent_and_print(), Parma_Polyhedra_Library::PIP_Tree_Node::print_tree(), and true_child.

02966                                                                         {
02967   // First print info common to decision and solution nodes.
02968   PIP_Tree_Node::print_tree(s, indent, pip_dim_is_param, first_art_dim);
02969 
02970   // Then print info specific of decision nodes.
02971   dimension_type child_first_art_dim = first_art_dim + art_parameter_count();
02972 
02973   PPL_ASSERT(true_child != 0);
02974   true_child->print_tree(s, indent+1, pip_dim_is_param, child_first_art_dim);
02975 
02976   indent_and_print(s, indent, "else\n");
02977 
02978   if (false_child)
02979     false_child->print_tree(s, indent+1, pip_dim_is_param, child_first_art_dim);
02980   else
02981     indent_and_print(s, indent+1, "_|_\n");
02982 }

void Parma_Polyhedra_Library::PIP_Decision_Node::set_owner ( const PIP_Problem owner  )  [private, virtual]

Sets the pointer to the PIP_Problem owning object.

Implements Parma_Polyhedra_Library::PIP_Tree_Node.

Definition at line 568 of file PIP_Tree.cc.

References false_child, Parma_Polyhedra_Library::PIP_Tree_Node::owner_, Parma_Polyhedra_Library::PIP_Tree_Node::set_owner(), and true_child.

Referenced by Parma_Polyhedra_Library::PIP_Problem::ascii_load().

00568                                                      {
00569   owner_ = owner;
00570   if (false_child)
00571     false_child->set_owner(owner);
00572   if (true_child)
00573     true_child->set_owner(owner);
00574 }

PIP_Tree_Node * Parma_Polyhedra_Library::PIP_Decision_Node::solve ( const PIP_Problem pip,
bool  check_feasible_context,
const Matrix context,
const Variables_Set params,
dimension_type  space_dim,
unsigned  indent_level 
) [protected, virtual]

Implements pure virtual method PIP_Tree_Node::solve.

Implements Parma_Polyhedra_Library::PIP_Tree_Node.

Definition at line 822 of file PIP_Tree.cc.

References Parma_Polyhedra_Library::PIP_Tree_Node::artificial_parameters, Parma_Polyhedra_Library::Constraint_System::begin(), Parma_Polyhedra_Library::PIP_Tree_Node::compatibility_check(), Parma_Polyhedra_Library::PIP_Tree_Node::constraints_, Parma_Polyhedra_Library::Constraint_System::empty(), Parma_Polyhedra_Library::Constraint_System::end(), false_child, Parma_Polyhedra_Library::PIP_Tree_Node::indent_and_print(), Parma_Polyhedra_Library::Constraint_System::insert(), Parma_Polyhedra_Library::Matrix::num_rows(), OK(), Parma_Polyhedra_Library::PIP_Tree_Node::OK(), Parma_Polyhedra_Library::PIP_Tree_Node::parent(), Parma_Polyhedra_Library::PIP_Tree_Node::parent_merge(), Parma_Polyhedra_Library::PIP_Tree_Node::set_parent(), Parma_Polyhedra_Library::PIP_Tree_Node::solve(), Parma_Polyhedra_Library::Constraint_System::swap(), and true_child.

00827                                                       {
00828 #ifdef NOISY_PIP_TREE_STRUCTURE
00829   indent_and_print(std::cerr, indent_level, "=== SOLVING DECISION NODE\n");
00830 #else
00831   used(indent_level);
00832 #endif
00833   PPL_ASSERT(true_child != 0);
00834   Matrix context_true(context);
00835   Variables_Set all_params(params);
00836   const dimension_type num_art_params = artificial_parameters.size();
00837   add_artificial_parameters(context_true, all_params, space_dim,
00838                             num_art_params);
00839   merge_assign(context_true, constraints_, all_params);
00840   bool has_false_child = (false_child != 0);
00841   bool has_true_child = (true_child != 0);
00842 #ifdef NOISY_PIP_TREE_STRUCTURE
00843   indent_and_print(std::cerr, indent_level,
00844                    "=== DECISION: SOLVING THEN CHILD\n");
00845 #endif
00846   true_child = true_child->solve(pip, check_feasible_context,
00847                                  context_true, all_params, space_dim,
00848                                  indent_level + 1);
00849 
00850   if (has_false_child) {
00851     // Decision nodes with false child must have exactly one constraint
00852     PPL_ASSERT(1 == std::distance(constraints_.begin(), constraints_.end()));
00853     // NOTE: modify context_true in place, complementing its last constraint.
00854     Matrix& context_false = context_true;
00855     Row& last = context_false[context_false.num_rows()-1];
00856     complement_assign(last, last, 1);
00857 #ifdef NOISY_PIP_TREE_STRUCTURE
00858     indent_and_print(std::cerr, indent_level,
00859                      "=== DECISION: SOLVING ELSE CHILD\n");
00860 #endif
00861     false_child = false_child->solve(pip, check_feasible_context,
00862                                      context_false, all_params, space_dim,
00863                                      indent_level + 1);
00864   }
00865 
00866   if (true_child == 0 && false_child == 0) {
00867     // No childs: the whole subtree is unfeasible.
00868 #ifdef NOISY_PIP_TREE_STRUCTURE
00869     indent_and_print(std::cerr, indent_level,
00870                      "=== DECISION: BOTH BRANCHES NOW UNFEASIBLE: _|_\n");
00871 #endif
00872     delete this;
00873     return 0;
00874   }
00875 
00876   if (has_false_child && false_child == 0) {
00877     // False child has become unfeasible: merge this node's artificials with
00878     // the true child, while removing the local parameter constraints, which
00879     // are no longer discriminative.
00880 #ifdef NOISY_PIP_TREE_STRUCTURE
00881     indent_and_print(std::cerr, indent_level,
00882                      "=== DECISION: ELSE BRANCH NOW UNFEASIBLE\n");
00883     indent_and_print(std::cerr, indent_level,
00884                      "==> merge then branch with parent.\n");
00885 #endif
00886     PIP_Tree_Node* node = true_child;
00887     node->parent_merge();
00888     node->set_parent(parent());
00889     true_child = 0;
00890     delete this;
00891     PPL_ASSERT(node->OK());
00892     return node;
00893   }
00894   else if (has_true_child && true_child == 0) {
00895     // True child has become unfeasible: merge this node's artificials
00896     // with the false child.
00897 #ifdef NOISY_PIP_TREE_STRUCTURE
00898     indent_and_print(std::cerr, indent_level,
00899                      "=== DECISION: THEN BRANCH NOW UNFEASIBLE\n");
00900     indent_and_print(std::cerr, indent_level,
00901                      "==> merge else branch with parent.\n");
00902 #endif
00903     PIP_Tree_Node* node = false_child;
00904     node->parent_merge();
00905     node->set_parent(parent());
00906     false_child = 0;
00907     delete this;
00908     PPL_ASSERT(node->OK());
00909     return node;
00910   }
00911   else if (check_feasible_context) {
00912     // Test all constraints for redundancy with the context, and eliminate
00913     // them if not necessary.
00914     Constraint_System cs;
00915     cs.swap(constraints_);
00916     const Constraint_System::const_iterator end = cs.end();
00917     for (Constraint_System::const_iterator ci = cs.begin(); ci != end; ++ci) {
00918       Matrix ctx_copy(context);
00919       merge_assign(ctx_copy, Constraint_System(*ci), all_params);
00920       Row& last = ctx_copy[ctx_copy.num_rows()-1];
00921       complement_assign(last, last, 1);
00922       if (compatibility_check(ctx_copy)) {
00923         // The constraint is not redundant with the context: we must keep it.
00924         constraints_.insert(*ci);
00925       }
00926     }
00927     // If the constraints set has become empty, only keep the true child.
00928     if (constraints_.empty()) {
00929 #ifdef NOISY_PIP_TREE_STRUCTURE
00930       indent_and_print(std::cerr, indent_level,
00931                        "=== DECISION: NO BRANCHING CONSTRAINTS LEFT\n");
00932       indent_and_print(std::cerr, indent_level,
00933                        "==> merge then branch with parent.\n");
00934 #endif
00935       PIP_Tree_Node* node = true_child;
00936       node->parent_merge();
00937       node->set_parent(parent());
00938       true_child = 0;
00939       delete this;
00940       PPL_ASSERT(node->OK());
00941       return node;
00942     }
00943   }
00944   PPL_ASSERT(OK());
00945   return this;
00946 }

memory_size_type Parma_Polyhedra_Library::PIP_Decision_Node::total_memory_in_bytes (  )  const [virtual]

Returns the total size in bytes of the memory occupied by *this.

Implements Parma_Polyhedra_Library::PIP_Tree_Node.

Definition at line 2873 of file PIP_Tree.cc.

References external_memory_in_bytes().

02873                                                {
02874   return sizeof(*this) + external_memory_in_bytes();
02875 }

void Parma_Polyhedra_Library::PIP_Decision_Node::update_tableau ( const PIP_Problem pip,
dimension_type  external_space_dim,
dimension_type  first_pending_constraint,
const Constraint_Sequence input_cs,
const Variables_Set parameters 
) [protected, virtual]

Implements pure virtual method PIP_Tree_Node::update_tableau.

Implements Parma_Polyhedra_Library::PIP_Tree_Node.

Definition at line 802 of file PIP_Tree.cc.

References false_child, OK(), true_child, and Parma_Polyhedra_Library::PIP_Tree_Node::update_tableau().

00806                                                                    {
00807   true_child->update_tableau(pip,
00808                              external_space_dim,
00809                              first_pending_constraint,
00810                              input_cs,
00811                              parameters);
00812   if (false_child)
00813     false_child->update_tableau(pip,
00814                                 external_space_dim,
00815                                 first_pending_constraint,
00816                                 input_cs,
00817                                 parameters);
00818   PPL_ASSERT(OK());
00819 }


Friends And Related Function Documentation

bool PIP_Problem::ascii_load ( std::istream &  s  )  [friend]
friend class PIP_Solution_Node [friend]

Reimplemented from Parma_Polyhedra_Library::PIP_Tree_Node.

Definition at line 726 of file PIP_Tree.defs.hh.

Referenced by ascii_load().


Member Data Documentation


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