C:/Programme/home/Administrator/CD/stableSetCode/ProjectionNode.cpp

Go to the documentation of this file.
00001 
00002 //
00003 //  Module           : ProjectionNode.cpp
00004 //  Description      : Node of the edge projection tree.
00005 //  Author           : Steffen Rebennack
00006 //  Email            : srebenac@ix.urz.uni-heidelberg.de;
00007 //                     steffen.rebennack@web.de
00008 //  Copyright        : (C) 2006 by the University of L'Aquvila and
00009 //                     University of Heidelberg
00010 //  Created on       : Wed Apr 05 15:30:06 2006
00011 //  Last modified by : -
00012 //  Last modified on : -
00013 //  Update count     : 0
00014 //
00016 //
00017 //  Date        Name            Changes/Extensions
00018 //  ----        ----            ------------------
00019 //
00021 
00022 #include "ProjectionNode.hh"
00023 
00024 
00025 // -----------------------------------------------------------------------------
00026 // --------------- M e t h o d s  ( p u b l i c ) ------------------------------
00027 // -----------------------------------------------------------------------------
00028 
00029 
00030 // -----------------------------------------------------------------------------
00031 // C o n s t r u c t o r
00032 //
00033 // Copy all information of this node.
00034 // -----------------------------------------------------------------------------
00035 ProjectionNode::ProjectionNode(int *theEdge, vector<int> *theDeletedNodes,
00036                                vector<int*> *theDeletedEdges,
00037                                vector<int*> *theFalseEdges,
00038                                ProjectionNode *prevNode):
00039     previousNode(prevNode)
00040 {
00041     
00042     int i;    // Loop variable.
00043     int size; // Store a size.
00044 
00045     //
00046     // Copy projection edge.            
00047     //
00048     edge[0] = theEdge[0];
00049     edge[1] = theEdge[1];
00050 
00051     //
00052     // Copy the deleted nodes.
00053     //
00054     if (theDeletedNodes != NULL) {
00055         if(!theDeletedNodes->empty()) {
00056         size = theDeletedNodes->size();
00057         deletedNodes.resize(size);
00058         for (i=0; i<size; i++) {
00059             deletedNodes[i] = (*theDeletedNodes)[i];
00060         }}
00061     }// if
00062     
00063     //
00064     // Copy the deleted edges.
00065     //
00066     if (!theDeletedEdges->empty()) {
00067         int *anEdge;
00068         size = theDeletedEdges->size();
00069         deletedEdges.resize(size);
00070         for (i=0; i<size; i++) {
00071             anEdge = new int[2];
00072             anEdge[0] = (*theDeletedEdges)[i][0];
00073             anEdge[1] = (*theDeletedEdges)[i][1];
00074             deletedEdges[i] = anEdge;
00075         }
00076     }// if
00077     
00078     //
00079     // Copy the false edges.
00080     //
00081     if (!theFalseEdges->empty()) {
00082         int *anEdge;
00083         size = theFalseEdges->size();
00084         falseEdges.resize(size);
00085         for (i=0; i<size; i++) {
00086             anEdge = new int[2];
00087             anEdge[0] = (*theFalseEdges)[i][0];
00088             anEdge[1] = (*theFalseEdges)[i][1];
00089             falseEdges[i] = anEdge;
00090         }
00091     }// if
00092     
00093 }// end constructor
00094 
00095 
00096 // -----------------------------------------------------------------------------
00097 // D e s t r u c t o r
00098 // -----------------------------------------------------------------------------
00099 ProjectionNode::~ProjectionNode() {
00100 
00101     // Delete all edges.
00102     if (!deletedEdges.empty()) {
00103         for (int i=deletedEdges.size()-1; i>=0; i--) {
00104             delete [] deletedEdges[i];
00105             deletedEdges[i] = NULL;
00106         }
00107         deletedEdges.clear();
00108     }
00109     // Delete all false edges.
00110     if (!falseEdges.empty()) {
00111         for (int i=falseEdges.size()-1; i>=0; i--) {
00112             delete [] falseEdges[i];
00113             falseEdges[i] = NULL;
00114         }
00115         falseEdges.clear();
00116     }
00117     // Delete all sons of this node.
00118     if (!itsNodes.empty()) {
00119         for (int i=itsNodes.size()-1; i>=0; i--) {
00120             // Call destructor of each son of this node.
00121             delete itsNodes[i];
00122             itsNodes[i] = NULL;
00123         }
00124         itsNodes.clear();
00125     }
00126 
00127 }// end destructor
00128 
00129 
00130 // -----------------------------------------------------------------------------
00131 // a d d N o d e
00132 // -----------------------------------------------------------------------------
00133 ProjectionNode* ProjectionNode::addNode(int theEdge[2],
00134                                         vector<int> *theDeletedNodes,
00135                                         vector<int*> *theDeletedEdges,
00136                                         vector<int*> *theFalseEdges) {
00137     
00138     ProjectionNode *pN;
00139     pN = new ProjectionNode(theEdge, theDeletedNodes, theDeletedEdges,
00140                             theFalseEdges, this);
00141     itsNodes.push_back(pN);  
00142     
00143     return pN;
00144 }
00145     
00146 
00147 // -----------------------------------------------------------------------------
00148 // g e t E d g e
00149 // -----------------------------------------------------------------------------
00150 int ProjectionNode::getEdge(int i) {
00151     return edge[i];
00152 }
00153 
00154 
00155 // -----------------------------------------------------------------------------
00156 // g e t D e l e t e d N o d e s
00157 // -----------------------------------------------------------------------------
00158 vector<int>* ProjectionNode::getDeletedNodes() {  
00159     return &deletedNodes;
00160 }
00161 
00162 
00163 // -----------------------------------------------------------------------------
00164 // g e t D e l e t e d E d g e s
00165 // -----------------------------------------------------------------------------
00166 vector<int*>* ProjectionNode::getDeletedEdges() {    
00167     return &deletedEdges;
00168 }
00169 
00170     
00171 // -----------------------------------------------------------------------------
00172 // g e t F a l s e E d g e s
00173 // -----------------------------------------------------------------------------
00174 vector<int*>* ProjectionNode::getFalseEdges() {    
00175     return &falseEdges;
00176 }
00177 
00178 
00179 // -----------------------------------------------------------------------------
00180 // g e t P r e v i o u s N o d e
00181 // -----------------------------------------------------------------------------
00182 ProjectionNode* ProjectionNode::getPreviousNode() {    
00183     return previousNode;
00184 }
00185 
00186 

Generated on Fri Apr 28 15:49:59 2006 for Branch and Cut algorithm for the Maximum Stable Set Problem by  doxygen 1.4.6-NO