Changeset 488

Timestamp:

12/06/10 16:24:09 (14 years ago)

Author:

grlod

Message:

Comments and compiler warnings correction.

Location:

trunk/yao/src/YAOObjects

Files:

• Connection.hpp (modified) (7 diffs)
• Operator.hpp (modified) (2 diffs)
• Order.cpp (modified) (53 diffs)
• Order.hpp (modified) (2 diffs)
• SpaceExtent.hpp (modified) (1 diff)

trunk/yao/src/YAOObjects/Connection.hpp

@@ -51 +51 @@
    *  If the member concern both stages we do not put anything.
    *
-   *  The class has some significant property: "from", "N° output", "Ci", "Cj", "Ck", "Ct", "to", "N° input". These can be retrieved with the methods:
+   *  The class has some significant property: "from", "Nￜ output", "Ci", "Cj", "Ck", "Ct", "to", "Nￜ input". These can be retrieved with the methods:
    *  getPropertyCount, getPropertyName and getProperty. These methods are useful above all in the second stage and they are used to shows 
    *  in a structured way the properties of the theConnectionTable object that is a table composed of Connection objects.
@@ -73 +73 @@
 
     //! Default constructor.
-    Connection(): reli(0), relj(0), relk(0), relt(0), inBegin(0), inEnd(0), outBegin(0), outEnd(0), t(false), T(false){} 
+    Connection():  inBegin(0), outBegin(0), inEnd(0), outEnd(0), reli(0), relj(0), relk(0), relt(0), t(false), T(false){}
     
     /** 
@@ -405 +405 @@
     /**
      * Allows to have a nice and automatic visualization of the Connection object elements. 
-     * In this method we retrive this kind of propertis: "from", "N° output", "Ci", "Cj", "Ck", "Ct", "to", "N° input".
+     * In this method we retrive this kind of propertis: "from", "Nￜ output", "Ci", "Cj", "Ck", "Ct", "to", "Nￜ input".
      * These are prefixed string that never change.
      * @param anIndex is the number of property required.
@@ -418 +418 @@
     /**
      * Allows to have a nice and automatic visualization of the Connection object elements. 
-     * In this method we retrive the value of significant property: "from", "N° output", "Ci", "Cj", "Ck", "Ct", "to", "N° input".
+     * In this method we retrive the value of significant property: "from", "Nￜ output", "Ci", "Cj", "Ck", "Ct", "to", "Nￜ input".
      * In function of the integer in input to the method we retrieve the respective property.
      * @param anIndex is the number of property required.
@@ -455 +455 @@
     short reli, relj, relk;                           
     
-    //! Relative or absolute displacement for t and T coordinates. 
+    //! Relative or absolute displacement for t and T coordinates.
     //! 0  ==> t not present in the ctin-m directive;
     //! -1 ==> absolute displacement;
@@ -461 +461 @@
     //!  2 ==> relative displacement if the input trajectory is different from the output trajectory and we have 't' in the description file.
     //! In this case we have to translate the instants from the inTraj to the outTraj.
-    short relt;   
+    short relt;
     bool ctinType;  //!< True if ctin, false if ctinm.
 
@@ -470 +470 @@
 /**
  * Allows to have a nice and automatic visualization of the Connection object elements. 
- * In this method we retrive the value of significant property: "from", "N° output", "Ci", "Cj", "Ck", "Ct", "to", "N° input".
+ * In this method we retrive the value of significant property: "from", "Nￜ output", "Ci", "Cj", "Ck", "Ct", "to", "Nￜ input".
  * In function of the integer in input to the method we retrieve the respective property.
  * @param anIndex is the number of property required.

trunk/yao/src/YAOObjects/Operator.hpp

@@ -49 +49 @@
        */
       Operator(const std::string& aName=""): 
-        Component<Trajectory>(aName, 0), theType(Operator::M), counterOrderHeader(false), counterOrderBody(false){}
+        Component<Trajectory>(aName, 0), counterOrderHeader(false), counterOrderBody(false), theType(Operator::M) {}
 
       /**
@@ -59 +59 @@
        */
       Operator(const std::string& aName, const Trajectory* aParent, std::vector<int> aShape, Type aType=Operator::M):
