Improvements in Vec_Vec_t.

1 files changed, 129 insertions, 9 deletions

diff --git a/src/misc/vec/vecVec.h b/src/misc/vec/vecVec.h
index 18f6d75c..e888e4cf 100644
--- a/src/misc/vec/vecVec.h
+++ b/src/misc/vec/vecVec.h
@@ -56,12 +56,28 @@ struct Vec_Vec_t_
     for ( i = 0; (i < Vec_VecSize(vGlob)) && (((vVec) = (Vec_Ptr_t*)Vec_VecEntry(vGlob, i)), 1); i++ )
 #define Vec_VecForEachLevelStart( vGlob, vVec, i, LevelStart )                                \
     for ( i = LevelStart; (i < Vec_VecSize(vGlob)) && (((vVec) = (Vec_Ptr_t*)Vec_VecEntry(vGlob, i)), 1); i++ )
+#define Vec_VecForEachLevelStop( vGlob, vVec, i, LevelStop )                                  \
+    for ( i = 0; (i < LevelStop) && (((vVec) = (Vec_Ptr_t*)Vec_VecEntry(vGlob, i)), 1); i++ )
 #define Vec_VecForEachLevelStartStop( vGlob, vVec, i, LevelStart, LevelStop )                 \
-    for ( i = LevelStart; (i <= LevelStop) && (((vVec) = (Vec_Ptr_t*)Vec_VecEntry(vGlob, i)), 1); i++ )
+    for ( i = LevelStart; (i < LevelStop) && (((vVec) = (Vec_Ptr_t*)Vec_VecEntry(vGlob, i)), 1); i++ )
 #define Vec_VecForEachLevelReverse( vGlob, vVec, i )                                          \
-    for ( i = Vec_VecSize(vGlob) - 1; (i >= 0) && (((vVec) = (Vec_Ptr_t*)Vec_VecEntry(vGlob, i)), 1); i-- )
+    for ( i = Vec_VecSize(vGlob)-1; (i >= 0) && (((vVec) = (Vec_Ptr_t*)Vec_VecEntry(vGlob, i)), 1); i-- )
 #define Vec_VecForEachLevelReverseStartStop( vGlob, vVec, i, LevelStart, LevelStop )          \
-    for ( i = LevelStart; (i >= LevelStop) && (((vVec) = (Vec_Ptr_t*)Vec_VecEntry(vGlob, i)), 1); i-- )
+    for ( i = LevelStart-1; (i >= LevelStop) && (((vVec) = (Vec_Ptr_t*)Vec_VecEntry(vGlob, i)), 1); i-- )
+
+// iterators through levels 
+#define Vec_VecForEachLevelInt( vGlob, vVec, i )                                              \
+    for ( i = 0; (i < Vec_VecSize(vGlob)) && (((vVec) = (Vec_Int_t*)Vec_VecEntry(vGlob, i)), 1); i++ )
+#define Vec_VecForEachLevelIntStart( vGlob, vVec, i, LevelStart )                             \
+    for ( i = LevelStart; (i < Vec_VecSize(vGlob)) && (((vVec) = (Vec_Int_t*)Vec_VecEntry(vGlob, i)), 1); i++ )
+#define Vec_VecForEachLevelIntStop( vGlob, vVec, i, LevelStop )                               \
+    for ( i = 0; (i < LevelStop) && (((vVec) = (Vec_Int_t*)Vec_VecEntry(vGlob, i)), 1); i++ )
+#define Vec_VecForEachLevelIntStartStop( vGlob, vVec, i, LevelStart, LevelStop )              \
+    for ( i = LevelStart; (i < LevelStop) && (((vVec) = (Vec_Int_t*)Vec_VecEntry(vGlob, i)), 1); i++ )
+#define Vec_VecForEachLevelIntReverse( vGlob, vVec, i )                                       \
+    for ( i = Vec_VecSize(vGlob)-1; (i >= 0) && (((vVec) = (Vec_Int_t*)Vec_VecEntry(vGlob, i)), 1); i-- )
+#define Vec_VecForEachLevelIntReverseStartStop( vGlob, vVec, i, LevelStart, LevelStop )       \
+    for ( i = LevelStart-1; (i >= LevelStop) && (((vVec) = (Vec_Int_t*)Vec_VecEntry(vGlob, i)), 1); i-- )
 
 // iteratores through entries
 #define Vec_VecForEachEntry( Type, vGlob, pEntry, i, k )                                      \
