Index: IntegerProgramming/matrix.cc
===================================================================
--- IntegerProgramming/matrix.cc	(revision a7c8b18aaee6ef15b1855f3bbd8d65f0c06f27b6)
+++ IntegerProgramming/matrix.cc	(revision d96b7981b4c023c87dfa9564273e0a6f307b5c78)
@@ -320,5 +320,5 @@
     M[i]=0;
     for(short j=0;j<columns;j++)
-      if(H[i][j]==0)
+      if(H[i][j]==(const BigInt&)0)
         M[i]++;
   }
@@ -348,5 +348,5 @@
   short min_index=-1;
   for(short i=0;i<_kernel_dimension;i++)
-    if(M[i]>0)
+    if(M[i]>(const BigInt&)0)
       if(min_index==-1)
         min_index=i;
@@ -385,5 +385,5 @@
     BOOLEAN found=TRUE;
     for(short j=0;j<columns;j++)
-      if(H[0][j]==0)
+      if(H[0][j]==(const BigInt&)0)
         found=FALSE;
 
@@ -405,9 +405,9 @@
 
     for(short j=0;j<columns;j++)
-      if(H[0][j]==0)
+      if(H[0][j]==(const BigInt&)0)
       {
         remaining_zero_components++;
         for(short i=current_position;i<_kernel_dimension;i++)
-          if(H[i][j]==0)
+          if(H[i][j]==(const BigInt&)0)
             M[i]++;
       }
@@ -421,5 +421,5 @@
         min=M[i];
 
-    if(min==remaining_zero_components)
+    if(min==(const BigInt&)remaining_zero_components)
       // all zero components in H[0] are zero in each remaining vector
       // => desired vector does not exist
@@ -442,5 +442,5 @@
     short min_index=0;
     for(short i=current_position;i<_kernel_dimension;i++)
-      if(M[i]>0)
+      if(M[i]>(const BigInt&)0)
         if(min_index==0)
           min_index=i;
@@ -477,12 +477,12 @@
       // mult*H[current_position]
       for(short j=0;j<columns;j++)
-        if(H[0][j]!=0)
-          if(H[0][j]+mult*H[current_position][j]==0)
+        if(H[0][j]!=(const BigInt&)0)
+          if(H[0][j]+(const BigInt&)mult*H[current_position][j]
+            ==(const BigInt&)0)
             found=FALSE;
 
       if(found==TRUE)
         for(short j=0;j<columns;j++)
-          H[0][j]+=mult*H[current_position][j];
-
+          H[0][j]+=(const BigInt&)mult*H[current_position][j];
       else
         // try -mult
@@ -494,26 +494,20 @@
         // mult*H[current_position]
         for(short j=0;j<columns;j++)
-          if(H[0][j]!=0)
-            if(H[0][j]-mult*H[current_position][j]==0)
+          if(H[0][j]!=(const BigInt&)0)
+            if(H[0][j]-(const BigInt&)mult*H[current_position][j]
+              ==(const BigInt&)0)
               found=FALSE;
 
         if(found==TRUE)
           for(short j=0;j<columns;j++)
-            H[0][j]-=mult*H[current_position][j];
+            H[0][j]-=(const BigInt&)mult*H[current_position][j];
       }
-
     }
-
-  }
-
+  }
 
 // When reaching this line, an error must have occurred.
   cerr<<"FATAL ERROR in short matrix::compute_nonnegative_vector()"<<endl;
   abort();
-
-}
-
-
-
+}
 
 short matrix::compute_flip_variables(short*& F)
@@ -538,5 +532,5 @@
 
   for(short j=0;j<columns;j++)
-    if(H[0][j]<0)
+    if(H[0][j]<(const BigInt&)0)
       r++;
   // remember that all components of H[0] are !=0
@@ -555,5 +549,5 @@
     short counter=0;
     for(short j=0;j<columns;j++)