-        Component<Trajectory>(aName, aParent), SpaceExtent(aShape), theType(aType), counterOrderHeader(false), counterOrderBody(false){}
+        Component<Trajectory>(aName, aParent), SpaceExtent(aShape), counterOrderHeader(false), counterOrderBody(false), theType(aType){}
 
       /**

trunk/yao/src/YAOObjects/Order.cpp

@@ -210 +210 @@
  */
 void Order::reverseTokenList(struct st_token *atoken){  
-        struct st_token *q0, *q1;           // Pointer on the begin of the list_inst of the chain.
+        struct st_token *q0=NULL, *q1=NULL;         // Pointer on the begin of the list_inst of the chain.
         struct st_token *p1, *p2, *pe;// Pointer that allow the reverse of the list elements and that progress each time
 
@@ -360 +360 @@
         // ---------------------------------------------------------------------------- 
 
-        int nbSpace;
+        int nbSpace = 0;
 
         // For all the order object inside the order table
@@ -856 +856 @@
                         stringstream theConnection; 
 
+
                         theConnection << itSource -> getName() << "(" << tok_tab -> getI() << ", " << tok_tab -> getJ() << ", " << tok_tab -> getK() << ") ==> " << itTarget -> getName() << " : ";
+
+
 
                         // Keep connections if the moduls are integrated in an order statement
@@ -1291 +1294 @@
         // -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------  
 
-        if(itSource -> getAxisVal(numDim) > 0 && valCijk[itSource -> getAxisNumber(numDim) - 1] > 0) return 1;  
+        if(itSource -> getAxisVal(numDim) > 0 && valCijk[itSource -> getAxisNumber(numDim) - 1] > 0)
+                return 1;
 
 } 
@@ -1389 +1393 @@
                         // ---------------------------------------------------------
 
-                        for(int noTraj = 0; noTraj < trajVector.size(); noTraj++)
+                        for(unsigned int noTraj = 0; noTraj < trajVector.size(); noTraj++)
 
                                 // If the trajectory match the current one, then it should be considerated as already integrated
@@ -1434 +1438 @@
         // -----------------------
 
-        for(int i = 0; i < spacesList.size(); i++) add_vertex(spaceGraph);
+        for(unsigned int i = 0; i < spacesList.size(); i++) add_vertex(spaceGraph);
 
         // Register the space name inside each vertex
@@ -1498 +1502 @@
         // -------------------------
 