@@ -73,7 +89,7 @@ struct Vec_Vec_t_
     for ( i = LevelStart; i < Vec_VecSize(vGlob); i++ )                                       \
         Vec_PtrForEachEntry( Type, (Vec_Ptr_t *)Vec_VecEntry(vGlob, i), pEntry, k ) 
 #define Vec_VecForEachEntryStartStop( Type, vGlob, pEntry, i, k, LevelStart, LevelStop )      \
-    for ( i = LevelStart; i <= LevelStop; i++ )                                               \
+    for ( i = LevelStart; i < LevelStop; i++ )                                                \
         Vec_PtrForEachEntry( Type, (Vec_Ptr_t *)Vec_VecEntry(vGlob, i), pEntry, k ) 
 #define Vec_VecForEachEntryReverse( Type, vGlob, pEntry, i, k )                               \
     for ( i = 0; i < Vec_VecSize(vGlob); i++ )                                                \
@@ -82,9 +98,31 @@ struct Vec_Vec_t_
     for ( i = Vec_VecSize(vGlob) - 1; i >= 0; i-- )                                           \
         Vec_PtrForEachEntryReverse( Type, (Vec_Ptr_t *)Vec_VecEntry(vGlob, i), pEntry, k ) 
 #define Vec_VecForEachEntryReverseStart( Type, vGlob, pEntry, i, k, LevelStart )              \
-    for ( i = LevelStart; i >= 0; i-- )                                                       \
+    for ( i = LevelStart-1; i >= 0; i-- )                                                     \
         Vec_PtrForEachEntry( Type, (Vec_Ptr_t *)Vec_VecEntry(vGlob, i), pEntry, k ) 
 
+// iteratores through entries
+#define Vec_VecForEachEntryInt( Type, vGlob, Entry, i, k )                                    \
+    for ( i = 0; i < Vec_VecSize(vGlob); i++ )                                                \
+        Vec_IntForEachEntry( Type, (Vec_Int_t *)Vec_VecEntry(vGlob, i), Entry, k ) 
+#define Vec_VecForEachEntryIntLevel( Type, vGlob, Entry, i, Level )                           \
+        Vec_IntForEachEntry( Type, (Vec_Int_t *)Vec_VecEntry(vGlob, Level), Entry, i ) 
+#define Vec_VecForEachEntryIntStart( Type, vGlob, Entry, i, k, LevelStart )                   \
+    for ( i = LevelStart; i < Vec_VecSize(vGlob); i++ )                                       \
+        Vec_IntForEachEntry( Type, (Vec_Int_t *)Vec_VecEntry(vGlob, i), Entry, k ) 
+#define Vec_VecForEachEntryIntStartStop( Type, vGlob, Entry, i, k, LevelStart, LevelStop )    \
+    for ( i = LevelStart; i < LevelStop; i++ )                                                \
+        Vec_IntForEachEntry( Type, (Vec_Int_t *)Vec_VecEntry(vGlob, i), Entry, k ) 
+#define Vec_VecForEachEntryIntReverse( Type, vGlob, Entry, i, k )                             \
+    for ( i = 0; i < Vec_VecSize(vGlob); i++ )                                                \
+        Vec_IntForEachEntryReverse( Type, (Vec_Int_t *)Vec_VecEntry(vGlob, i), Entry, k ) 
+#define Vec_VecForEachEntryIntReverseReverse( Type, vGlob, Entry, i, k )                      \
+    for ( i = Vec_VecSize(vGlob) - 1; i >= 0; i-- )                                           \
+        Vec_IntForEachEntryReverse( Type, (Vec_Int_t *)Vec_VecEntry(vGlob, i), Entry, k ) 
+#define Vec_VecForEachEntryIntReverseStart( Type, vGlob, Entry, i, k, LevelStart )            \
+    for ( i = LevelStart-1; i >= 0; i-- )                                                     \
+        Vec_IntForEachEntry( Type, (Vec_Int_t *)Vec_VecEntry(vGlob, i), Entry, k ) 
+
 ////////////////////////////////////////////////////////////////////////
 ///                     FUNCTION DEFINITIONS                         ///
 ////////////////////////////////////////////////////////////////////////