-      if(H[0][j]>0)
+      if(H[0][j]>(const BigInt&)0)
       {
         F[counter]=j;
@@ -569,5 +563,5 @@
     short counter=0;
     for(short j=0;j<columns;j++)
-      if(H[0][j]<0)
+      if(H[0][j]<(const BigInt&)0)
       {
         F[counter]=j;
@@ -629,8 +623,8 @@
       if(ideal_saturated_by_var[j]==FALSE)
       {
-        if(H[k][j]>0)
+        if(H[k][j]>(const BigInt&)0)
           pos_sat_var++;
         else
-          if(H[k][j]<0)
+          if(H[k][j]<(const BigInt&)0)
             neg_sat_var++;
       }
@@ -643,5 +637,5 @@
       for(short j=0;j<columns;j++)
         if(ideal_saturated_by_var[j]==FALSE)
-          if(H[k][j]>0)
+          if(H[k][j]>(const BigInt&)0)
             // ideal has to be saturated by the variables corresponding
             // to positive components
@@ -652,5 +646,5 @@
           }
           else
-            if(H[k][j]<0)
+            if(H[k][j]<(const BigInt&)0)
               // then the ideal is automatically saturated by the variables
               // corresponding to negative components
@@ -661,5 +655,5 @@
       for(short j=0;j<columns;j++)
         if(ideal_saturated_by_var[j]==FALSE)
-          if(H[k][j]<0)
+          if(H[k][j]<(const BigInt&)0)
             // ideal has to be saturated by the variables corresponding
             // to negative components
@@ -670,5 +664,5 @@
           }
           else
-            if(H[k][j]>0)
+            if(H[k][j]>(const BigInt&)0)
               // then the ideal is automatically saturated by the variables
               // corresponding to positive components
Index: IntegerProgramming/term_ordering.cc
===================================================================
--- IntegerProgramming/term_ordering.cc	(revision a7c8b18aaee6ef15b1855f3bbd8d65f0c06f27b6)
+++ IntegerProgramming/term_ordering.cc	(revision d96b7981b4c023c87dfa9564273e0a6f307b5c78)
@@ -10,5 +10,5 @@
 /////////////// constructors and destructor ///////////////////////////////////
 
-term_ordering::term_ordering(const BOOLEAN& _homogeneous=FALSE)
+term_ordering::term_ordering(const BOOLEAN& _homogeneous)
     :homogeneous(_homogeneous)
 {
@@ -24,5 +24,5 @@
                              const float* weights,
                              const short& _weighted_ordering,
-                             const BOOLEAN& _homogeneous=FALSE)
+                             const BOOLEAN& _homogeneous)
     :weighted_block_size(number_of_weighted_variables),
      homogeneous(_homogeneous)
@@ -86,5 +86,5 @@
                              const short& number_of_elimination_variables,
                              const short& _elimination_ordering,
-                             const BOOLEAN& _homogeneous=FALSE)
+                             const BOOLEAN& _homogeneous)
     :weighted_block_size(number_of_weighted_variables),
      elimination_block_size(number_of_elimination_variables),
@@ -150,5 +150,5 @@
 
 term_ordering::term_ordering(ifstream& input, const short& _weighted_ordering,
-                             const BOOLEAN& _homogeneous=FALSE)
+                             const BOOLEAN& _homogeneous)
     :homogeneous(_homogeneous)
 {
@@ -219,5 +219,5 @@
 term_ordering::term_ordering(const short& n, ifstream& input,
                              const short& _weighted_ordering,
-                             const BOOLEAN& _homogeneous=FALSE)
+                             const BOOLEAN& _homogeneous)
     :homogeneous(_homogeneous)
 {
@@ -260,5 +260,5 @@
         cout << "neg found at i="<<i<<":" <<weight_vector[i] <<"\n";
         negative_weight=TRUE;
-      }	
+      }
       if(weight_vector[i]==0)
         zero_weight=TRUE;