-        for(int noTraj = 0; noTraj < trajVector.size(); noTraj++) {
+        for(unsigned int noTraj = 0; noTraj < trajVector.size(); noTraj++) {
 
                 int orderId = -1;
@@ -1505 +1509 @@
                 // ------------------
 
-                for(int noSpace = 0; noSpace < topoOrder.size(); noSpace++) {
+                for(unsigned int noSpace = 0; noSpace < topoOrder.size(); noSpace++) {
 
                         // In the order that have been defined to the spaces by the topological sort
@@ -1543 +1547 @@
         // --------------------------------
 
-        for(int noTraj = 0; noTraj < trajOrder.size(); noTraj++) {
+        for(unsigned int noTraj = 0; noTraj < trajOrder.size(); noTraj++) {
 
                 // For all the space numbers
                 // -------------------------
 
-                for(int noSpace = 0; noSpace < topoOrder.size(); noSpace++) {
+                for(unsigned int noSpace = 0; noSpace < topoOrder.size(); noSpace++) {
 
                         // In the order that have been defined to the spaces by the topological sort
@@ -1809 +1813 @@
 
 
-        /*
+
          * Perform the spaceintraj writting.
          * For each trajectory in the trajectories order that have been performed (maybe not needed).
@@ -1819 +1823 @@
         // --------------------------------
 
-        for(int noTraj = 0; noTraj < trajOrder.size(); noTraj++) {
+        for(unsigned int noTraj = 0; noTraj < trajOrder.size(); noTraj++) {
 
                 ofstream hiddenFile;
@@ -1848 +1852 @@
                 // -------------------------
 
-                for(int noSpace = 0; noSpace < topoOrder.size(); noSpace++) {
+                for(unsigned int noSpace = 0; noSpace < topoOrder.size(); noSpace++) {
 
                         // In the order that have been defined to the spaces by the topological sort
@@ -1891 +1895 @@
 
 
-int Order::getModulIndex(string mod, const vector<string>& tab, int index) { for(int i = 0; i < index; i++) if(tab[i] == mod) return i; }
+int Order::getModulIndex(string mod, const vector<string>& tab, int index)
+{
+        for(int i = 0; i < index; i++)
+                if(tab[i] == mod)
+                        return i;
+}
 
 void Order::to3D(int nbDim, vector<int>& valCi, vector<int>& valCj, vector<int>& valCk, int nbEdges) {
@@ -1919 +1928 @@
         // ---------------------------------------------------------------
 
-        for(int i = 0; i < modulList.size(); i++) add_vertex(currentGraph);
-
-        for(int i = 0; i < edgeArray.size(); i++) add_edge(edgeArray[i].first, edgeArray[i].second, currentGraph);
+        for(unsigned int i = 0; i < modulList.size(); i++) add_vertex(currentGraph);
+
+        for(unsigned int i = 0; i < edgeArray.size(); i++) add_edge(edgeArray[i].first, edgeArray[i].second, currentGraph);
 
 
@@ -1979 +1988 @@
         // -----------------------------------------------------
 
-        for(int noComp3D = 0; noComp3D < outerComp.size(); noComp3D++) {
+        for(unsigned int noComp3D = 0; noComp3D < outerComp.size(); noComp3D++) {
 
                 // Display all relevant informations on components : dimension and sign of the three first axis
@@ -1999 +2008 @@
         // ------------------------------------------------------
 
-        for(int noComp3D = 0; noComp3D < outerComp.size(); noComp3D++) {
+        for(unsigned int noComp3D = 0; noComp3D < outerComp.size(); noComp3D++) {
 
                 //  For all 2D component embedded in the vector middleComp
                 // -------------------------------------------------------
 
-                for(int noComp2D = 0; noComp2D < middleComp[noComp3D][noFixed1].size(); noComp2D++) {
+                for(unsigned int noComp2D = 0; noComp2D < middleComp[noComp3D][noFixed1].size(); noComp2D++) {
 
                         // For all 1D component embedded in the vector innerComp
                         // -----------------------------------------------------
 
-                        for(int noComp1D = 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noFixed2].size(); noComp1D++)  {
+                        for(unsigned int noComp1D = 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noFixed2].size(); noComp1D++)  {
 
                                 // Display all relevant informations on components : dimension and sign of the remaining axis then embedded moduls
@@ -2019 +2028 @@
                                                 << innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].cfcSign[0].second << ", modulees : ";
 
-                                for(int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].embeddedModuls.size(); noMod++) {
+                                for(unsigned int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].embeddedModuls.size(); noMod++) {
 
                                         cout << boost::get(boost::vertex_name_t(), myGraph, innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].embeddedModuls[noMod]) << " ";
@@ -2053 +2062 @@
         // -----------------------------------------------------------------------------
 
-        for(int i = 0; i < outerComponentsList.size(); i++) put(get(boost::vertex_affected_comp_t(), myGraph), i, outerComponentsList[i]);
+        for(unsigned int i = 0; i < outerComponentsList.size(); i++) put(get(boost::vertex_affected_comp_t(), myGraph), i, outerComponentsList[i]);
 
         // Setting the number of components that have been detected
@@ -2394 +2403 @@
                 vector<cfcStruct> sortedOuterCfcStructTable;
 
-                for(int noComponent = 0; noComponent < topoOrder.size(); noComponent++) {
+                for(unsigned int noComponent = 0; noComponent < topoOrder.size(); noComponent++) {
 
                         sortedOuterCfcStructTable.push_back(outerComp[topoOrder[noComponent]]);
@@ -2406 +2415 @@
                 outerComp.clear();
 
-                for(int noComponent = 0; noComponent < topoOrder.size(); noComponent++) {
+                for(unsigned int noComponent = 0; noComponent < topoOrder.size(); noComponent++) {
 
                         isImposed[noComponent][0] = sortedIsImposed[noComponent][0];
@@ -2432 +2441 @@
         // ----------------------------------------------------------------------------------------
 
-        for(int noComp3D = 0; noComp3D <  outerComp.size(); noComp3D++) middleComp[noComp3D]  = new cfcStructTableType[3];
+        for(unsigned int noComp3D = 0; noComp3D <  outerComp.size(); noComp3D++) middleComp[noComp3D]  = new cfcStructTableType[3];
 
         // Set the inner component (1D) array second dimension to 3 (one by first fixed dimension)
         // ---------------------------------------------------------------------------------------
 
-        for(int noComp3D = 0; noComp3D <  outerComp.size(); noComp3D++) innerComp[noComp3D]  = new cfcStructTableType**[3];
+        for(unsigned int noComp3D = 0; noComp3D <  outerComp.size(); noComp3D++) innerComp[noComp3D]  = new cfcStructTableType**[3];
 
         // For each 3D component
         // ---------------------
 
-        for(int noComp = 0; noComp <  outerComp.size(); noComp++) {
+        for(unsigned int noComp = 0; noComp <  outerComp.size(); noComp++) {
 
                 // Create a graph that just contain vertices and edges included in the current 3D component (ie extract the current 3D component from the main graph)
@@ -2511 +2520 @@
         // -----------------------------------
 
-        for(int i = 0; i < edgeIterVector.size(); i++)
+        for(unsigned int i = 0; i < edgeIterVector.size(); i++)
 
                 // If the edge does not connect two nodes of the component "noComp" given as parameter (ie. if the edge is not fully integrated in the comoponent)
@@ -2543 +2552 @@
         // -----------------------------------
 
-        for(int i = 0; i < vertexIterVector.size(); i++)
+        for(unsigned int i = 0; i < vertexIterVector.size(); i++)
 
                 // If the vertex is not a part of the component "noComp" given as parameter
@@ -2562 +2571 @@
         cout << endl << "showMiddle(" << noFixed1 << ")";
 
-        for(int noComp3D = 0; noComp3D < outerComp.size(); noComp3D++) {
-
-                for(int noComp2D = 0; noComp2D < middleComp[noComp3D][noFixed1].size(); noComp2D++) {
+        for(unsigned int noComp3D = 0; noComp3D < outerComp.size(); noComp3D++) {
+
+                for(unsigned int noComp2D = 0; noComp2D < middleComp[noComp3D][noFixed1].size(); noComp2D++) {
 
                         cout << endl    << "middleComp[" << noComp3D << "][" << noFixed1 << "][" << noComp2D << "].cfcSign[0].first : "
@@ -2574 +2583 @@
                         cout << endl;
 
-                        for(int noMod = 0; noMod < middleComp[noComp3D][noFixed1][noComp2D].embeddedModuls.size(); noMod++) {
+                        for(unsigned int noMod = 0; noMod < middleComp[noComp3D][noFixed1][noComp2D].embeddedModuls.size(); noMod++) {
 
                                 cout << endl << "middleComp[" << noComp3D << "][" << noFixed1 << "][" << noComp2D << "].EmbeddedModuls[" << noMod << "] : "
@@ -2643 +2652 @@
         // --------------------------------------------------------------------------------------------------------------
 
-        for(int noVertex = 0; noVertex < boost::num_vertices(upperGraph); noVertex++) add_vertex(outGraph);
+        for(unsigned int noVertex = 0; noVertex < boost::num_vertices(upperGraph); noVertex++) add_vertex(outGraph);
 
         // Add one edge for each edge of the graph that have to be copied (the vertices are created with the same indexes than in the original graph and then the edges connect the right vertices)
@@ -3035 +3044 @@
         // ----------------------------------------------------------------------------------
 
-        for(int i = 0; i < fixedComponentsList.size(); i++) put(get(boost::vertex_affected_comp_t(), currentGraph), i, fixedComponentsList[i]);
+        for(unsigned int i = 0; i < fixedComponentsList.size(); i++) put(get(boost::vertex_affected_comp_t(), currentGraph), i, fixedComponentsList[i]);
 
         // Get the number of 1D components detected
@@ -3062 +3071 @@
         // ----------------------------------
 
-        for(int noComp1D = 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noFixed2].size(); noComp1D++) {
+        for(unsigned int noComp1D = 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noFixed2].size(); noComp1D++) {
 
                 innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].cfcSign.resize(1);
@@ -3073 +3082 @@
         // --------------------------------------------------------------------------------
 
-        for(int i = 0; i < fixedComponentsList.size(); i++) {
+        for(unsigned int i = 0; i < fixedComponentsList.size(); i++) {
 
                 innerComp[noComp3D][noFixed1][noComp2D][noFixed2][fixedComponentsList[i]].embeddedModuls.push_back(boost::get(boost::vertex_original_id_t(), currentGraph, i));
@@ -3124 +3133 @@
         boost::topological_sort(currentGraph, std::front_inserter(topoOrder), boost::vertex_index_map(boost::identity_property_map()));
 
-        for(int i = 0; i < topoOrder.size(); i++) put(get(boost::vertex_topo_order_t(), currentGraph), topoOrder[i], i);
+        for(unsigned int i = 0; i < topoOrder.size(); i++) put(get(boost::vertex_topo_order_t(), currentGraph), topoOrder[i], i);
 
         // ETAPE 5.2 DE LA PROCEDURE A UNE DIMENSION
@@ -3132 +3141 @@
         // -----------------------------------------------------
 
-        for(int noComp1D = 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noFixed2].size(); noComp1D++) {
-
-                for(int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].embeddedModuls.size(); noMod++) {
-
-                        for(int noMod2 = noMod + 1; noMod2 < innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].embeddedModuls.size(); noMod2++) {
+        for(unsigned int noComp1D = 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noFixed2].size(); noComp1D++) {
+
+                for(unsigned int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].embeddedModuls.size(); noMod++) {
+
+                        for(unsigned int noMod2 = noMod + 1; noMod2 < innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].embeddedModuls.size(); noMod2++) {
 
                                 if(get(boost::vertex_topo_order_t(), currentGraph, innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].embeddedModuls[noMod])  >
@@ -3177 +3186 @@
                 vector<cfcStruct> sortedCfcStructTable;
 
-                for(int noComponent = 0; noComponent < reducedTopoOrder.size(); noComponent++) sortedCfcStructTable.push_back(innerComp[noComp3D][noFixed1][noComp2D][noFixed2][reducedTopoOrder[noComponent]]);
+                for(unsigned int noComponent = 0; noComponent < reducedTopoOrder.size(); noComponent++) sortedCfcStructTable.push_back(innerComp[noComp3D][noFixed1][noComp2D][noFixed2][reducedTopoOrder[noComponent]]);
 
                 innerComp[noComp3D][noFixed1][noComp2D][noFixed2].clear();
 
-                for(int noComponent = 0; noComponent < reducedTopoOrder.size(); noComponent++) innerComp[noComp3D][noFixed1][noComp2D][noFixed2].push_back(sortedCfcStructTable[noComponent]);
+                for(unsigned int noComponent = 0; noComponent < reducedTopoOrder.size(); noComponent++) innerComp[noComp3D][noFixed1][noComp2D][noFixed2].push_back(sortedCfcStructTable[noComponent]);
 
         }
@@ -3210 +3219 @@
         // -------------------------------
 
-        for(int i = 0; i < edgeIterVector.size(); i++) {
+        for(unsigned int i = 0; i < edgeIterVector.size(); i++) {
 
                 // If the sign value for the edge is not null for the dimension "noFixedDim" given as parameter, then delete the edge
@@ -3284 +3293 @@
         // ------------------------------------------------------------------------------
 
-        for(int i = 0; i < middleComponentsList.size(); i++) put(get(boost::vertex_affected_comp_t(), fixedGraph), i, middleComponentsList[i]);
+        for(unsigned int i = 0; i < middleComponentsList.size(); i++) put(get(boost::vertex_affected_comp_t(), fixedGraph), i, middleComponentsList[i]);
 
         // Setting the number of components that have been detected
@@ -3461 +3470 @@
                 vector<cfcStruct> sortedCfcStructTable;
 
-                for(int noComponent = 0; noComponent < topoOrder.size(); noComponent++) sortedCfcStructTable.push_back(middleComp[noComp][fixedDim][topoOrder[noComponent]]);
+                for(unsigned int noComponent = 0; noComponent < topoOrder.size(); noComponent++) sortedCfcStructTable.push_back(middleComp[noComp][fixedDim][topoOrder[noComponent]]);
 
                 middleComp[noComp][fixedDim].clear();
 
-                for(int noComponent = 0; noComponent < topoOrder.size(); noComponent++) middleComp[noComp][fixedDim].push_back(sortedCfcStructTable[noComponent]);
+                for(unsigned int noComponent = 0; noComponent < topoOrder.size(); noComponent++) middleComp[noComp][fixedDim].push_back(sortedCfcStructTable[noComponent]);
 
         }
@@ -3537 +3546 @@
         // -----------------------------------------------
 
-        for(int noComp3D = 0; noComp3D < outerComp.size(); noComp3D++) {
+        for(unsigned int noComp3D = 0; noComp3D < outerComp.size(); noComp3D++) {
 
                 // For all the components embedded in the 2D graph coming from the current 3D component
                 // ------------------------------------------------------------------------------------
 
-                for(int noComp2D = 0; noComp2D < middleComp[noComp3D][0].size(); noComp2D++)  {
+                for(unsigned int noComp2D = 0; noComp2D < middleComp[noComp3D][0].size(); noComp2D++)  {
 
                         // For all the components embedded in the 1D graph coming from the current 2D component
                         // ------------------------------------------------------------------------------------
 
-                        for(int noComp1D = 0; noComp1D < innerComp[noComp3D][0][noComp2D][1].size(); noComp1D++)  {
+                        for(unsigned int noComp1D = 0; noComp1D < innerComp[noComp3D][0][noComp2D][1].size(); noComp1D++)  {
 
                                 // Get the value of the first axis (third in the data structure as it is a 3D data structure, no need to get the number of the axis as there is only one)
@@ -3567 +3576 @@
                                 // --------------------------------------------------------
 
-                                for(int noMod = 0; noMod < innerComp[noComp3D][0][noComp2D][1][noComp1D].embeddedModuls.size(); noMod++) {
+                                for(unsigned int noMod = 0; noMod < innerComp[noComp3D][0][noComp2D][1][noComp1D].embeddedModuls.size(); noMod++) {
 
                                         // Insert the modules after the paramaters
@@ -3599 +3608 @@
         // ----------------------------------------
 
-        for(int noComp3D = 0; noComp3D < outerComp.size(); noComp3D++) {
+        for(unsigned int noComp3D = 0; noComp3D < outerComp.size(); noComp3D++) {
 
                 // For all components in the 2D graph coming from the current 3D component with the first axis fixed
                 // -------------------------------------------------------------------------------------------------
 
-                for(int noComp2D = 0; noComp2D < middleComp[noComp3D][0].size(); noComp2D++)  {
+                for(unsigned int noComp2D = 0; noComp2D < middleComp[noComp3D][0].size(); noComp2D++)  {
 
                         // Get the the the first axis dimension (second in the data structure as it is a 3D data structure)
@@ -3650 +3659 @@
                                 // -----------------------------------------------------------------------------------------------------
 
-                                for(int noComp1D = 0; noComp1D < innerComp[noComp3D][0][noComp2D][noFixed1].size(); noComp1D++) {
+                                for(unsigned int noComp1D = 0; noComp1D < innerComp[noComp3D][0][noComp2D][noFixed1].size(); noComp1D++) {
 
                                         // For all the moduls embedded in the current 1D component
                                         // -------------------------------------------------------
 
-                                        for(int noMod = 0; noMod < innerComp[noComp3D][0][noComp2D][noFixed1][noComp1D].embeddedModuls.size(); noMod++) {
+                                        for(unsigned int noMod = 0; noMod < innerComp[noComp3D][0][noComp2D][noFixed1][noComp1D].embeddedModuls.size(); noMod++) {
 
                                                 // Insert the modul name in the current order parameter
@@ -3679 +3688 @@
                                 // -------------------------------------------------------------------------------------------------
 
-                                for(int noComp1D = 0; noComp1D < innerComp[noComp3D][0][noComp2D][noFixed1].size(); noComp1D++) {
+                                for(unsigned int noComp1D = 0; noComp1D < innerComp[noComp3D][0][noComp2D][noFixed1].size(); noComp1D++) {
 
                                         // Get the second axis dimension (third in the data structure as it is a 3D data structure)
@@ -3704 +3713 @@
                                         // -------------------------------------------------------
 
-                                        for(int noMod = 0; noMod < innerComp[noComp3D][0][noComp2D][noFixed1][noComp1D].embeddedModuls.size(); noMod++) {
+                                        for(unsigned int noMod = 0; noMod < innerComp[noComp3D][0][noComp2D][noFixed1][noComp1D].embeddedModuls.size(); noMod++) {
 
                                                 // Insert the modul name in the current order parameter
@@ -3738 +3747 @@
         // -----------------------------------------------
 
-        for(int noComp3D = 0; noComp3D < outerComp.size(); noComp3D++) {
+        for(unsigned int noComp3D = 0; noComp3D < outerComp.size(); noComp3D++) {
 
                 // Get the axis number (dimension) and the axis value of the first axis crossed in the order statement
@@ -3789 +3798 @@
                                 // -----------------------------------------------------------------------------------------------------------------------
 
-                                for(int noComp2D = 0; noComp2D < middleComp[noComp3D][noFixed1].size(); noComp2D++) {
+                                for(unsigned int noComp2D = 0; noComp2D < middleComp[noComp3D][noFixed1].size(); noComp2D++) {
 
                                         // Get the number of the second axis crossed in the order statement
@@ -3799 +3808 @@
                                         // -------------------------------------------------------------------------------------------------------------------------
 
-                                        for(int noComp1D= 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noAxis2].size(); noComp1D++) {
+                                        for(unsigned int noComp1D= 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noAxis2].size(); noComp1D++) {
 
                                                 // For all moduls embedded in the current 1D graph component
                                                 // ---------------------------------------------------------
 
-                                                for(int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
+                                                for(unsigned int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
 
                                                         // Display the modul name (that will appear after the order paramaters that have been read before)
@@ -3827 +3836 @@
                                 // -----------------------------------------------------------------------------------------------------------------------
 
-                                for(int noComp2D = 0; noComp2D < middleComp[noComp3D][noFixed1].size(); noComp2D++) {
+                                for(unsigned int noComp2D = 0; noComp2D < middleComp[noComp3D][noFixed1].size(); noComp2D++) {
 
 
@@ -3838 +3847 @@
                                         // -------------------------------------------------------------------------------------------------------------------------
 
-                                        for(int noComp1D = 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noAxis2].size(); noComp1D++) {
+                                        for(unsigned int noComp1D = 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noAxis2].size(); noComp1D++) {
 
                                                 // Get the number of the third axis crossed in the order statement
@@ -3864 +3873 @@
                                                 // ---------------------------------------------------------
 
-                                                for(int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
+                                                for(unsigned int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
 
                                                         // Display the modul name (that will appear after the order paramaters that have been read before)
@@ -3891 +3900 @@
                         // -----------------------------------------------------------------------------------------------------------------------
 
-                        for(int noComp2D = 0; noComp2D < middleComp[noComp3D][noFixed1].size(); noComp2D++) {
+                        for(unsigned int noComp2D = 0; noComp2D < middleComp[noComp3D][noFixed1].size(); noComp2D++) {
 
                                 // Get the number of the second axis crossed in the order statement
@@ -3942 +3951 @@
                                                 // ------------------------------------------------------------------------------------------------------------------------------
 
-                                                for(int noComp1D= 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noAxis2].size(); noComp1D++) {
+                                                for(unsigned int noComp1D= 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noAxis2].size(); noComp1D++) {
 
                                                         // For all moduls embedded in the current 1D graph component
                                                         // ---------------------------------------------------------
 
-                                                        for(int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
+                                                        for(unsigned int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
 
                                                                 // Display the modul name (that will appear after the order paramaters that have been readen before)
@@ -3970 +3979 @@
                                                 // ------------------------------------------------------------------------------------------------------------------------------
 
-                                                for(int noComp1D= 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noAxis2].size(); noComp1D++) {
+                                                for(unsigned int noComp1D= 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noAxis2].size(); noComp1D++) {
 
                                                         // Get the number of the third axis crossed in the order statement
@@ -3996 +4005 @@
                                                         // ---------------------------------------------------------
 
-                                                        for(int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
+                                                        for(unsigned int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
 
                                                                 // Display the modul name (that will appear after the order paramaters that have been readen before)
@@ -4311 +4320 @@
         // -------------------------------
 
-        for(int i = 0; i < edgeIterVector.size(); i++) boost::remove_edge(*(edgeIterVector[i]), currentGraph);
+        for(unsigned int i = 0; i < edgeIterVector.size(); i++) boost::remove_edge(*(edgeIterVector[i]), currentGraph);
 
         // Putting iterators inside a vector is more convenient , especially for deletions
@@ -4333 +4342 @@
         // -----------------------------------
 
-        for(int i = 0; i < vertexIterVector.size(); i++) boost::remove_vertex(*(vertexIterVector[i]), currentGraph);
+        for(unsigned int i = 0; i < vertexIterVector.size(); i++)
+                boost::remove_vertex(*(vertexIterVector[i]), currentGraph);
 
 

trunk/yao/src/YAOObjects/Order.hpp

@@ -199 +199 @@
   /**
    *  Set up all the loops by scanning the order directives.
+   *  For each module, adds order information (axis order and direction, sequence with other modules, loop identifier )
    */
   void setLoop(Table<Connection>& theConnectionTable, Table<Modul>& theModulTable, Table<Space>& theSpaceTable, Table<Operator>& theOperatorTable, Table<Order>& theOrderTable);
@@ -274 +275 @@
 
    /**
-    *  A string that contain the project name given as a paramater to automaticOrderGenerator (declared here to avoid changing all the function calls)
+    *  A string that contain the project name given as a parameter to automaticOrderGenerator (declared here to avoid changing all the function calls)
     */
    string theProject;

trunk/yao/src/YAOObjects/SpaceExtent.hpp

@@ -55 +55 @@
        */
       int getYA(short YAx) const {
-        if(YAx==1) return theShape.size()? theShape[0] : 0;
-        if(YAx==2) return theShape.size() >= 2? theShape[1] : 0;
-        if(YAx==3) return theShape.size() == 3? theShape[2] : 0;
+          if(YAx==1) return theShape.size()? theShape[0] : 0;
+          if(YAx==2) return theShape.size() >= 2? theShape[1] : 0;
+          if(YAx==3) return theShape.size() == 3? theShape[2] : 0;
+          // Erroneous case
+          // 0 is better than nothing..
+          return 0;
       }