small fixes

Author: giovmanz

.vscode/launch.json

@@ -58,6 +58,35 @@
       "preLaunchTask": "make gdb",
       "miDebuggerPath": "/usr/bin/gdb"
     },
+    {
+      "name": "k2tclosure: make all and debug",
+      "type": "cppdbg",
+      "request": "launch",
+      "program": "${fileDirname}/k2tclosure.x",
+      //"args": [ "-o", "tmp/poli3.2", "-I", "tmp/poli3.ck2.p", "tmp/poli3.ck2"
+      // "args": [ "-o", "web/cnr80k.txt.2", "web/cnr80k.txt.k2"
+      "args": [ "-v", "web/cnr80k.k2"
+      ],
+      "stopAtEntry": true,
+      "cwd": "${fileDirname}",
+      "environment": [],
+      "externalConsole": false,
+      "MIMode": "gdb",
+      "setupCommands": [
+        {
+          "description": "Enable pretty-printing for gdb",
+          "text": "-enable-pretty-printing",
+          "ignoreFailures": true
+        },
+        {
+          "description": "Set Disassembly Flavor to Intel",
+          "text": "-gdb-set disassembly-flavor intel",
+          "ignoreFailures": true
+        }
+      ],
+      "preLaunchTask": "make gdb",
+      "miDebuggerPath": "/usr/bin/gdb"
+    },
     {
       "name": "k2cpdf: make all and debug",
       "type": "cppdbg",

k2ops.c

@@ -93,14 +93,52 @@ static int k2tree_equals_rec(size_t size, const k2mat_t *a, size_t *posa,
       if (roota & (1 << k)) {
         assert(rootb & (1 << k)); 
         int eqr = k2tree_equals_rec(size/2,a,posa,b,posb);
-        if(eqr>0) return eqr+1; // a and b are different at level eqr+1
-        if(eqr < eq) eq = eqr;  // keep track of deepest level reached
+        if(eqr>=0) return eqr+1; // a and b are different at level eqr+1
+        if(eqr < eq) eq = eqr;   // keep track of deepest level reached
       }
     }
     return eq -1; // a: equals to :b, increase depth by one 
   }
 }
 
+// main entry point for matrix equality with limitations, see below:
+// check if size x size k2 compressed matrices :a and :b are equal
+// if a or b have main_diag_1 or backp!=NULL we cannot say: return INT32_MAX
+// if a==b return -d, where d>0 is the number of levels traversed  
+// if a!=b return the level>=0 containing the first difference
+// (first in the sense of the first level encountered in dfs order)
+// Note that if a==b we return the number of visited levels negated, 
+// while if a!=b we return the level of the first difference counting from 0 (root)
+// these two values differ by one: if the tree has 2 level (0 and 1) a difference 
+//   can be at level 1 at most, but the number of traversed levels is 2  
+// :a and :b must be of size at least 2*MMsize but their content can be
+// arbitrary: all 0's, all 1's, or generic 
+// note: here all 0's matrices are considered of depth 1 even if they are empty
+// only the tree strucure is considered, not the main diagonal flag or backpointers
+// TODO: use k2copy_normalize to compare any pair of matrices 
+int mequals(size_t size, const k2mat_t *a, const k2mat_t *b)
+{
+  assert(size>=2*MMsize);
+  assert(a!=NULL && b!=NULL);
+  if(a->main_diag_1 || b->main_diag_1)
+    return INT32_MAX; // cannot say
+  if( (a->backp!=NULL) || (a->backp!=NULL) )  
+    return INT32_MAX; // cannot say
+  if(k2is_empty(a) && k2is_empty(b)) 
+    return -1;                 // if a==0 && b==0: a==b and one level traversed
+  else if(k2is_empty(b))      
+    return 0;                 // if b==0 && a!=0: a!=b and difference at level 0
+  else if(k2is_empty(a))    
+    return 0;                 // if a==0 && b!=0: a!=b as above
+  // a and b are both non-zero, with no backp or main_diag
+  size_t posa=0,posb=0;
+  int eq = k2tree_equals_rec(size,a,&posa,b,&posb);
+  // do extra checks if the matrices are equal
+  assert(eq>=0 || (posa==k2pos(a) && posb==k2pos(b) && (posa==posb) ) );
+  return eq;
+}
+
+
 // return number of levels in the k2_tree storing matrix :a
 // only the tree structure is considered, not the main_diagonal flag or backpointers
 // note: root with no children: 1 level 