@@ -158,6 +196,28 @@ static inline void Vec_VecExpand( Vec_Vec_t * p, int Level )
 
 /**Function*************************************************************
 
+  Synopsis    [Allocates a vector with the given capacity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_VecExpandInt( Vec_Vec_t * p, int Level )
+{
+    int i;
+    if ( p->nSize >= Level + 1 )
+        return;
+    Vec_IntGrow( (Vec_Int_t *)p, Level + 1 );
+    for ( i = p->nSize; i <= Level; i++ )
+        p->pArray[i] = Vec_PtrAlloc( 0 );
+    p->nSize = Level + 1;
+}
+
+/**Function*************************************************************
+
   Synopsis    []
 
   Description []
@@ -183,6 +243,22 @@ static inline int Vec_VecSize( Vec_Vec_t * p )
   SeeAlso     []
 
 ***********************************************************************/
+static inline int Vec_VecLevelSize( Vec_Vec_t * p, int i )
+{
+    return Vec_PtrSize( (Vec_Ptr_t *)p->pArray[i] );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
 static inline void * Vec_VecEntry( Vec_Vec_t * p, int i )
 {
     assert( i >= 0 && i < p->nSize );
@@ -239,7 +315,7 @@ static inline void Vec_VecFreeP( Vec_Vec_t ** p )
   SeeAlso     []
 
 ***********************************************************************/
-static inline Vec_Vec_t * Vec_VecDupPtr( Vec_Vec_t * p )
+static inline Vec_Vec_t * Vec_VecDup( Vec_Vec_t * p )
 {
     Vec_Ptr_t * vNew, * vVec;
     int i;
@@ -262,11 +338,12 @@ static inline Vec_Vec_t * Vec_VecDupPtr( Vec_Vec_t * p )
 ***********************************************************************/
 static inline Vec_Vec_t * Vec_VecDupInt( Vec_Vec_t * p )
 {
-    Vec_Ptr_t * vNew, * vVec;
+    Vec_Ptr_t * vNew;
+    Vec_Int_t * vVec;
     int i;
     vNew = Vec_PtrAlloc( Vec_VecSize(p) );
-    Vec_VecForEachLevel( p, vVec, i )
-        Vec_PtrPush( vNew, Vec_IntDup((Vec_Int_t *)vVec) );
+    Vec_VecForEachLevelInt( p, vVec, i )
+        Vec_PtrPush( vNew, Vec_IntDup(vVec) );
     return (Vec_Vec_t *)vNew;
 }
 
@@ -344,6 +421,30 @@ static inline void Vec_VecPush( Vec_Vec_t * p, int Level, void * Entry )
   SeeAlso     []
 
 ***********************************************************************/
+static inline void Vec_VecPushInt( Vec_Vec_t * p, int Level, int Entry )
+{
+    if ( p->nSize < Level + 1 )
+    {
+        int i;
+        Vec_PtrGrow( (Vec_Ptr_t *)p, Level + 1 );
+        for ( i = p->nSize; i < Level + 1; i++ )
+            p->pArray[i] = Vec_PtrAlloc( 0 );
+        p->nSize = Level + 1;
+    }
+    Vec_IntPush( (Vec_Int_t*)p->pArray[Level], Entry );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
 static inline void Vec_VecPushUnique( Vec_Vec_t * p, int Level, void * Entry )
 {
     if ( p->nSize < Level + 1 )
@@ -354,6 +455,25 @@ static inline void Vec_VecPushUnique( Vec_Vec_t * p, int Level, void * Entry )
 
 /**Function*************************************************************
 
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_VecPushUniqueInt( Vec_Vec_t * p, int Level, int Entry )
+{
+    if ( p->nSize < Level + 1 )
+        Vec_VecPushInt( p, Level, Entry );
+    else
+        Vec_IntPushUnique( (Vec_Int_t*)p->pArray[Level], Entry );
+}
+
+/**Function*************************************************************
+
   Synopsis    [Comparison procedure for two arrays.]
 
   Description []