@@ -177,42 +215,6 @@ void k2copy_normalise(const k2mat_t *a, k2mat_t *b)
 }
 
 
-// main entry point for matrix equality with limitations, see below:
-// check if size x size k2 compressed matrices :a and :b are equal
-// if a or b have main_diag_1 or backp!=NULL we cannot say: return INT32_MAX
-// if a==b return -d, where d>0 is the number of levels traversed  
-// if a!=b return the level>=0 containing the first difference
-// (first in the sense of the first level encountered in dfs order)
-// Note that if a==b we return the number of visited levels negated, 
-// while if a!=b we return the level of the first difference counting from 0 (root)
-// these two values differ by one: if the tree has 2 level (0 and 1) a difference 
-//   can be at level 1 at most, but the number of traversed levels is 2  
-// :a and :b must be of size at least 2*MMsize but their content can be
-// arbitrary: all 0's, all 1's, or generic 
-// note: here all 0's matrices are considered of depth 1 even if they are empty
-// only the tree strucure is considered, not the main diagonal flag or backpointers
-// TODO: use k2copy_normalize to compare any pair of matrices 
-int mequals(size_t size, const k2mat_t *a, const k2mat_t *b)
-{
-  assert(size>=2*MMsize);
-  assert(a!=NULL && b!=NULL);
-  if(a->main_diag_1 || b->main_diag_1)
-    return INT32_MAX; // cannot say
-  if( (a->backp!=NULL) || (a->backp!=NULL) )  
-    return INT32_MAX; // cannot say
-  if(k2is_empty(a) && k2is_empty(b)) 
-    return -1;                 // if a==0 && b==0: a==b and one level traversed
-  else if(k2is_empty(b))      
-    return 0;                 // if b==0 && a!=0: a!=b and difference at level 0
-  else if(k2is_empty(a))    
-    return 0;                 // if a==0 && b!=0: a!=b as above
-  // a and b are both non-zero, with no backp or main_diag
-  size_t posa=0,posb=0;
-  int eq = k2tree_equals_rec(size,a,&posa,b,&posb);
-  // do extra checks if the matrices are equal
-  assert(eq<0 || (posa==k2pos(a) && posb==k2pos(b) && (posa==posb) ) );
-  return eq;
-}
 
 // add indentity matrix to a
 void madd_identity(k2mat_t *a)

k2tclosure.c

@@ -119,7 +119,7 @@ int main (int argc, char **argv) {
 
   // init matrix variables (valid for b128 and k2tree)
   k2mat_t a=K2MAT_INITIALIZER;
-  k2mat_t b=a,aIa=a;
+  k2mat_t aIa=a;
 
   // load first matrix possibly initializing k2 library
   mload_from_file(&a, iname1);
@@ -156,16 +156,16 @@ int main (int argc, char **argv) {
       assert((p&TSIZEMASK)==a.pos); // low bits contain size of whole matrix 
     #endif  
     if(verbose) mshow_stats(&a,"Current matrix",stdout);
+    k2mat_t b=K2MAT_INITIALIZER;
     mmake_pointer(&a,&b); 
     madd_identity(&b); // b = a + I
     if(verbose) printf("Multiplying (A+I)A\n");
     mmult(&b,&a,&aIa); // aIa = (a+I)a
     if(verbose) printf("Checking if fixed point\n");
     int eq = mequals(a.fullsize, &a,&aIa);
-    printf("mequals: %d\n", eq);
     if(eq <0) break;
     k2mat_t temp = a; a = aIa; aIa = temp; // swap a and aIa for the next iteration
-    matrix_free(&aIa);
+    matrix_free(&aIa);   
   }
   if(verbose) printf("Fixed point reached, stopping\n");
   if(verbose)  mshow_stats(&aIa,"Transitive closure matrix",stdout);