Changeset 194c2e7 in git for IntegerProgramming

Timestamp:

Feb 9, 2010, 6:50:36 PM (14 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

6c939eebfd221f2512b1e27d158d1b5457206987

Parents:

a477f80136c773f8acffd73512f53bf88a7c6fe8

Message:

short -> int

git-svn-id: file:///usr/local/Singular/svn/trunk@12539 2c84dea3-7e68-4137-9b89-c4e89433aadc

Location:

IntegerProgramming

Files:

• Buchberger.cc (modified) (56 diffs)
• IP_algorithms.cc (modified) (39 diffs)
• IP_algorithms.h (modified) (8 diffs)
• globals.h (modified) (1 diff)
• ideal.cc (modified) (40 diffs)
• ideal.h (modified) (10 diffs)
• ideal_stuff.cc (modified) (10 diffs)
• matrix.cc (modified) (51 diffs)
• matrix.h (modified) (8 diffs)
• solve_IP.cc (modified) (3 diffs)

IntegerProgramming/Buchberger.cc

@@ -63 +63 @@
     // we reach this element.
 
-    short supp2=bin2.head_support%Number_of_Lists;
-    short supp_union=(bin1.head_support%Number_of_Lists)|supp2;
+    int supp2=bin2.head_support%Number_of_Lists;
+    int supp_union=(bin1.head_support%Number_of_Lists)|supp2;
     // supp_union (read as binary vector) is the union of the supports of
     // first_iter.get_element() and second_iter.get_element()
     // (restricted to List_Support_Variables variables).
 
-    for(short i=0;i<S.number_of_subsets[supp_union];i++)
+    for(int i=0;i<S.number_of_subsets[supp_union];i++)
       // Go through the lists that contain elements whose support is a
       // subset of supp_union.
     {
-      short actual_list=S.subsets_of_support[supp_union][i];
+      int actual_list=S.subsets_of_support[supp_union][i];
       iter.set_to_list(generators[actual_list]);
       // This is the i-th list among the generator list with elements
@@ -136 +136 @@
     // Additionally,we can override lists whose support is to small.
 
-    short supp1=bin1.head_support%Number_of_Lists;
-    short supp2=bin2.head_support%Number_of_Lists;
-    short supp_union=supp1|supp2;
+    int supp1=bin1.head_support%Number_of_Lists;
+    int supp2=bin2.head_support%Number_of_Lists;
+    int supp_union=supp1|supp2;
     // supp_union (read as binary vector) is the union of the supports of
     // first_iter.get_element() and second_iter.get_element()
     // (restricted to List_Support_Variables variables).
 
-    for(short i=0;i<S.number_of_subsets[supp_union];i++)
+    for(int i=0;i<S.number_of_subsets[supp_union];i++)
       // Go through the lists that contain elements whose support is a
       // subset of supp_union.
     {
-      short actual_list=S.subsets_of_support[supp_union][i];
+      int actual_list=S.subsets_of_support[supp_union][i];
 
       if((actual_list|supp2) != supp_union)
@@ -221 +221 @@
     // (second_iter.get_element()).head_support.
 
-    short supp2=bin2.head_support%Number_of_Lists;
-    short supp_union=(bin1.head_support%Number_of_Lists)|supp2;
+    int supp2=bin2.head_support%Number_of_Lists;
+    int supp_union=(bin1.head_support%Number_of_Lists)|supp2;
     // supp_union (read as binary vector) is the union of the supports of
     // first_iter.get_element() and second_iter.get_element()
@@ -231 +231 @@
       // subset of supp_union.
     {
-      short actual_list=S.subsets_of_support[supp_union][i];
+      int actual_list=S.subsets_of_support[supp_union][i];
 
       if(actual_list<=supp2)
@@ -291 +291 @@
     // and (second_iter.get_element()).head_support.
 
-    short supp1=bin1.head_support%Number_of_Lists;
-    short supp2=bin2.head_support%Number_of_Lists;
-    short supp_union=supp1|supp2;
+    int supp1=bin1.head_support%Number_of_Lists;
+    int supp2=bin2.head_support%Number_of_Lists;
+    int supp_union=supp1|supp2;
     // supp_union (read as binary vector) is the union of the supports of
     // first_iter.get_element() and second_iter.get_element()
     // (restricted to List_Support_Variables variables)
 
-    for(short i=0;i<S.number_of_subsets[supp_union];i++)
+    for(int i=0;i<S.number_of_subsets[supp_union];i++)
       // Go through the lists that contain elements whose support is a
       // subset of supp_union.
     {
-      short actual_list=S.subsets_of_support[supp_union][i];
+      int actual_list=S.subsets_of_support[supp_union][i];
 
       if((actual_list==supp1) || (actual_list==supp2))
@@ -434 +434 @@
   list_iterator first_iter;
 
-  for(short i=0;i<Number_of_Lists;i++)
+  for(int i=0;i<Number_of_Lists;i++)
   {
     first_iter.set_to_list(generators[i]);
@@ -460 +460 @@
       // Then search over the remaining lists.
 
-      for(short j=i+1;j<Number_of_Lists;j++)
+      for(int j=i+1;j<Number_of_Lists;j++)
       {
         second_iter.set_to_list(generators[j]);
@@ -485 +485 @@
       list_iterator second_iter;
 
-      for(short j=i+1;j<Number_of_Lists;j++)
+      for(int j=i+1;j<Number_of_Lists;j++)
         // search over remaining lists
       {
@@ -548 +548 @@
   list_iterator first_iter;
 
-  for(short i=0;i<Number_of_Lists;i++)
+  for(int i=0;i<Number_of_Lists;i++)
   {
     first_iter.set_to_list(generators[i]);
@@ -575 +575 @@
       // Then search over the remaining lists.
 
-      for(short j=i+1;j<Number_of_Lists;j++)
+      for(int j=i+1;j<Number_of_Lists;j++)
       {
         second_iter.set_to_list(generators[j]);
@@ -601 +601 @@
       list_iterator second_iter;
 
-      for(short j=i+1;j<Number_of_Lists;j++)
+      for(int j=i+1;j<Number_of_Lists;j++)
         // search over remaining lists
       {
@@ -731 +731 @@
 
 
-  for(short i=0;i<Number_of_Lists;i++)
+  for(int i=0;i<Number_of_Lists;i++)
   {
     first_iter.set_to_list(generators[i]);
@@ -784 +784 @@
       // Then search over the remaining lists.
 
-      for(short j=i+1;(j<Number_of_Lists) && (first_reduced<=0);j++)
+      for(int j=i+1;(j<Number_of_Lists) && (first_reduced<=0);j++)
       {
         second_iter.set_to_list(generators[j]);
@@ -841 +841 @@
       second_iter.next();
 
-     for(short j=i+1;(j<Number_of_Lists) && (first_reduced<=0);j++)
+     for(int j=i+1;(j<Number_of_Lists) && (first_reduced<=0);j++)
       {
         second_iter.set_to_list(generators[j]);
@@ -995 +995 @@
 
 
-  for(short i=0;i<Number_of_Lists;i++)
+  for(int i=0;i<Number_of_Lists;i++)
   {
     first_iter.set_to_list(generators[i]);
@@ -1048 +1048 @@
       // Then search over the remaining lists.
 
-      for(short j=i+1;(j<Number_of_Lists) && (first_reduced<=0);j++)
+      for(int j=i+1;(j<Number_of_Lists) && (first_reduced<=0);j++)
       {
         second_iter.set_to_list(generators[j]);
@@ -1105 +1105 @@
       second_iter.next();
 
-     for(short j=i+1;(j<Number_of_Lists) && (first_reduced<=0);j++)
+     for(int j=i+1;(j<Number_of_Lists) && (first_reduced<=0);j++)
       {
         second_iter.set_to_list(generators[j]);
@@ -1258 +1258 @@
 #ifdef SUPPORT_DRIVEN_METHODS_EXTENDED
 
-  short supp1=(first_iter.get_element()).head_support%Number_of_Lists;
-  short supp2=(second_iter.get_element()).head_support%Number_of_Lists;
+  int supp1=(first_iter.get_element()).head_support%Number_of_Lists;
+  int supp2=(second_iter.get_element()).head_support%Number_of_Lists;
 
   // Determine the lists over which we have to iterate.
@@ -1270 +1270 @@
   // With this formulation, we can use the subset tree as follows:
 
-  short supp=bin.head_support%Number_of_Lists;
-  short inv_supp=Number_of_Lists-supp-1;
+  int supp=bin.head_support%Number_of_Lists;
+  int inv_supp=Number_of_Lists-supp-1;
   // This bit vector is the bitwise inverse of bin.head_support (restricted
   // to the variables considered in the list indices.
@@ -1279 +1279 @@
 
 
-  for(short i=0;i<S.number_of_subsets[inv_supp];i++)
-  {
-    short actual_list=Number_of_Lists-S.subsets_of_support[inv_supp][i]-1;
+  for(int i=0;i<S.number_of_subsets[inv_supp];i++)
+  {
+    int actual_list=Number_of_Lists-S.subsets_of_support[inv_supp][i]-1;
     // the actual list for iteration
     // The support of S.subsets_of_support[inv_supp][i] as a bit vector
@@ -1483 +1483 @@
 
   list_iterator first_iter;
-  short found;
+  int found;
   // to control if a reduction has occurred during the actual iteration
 
@@ -1497 +1497 @@
 
       binomial& bin1=first_iter.get_element();
-      short first_changed=0;
+      int first_changed=0;
       // to control if the first element has been reduced
 
@@ -1508 +1508 @@
       {
         binomial& bin2=second_iter.get_element();
-        short second_changed=0;
+        int second_changed=0;
 
         if(bin1.reduce_head_by(bin2,w)!=0)
@@ -1600 +1600 @@
 
   list_iterator first_iter;
-  short found;
+  int found;
   // to control if a reduction has occurred during the actual iteration
 
@@ -1614 +1614 @@
     {
       binomial& bin1=first_iter.get_element();
-      short first_changed=0;
+      int first_changed=0;
       // to control if the first element has been reduced
 
@@ -1754 +1754 @@
   list_iterator first_iter;
   list_iterator second_iter;
-  short found;
+  int found;
   // to control if a reduction has occurred during the actual iteration
 
@@ -1762 +1762 @@
     // no reduction occurred yet
 
-    for(short i=0;i<Number_of_Lists;i++)
+    for(int i=0;i<Number_of_Lists;i++)
     {
       first_iter.set_to_list(new_generators[i]);
@@ -1782 +1782 @@
 // two iterators reference different lists.
 
-        for(short j=0;(j<S.number_of_subsets[i]-1)&&(changed==0);j++)
+        for(int j=0;(j<S.number_of_subsets[i]-1)&&(changed==0);j++)
         {
           second_iter.set_to_list(new_generators[S.subsets_of_support[i][j]]);
@@ -1880 +1880 @@
 // two iterators reference different lists.
 
-        for(short j=0;(j<S.number_of_subsets[i]-1)&&(changed==0);j++)
+        for(int j=0;(j<S.number_of_subsets[i]-1)&&(changed==0);j++)
         {
           second_iter.set_to_list(new_generators[S.subsets_of_support[i][j]]);
@@ -2050 +2050 @@
 
   list_iterator first_iter;
-  short found;
+  int found;
   // to control if a reduction has occurred during the actual iteration
 
@@ -2064 +2064 @@
     {
       binomial& bin1=first_iter.get_element();
-      short first_changed=0;
+      int first_changed=0;
       // to control if the first element has been reduced
 
@@ -2227 +2227 @@
   list_iterator first_iter;
   list_iterator second_iter;
-  short found;
+  int found;
   // to control if a reduction has occurred during the actual iteration
 
@@ -2235 +2235 @@
     // no reduction occurred yet
 
-    for(short i=0;i<Number_of_Lists;i++)
+    for(int i=0;i<Number_of_Lists;i++)
     {
       first_iter.set_to_list(generators[i]);
@@ -2255 +2255 @@
 // two iterators reference different lists.
 
-        for(short j=0;(j<S.number_of_subsets[i]-1)&&(changed==0);j++)
+        for(int j=0;(j<S.number_of_subsets[i]-1)&&(changed==0);j++)
         {
           second_iter.set_to_list(generators[S.subsets_of_support[i][j]]);
@@ -2357 +2357 @@
 // two iterators reference different lists.
 
-        for(short j=0;(j<S.number_of_subsets[i]-1)&&(changed==0);j++)
+        for(int j=0;(j<S.number_of_subsets[i]-1)&&(changed==0);j++)
         {
           second_iter.set_to_list(generators[S.subsets_of_support[i][j]]);
@@ -2560 +2560 @@
   {
     binomial& bin=first_iter.get_element();
-    short changed;
+    int changed;
     // to control if bin has been reduced
 
@@ -2594 +2594 @@
   list_iterator first_iter;
 
-  for(short i=0;i<Number_of_Lists;i++)
+  for(int i=0;i<Number_of_Lists;i++)
   {
     first_iter.set_to_list(generators[i]);
@@ -2601 +2601 @@
     {
       binomial& bin=first_iter.get_element();
-      short changed;
+      int changed;
       // to control if bin has been reduced
 
@@ -2609 +2609 @@
         list_iterator second_iter;
 
-        short supp=bin.tail_support%Number_of_Lists;
+        int supp=bin.tail_support%Number_of_Lists;
         // determine the lists over which we have to iterate
 
-        for(short j=0;(j<S.number_of_subsets[supp]) && (changed==0);j++)
+        for(int j=0;(j<S.number_of_subsets[supp]) && (changed==0);j++)
         {
           second_iter.set_to_list(generators[S.subsets_of_support[supp][j]]);
@@ -2652 +2652 @@
 
 
-short ideal::add_new_generators()
+int ideal::add_new_generators()
 {
 // Reduces the binomials in the "new_generators" list(s) by the generators
@@ -2660 +2660 @@
 #ifdef NO_SUPPORT_DRIVEN_METHODS_EXTENDED
 
-  short result=0;
+  int result=0;
   // element inserted?
 
@@ -2686 +2686 @@
 #ifdef SUPPORT_DRIVEN_METHODS_EXTENDED
 
-  short result=0;
+  int result=0;
   // element inserted?
 
   list_iterator iter;
 
-  for(short i=0;i<Number_of_Lists;i++)
+  for(int i=0;i<Number_of_Lists;i++)
   {
     iter.set_to_list(new_generators[i]);
@@ -2785 +2785 @@
     // not yet reduced
 
-    short supp=bin.head_support%Number_of_Lists;
+    int supp=bin.head_support%Number_of_Lists;
     // determine the lists over which we have to iterate
 
@@ -2792 +2792 @@
     // that cannot contain reducers any more.
 
-    for(short i=0;(i<S.number_of_subsets[supp]) && (reduced==0);i++)
+    for(int i=0;(i<S.number_of_subsets[supp]) && (reduced==0);i++)
     {
       iter.set_to_list(generators[S.subsets_of_support[supp][i]]);
@@ -2816 +2816 @@
       // not yet reduced
 
-      short supp=bin.tail_support%Number_of_Lists;
+      int supp=bin.tail_support%Number_of_Lists;
       // determine the lists over which we have to iterate
 
@@ -2823 +2823 @@
       // lists that cannot contain reducers any more.
 
-      for(short i=0;(i<S.number_of_subsets[supp]) && (reduced==0);i++)
+      for(int i=0;(i<S.number_of_subsets[supp]) && (reduced==0);i++)
       {
         iter.set_to_list(generators[S.subsets_of_support[supp][i]]);
@@ -2859 +2859 @@
 
 
-ideal& ideal::reduced_Groebner_basis_1(const short& S_pair_criteria,
+ideal& ideal::reduced_Groebner_basis_1(const int& S_pair_criteria,
                                        const float& interred_percentage)
 {
@@ -2872 +2872 @@
   interreduction_percentage=interred_percentage;
 
-  short done;
+  int done;
   // control variable for recognizing when Buchberger's algorithm has reached
   // his end
@@ -2940 +2940 @@
 
 
-ideal& ideal::reduced_Groebner_basis_1a(const short& S_pair_criteria,
+ideal& ideal::reduced_Groebner_basis_1a(const int& S_pair_criteria,
                                         const float& interred_percentage)
 {
@@ -2953 +2953 @@
   interreduction_percentage=interred_percentage;
 
-  short done;
+  int done;
   // control variable for recognizing when Buchberger's algorithm has reached
   // his end
@@ -3021 +3021 @@
 
 
-ideal& ideal::reduced_Groebner_basis_2(const short& S_pair_criteria,
+ideal& ideal::reduced_Groebner_basis_2(const int& S_pair_criteria,
                                        const float& interred_percentage)
 {
@@ -3034 +3034 @@
   interreduction_percentage=interred_percentage;
 
-  short done;
+  int done;
   // control variable for recognizing when Buchberger's algorithm has reached
   // his end
@@ -3102 +3102 @@
 
 
-ideal& ideal::reduced_Groebner_basis_3(const short& S_pair_criteria,
+ideal& ideal::reduced_Groebner_basis_3(const int& S_pair_criteria,
                                        const float& interred_percentage)
 {
@@ -3115 +3115 @@
   interreduction_percentage=interred_percentage;
 
-  short not_done;
+  int not_done;
   // control variable for recognizing when Buchberger's algorithm has reached
   // his end
@@ -3168 +3168 @@
 
 
-ideal& ideal::reduced_Groebner_basis(const short& version,
-                                     const short& S_pair_criteria,
+ideal& ideal::reduced_Groebner_basis(const int& version,
+                                     const int& S_pair_criteria,
                                      const float& interred_percentage)
 {
@@ -3183 +3183 @@
         return reduced_Groebner_basis_3(S_pair_criteria, interred_percentage);
       default:
-        cerr<<"WARNING: ideal& ideal::reduced_Groebner_basis(const short&, "
-          "const short&, const float&):\n"
+        cerr<<"WARNING: ideal& ideal::reduced_Groebner_basis(const int&, "
+          "const int&, const float&):\n"
           "version argument out of range, nothing done"<<endl;
         return*this;

IntegerProgramming/IP_algorithms.cc

@@ -61 +61 @@
 
 int Conti_Traverso(INPUT_FILE MATRIX,
-                   const short& version,
-                   const short& S_pair_criteria,
+                   const int& version,
+                   const int& S_pair_criteria,
                    const float& interred_percentage,
                    const BOOLEAN& verbose)
@@ -71 +71 @@
 
   char format_string[128]; // to verifie file format
-  short constraints;       // number of equality constraints
-  short variables;         // number of variables (without auxiliary variables)
+  int constraints;       // number of equality constraints
+  int variables;         // number of variables (without auxiliary variables)
 
   ifstream input(MATRIX);
@@ -265 +265 @@
 
   char GROEBNER[128];
-  short i=0;
+  int i=0;
   while(MATRIX[i]!='\0' && MATRIX[i]!='.')
   {
@@ -349 +349 @@
 
 int Positive_Conti_Traverso(INPUT_FILE MATRIX,
-                            const short& version,
-                            const short& S_pair_criteria,
+                            const int& version,
+                            const int& S_pair_criteria,
                             const float& interred_percentage,
                             const BOOLEAN& verbose)
@@ -359 +359 @@
 
   char format_string[128]; // to verifie file format
-  short constraints;       // number of equality constraints
-  short variables;         // number of variables (without auxiliary variables)
+  int constraints;       // number of equality constraints
+  int variables;         // number of variables (without auxiliary variables)
 
   ifstream input(MATRIX);
@@ -561 +561 @@
 
   char GROEBNER[128];
-  short i=0;
+  int i=0;
   while(MATRIX[i]!='\0' && MATRIX[i]!='.')
   {
@@ -646 +646 @@
 
 int Elim_Conti_Traverso(INPUT_FILE MATRIX,
-                        const short& version,
-                        const short& S_pair_criteria,
+                        const int& version,
+                        const int& S_pair_criteria,
                         const float& interred_percentage,
                         const BOOLEAN& verbose)
@@ -656 +656 @@
 
   char format_string[128]; // to verifie file format
-  short constraints;       // number of equality constraints
-  short variables;         // number of variables (without auxiliary variables)
+  int constraints;       // number of equality constraints
+  int variables;         // number of variables (without auxiliary variables)
 
   ifstream input(MATRIX);
@@ -852 +852 @@
 
   char GROEBNER[128];
-  short i=0;
+  int i=0;
   while(MATRIX[i]!='\0' && MATRIX[i]!='.')
   {
@@ -935 +935 @@
 
 int Pottier(INPUT_FILE MATRIX,
-            const short& version,
-            const short& S_pair_criteria,
+            const int& version,
+            const int& S_pair_criteria,
             const float& interred_percentage,
             const BOOLEAN& verbose)
@@ -945 +945 @@
 
   char format_string[128]; // to verifie file format
-  short constraints;       // number of equality constraints
-  short variables;         // number of variables (without auxiliary variables)
+  int constraints;       // number of equality constraints
+  int variables;         // number of variables (without auxiliary variables)
 
   ifstream input(MATRIX);
@@ -1140 +1140 @@
 
   char GROEBNER[128];
-  short i=0;
+  int i=0;
   while(MATRIX[i]!='\0' && MATRIX[i]!='.')
   {
@@ -1223 +1223 @@
 
 int Hosten_Sturmfels(INPUT_FILE MATRIX,
-                     const short& version,
-                     const short& S_pair_criteria,
+                     const int& version,
+                     const int& S_pair_criteria,
                      const float& interred_percentage,
                      const BOOLEAN& verbose)
@@ -1233 +1233 @@
 
   char format_string[128]; // to verifie file format
-  short constraints;       // number of equality constraints
-  short variables;         // number of variables
+  int constraints;       // number of equality constraints
+  int variables;         // number of variables
 
   ifstream input(MATRIX);
@@ -1465 +1465 @@
   float *hom_grad=new float[variables];
 
-  for(short i=0;i<variables;i++)
+  for(int i=0;i<variables;i++)
   {
     input>>hom_grad[i];
@@ -1506 +1506 @@
 
   // determine saturation variables
-  short *sat_var;
-  short number_of_sat_var=A.hosten_shapiro(sat_var);
+  int *sat_var;
+  int number_of_sat_var=A.hosten_shapiro(sat_var);
   // memory for sat_var is allocated in the hosten_shapiro procedure
 
   // saturate the ideal
-  for(short i=0;i<number_of_sat_var;i++)
+  for(int i=0;i<number_of_sat_var;i++)
   {
     I.swap_variables(sat_var[i],variables-1);
@@ -1551 +1551 @@
 
   char GROEBNER[128];
-  short i=0;
+  int i=0;
   while(MATRIX[i]!='\0' && MATRIX[i]!='.')
   {
@@ -1634 +1634 @@
 
 int DiBiase_Urbanke(INPUT_FILE MATRIX,
-                    const short& version,
-                    const short& S_pair_criteria,
+                    const int& version,
+                    const int& S_pair_criteria,
                     const float& interred_percentage,
                     const BOOLEAN& verbose)
@@ -1644 +1644 @@
 
   char format_string[128]; // to verify file format
-  short constraints;       // number of equality constraints
-  short variables;         // number of variables
+  int constraints;       // number of equality constraints
+  int variables;         // number of variables
 
   ifstream input(MATRIX);
@@ -1822 +1822 @@
 
   // compute flip variables (also to check the suitability of the algorithm)
-  short* F;
-  short r=A.compute_flip_variables(F);
+  int* F;
+  int r=A.compute_flip_variables(F);
 
   if(r<0)
@@ -1862 +1862 @@
 
     float* weights=new float[variables];
-    for(short j=0;j<variables;j++)
+    for(int j=0;j<variables;j++)
       weights[j]=0;
     weights[F[0]]=1;
@@ -1880 +1880 @@
     // But the following change of the term ordering will correct this.
 
-    for(short l=1;l<r;l++)
+    for(int l=1;l<r;l++)
     {
       w.swap_weights(F[l-1],F[l]);
@@ -1910 +1910 @@
 
   char GROEBNER[128];
-  short i=0;
+  int i=0;
   while(MATRIX[i]!='\0' && MATRIX[i]!='.')
   {
@@ -2000 +2000 @@
 
 int Bigatti_LaScala_Robbiano(INPUT_FILE MATRIX,
-                             const short& version,
-                             const short& S_pair_criteria,
+                             const int& version,
+                             const int& S_pair_criteria,
                              const float& interred_percentage,
                              const BOOLEAN& verbose)
@@ -2010 +2010 @@
 
   char format_string[128];     // to verifie file format
-  short constraints;       // number of equality constraints
-  short variables;         // number of variables
+  int constraints;       // number of equality constraints
+  int variables;         // number of variables
 
   ifstream input(MATRIX);
@@ -2253 +2253 @@
   float *hom_grad=new float[variables];
   
-  for(short _i=0;_i<variables;_i++)
+  for(int _i=0;_i<variables;_i++)
   {
     input>>hom_grad[_i];
@@ -2324 +2324 @@
 
   char GROEBNER[128];
-  short i=0;
+  int i=0;
   while(MATRIX[i]!='\0' && MATRIX[i]!='.')
   {
@@ -2410 +2410 @@
 
   char format_string[128];
-  short problem_variables;
-  short elimination_variables;
-  short weighted_variables;
+  int problem_variables;
+  int elimination_variables;
+  int weighted_variables;
   char elimination_refinement[128];
   char weighted_refinement[128];
@@ -2683 +2683 @@
   }
 
-  short weighted_ref;
+  int weighted_ref;
   if(!strcmp(weighted_refinement,"W_LEX"))
     weighted_ref=W_LEX;
@@ -2712 +2712 @@
   if(elimination_variables>0)
   {
-    short elimination_ref;
+    int elimination_ref;
     if(!strcmp(elimination_refinement,"LEX"))
       elimination_ref=LEX;
@@ -3037 +3037 @@
   char SOLUTION[128];
 
-  short i=0;
+  int i=0;
   while(GROEBNER[i]!='\0' && GROEBNER[i]!='.')
   {
@@ -3083 +3083 @@
     Integer right_hand[weighted_variables+elimination_variables];
 
-    for(short k=0;k<instances;k++)
+    for(int k=0;k<instances;k++)
     {
       // at the beginning, the variables of interest are zero
@@ -3190 +3190 @@
       BOOLEAN error=FALSE;    // to test legality of right hand vectors
 
-      for(short k=0;k<instances;k++)
+      for(int k=0;k<instances;k++)
       {
         // at the beginning, the variables of interest are zero
@@ -3295 +3295 @@
       Integer initial_solution[weighted_variables];
 
-      for(short k=0;k<instances;k++)
+      for(int k=0;k<instances;k++)
       {
         // initial solution vector is read from the input stream into the
@@ -3363 +3363 @@
 
 int change_cost(INPUT_FILE GROEBNER, INPUT_FILE NEW_COST,
-                const short& version,
-                const short& S_pair_criteria,
+                const int& version,
+                const int& S_pair_criteria,
                 const float& interred_percentage,
                 const BOOLEAN& verbose)
@@ -3370 +3370 @@
 
   char format_string[128];
-  short elimination_variables;
-  short weighted_variables;
+  int elimination_variables;
+  int weighted_variables;
   char elimination_refinement[128];
   char weighted_refinement[128];
-  short new_variables;
+  int new_variables;
   char algorithm[128];
   long old_size;
@@ -3758 +3758 @@
   // the term ordering to refine the weight is taken to be the same as that
   // for the old Groebner basis
-  short weighted_ref;
+  int weighted_ref;
   if(!strcmp(weighted_refinement,"W_LEX"))
     weighted_ref=W_LEX;
@@ -3787 +3787 @@
   if(elimination_variables>0)
   {
-    short elimination_ref;
+    int elimination_ref;
     if(!strcmp(elimination_refinement,"LEX"))
       elimination_ref=LEX;
@@ -3914 +3914 @@
   char NEW_GROEBNER[128];
 
-  short i=0;
+  int i=0;
   while(NEW_COST[i]!='\0' && NEW_COST[i]!='.')
   {

IntegerProgramming/IP_algorithms.h

@@ -49 +49 @@
 
 extern int Conti_Traverso(INPUT_FILE MATRIX,
-                          const short& version=1,
-                          const short& S_pair_criteria=11,
+                          const int& version=1,
+                          const int& S_pair_criteria=11,
                           const float& interred_percentage=12.0,
                           const BOOLEAN& verbose=FALSE);
@@ -58 +58 @@
 
 extern int Positive_Conti_Traverso(INPUT_FILE MATRIX,
-                                   const short& version=1,
-                                   const short& S_pair_criteria=11,
+                                   const int& version=1,
+                                   const int& S_pair_criteria=11,
                                    const float& interred_percentage=12.0,
                                    const BOOLEAN& verbose=FALSE);
@@ -66 +66 @@
 
 extern int Elim_Conti_Traverso(INPUT_FILE MATRIX,
-                               const short& version=1,
-                               const short& S_pair_criteria=11,
+                               const int& version=1,
+                               const int& S_pair_criteria=11,
                                const float& interred_percentage=12.0,
                                const BOOLEAN& verbose=FALSE);
@@ -75 +75 @@
 
 extern int Pottier(INPUT_FILE MATRIX,
-                   const short& version=1,
-                   const short& S_pair_criteria=11,
+                   const int& version=1,
+                   const int& S_pair_criteria=11,
                    const float& interred_percentage=12.0,
                    const BOOLEAN& verbose=FALSE);
@@ -83 +83 @@
 
 extern int Hosten_Sturmfels(INPUT_FILE MATRIX,
-                            const short& version=1,
-                            const short& S_pair_criteria=11,
+                            const int& version=1,
+                            const int& S_pair_criteria=11,
                             const float& interred_percentage=12.0,
                             const BOOLEAN& verbose=FALSE);
@@ -92 +92 @@
 
 extern int DiBiase_Urbanke(INPUT_FILE MATRIX,
-                           const short& version=1,
-                           const short& S_pair_criteria=11,
+                           const int& version=1,
+                           const int& S_pair_criteria=11,
                            const float& interred_percentage=12.0,
                            const BOOLEAN& verbose=FALSE);
@@ -100 +100 @@
 
 extern int Bigatti_LaScala_Robbiano(INPUT_FILE MATRIX,
-                                    const short& version=1,
-                                    const short& S_pair_criteria=11,
+                                    const int& version=1,
+                                    const int& S_pair_criteria=11,
                                     const float& interred_percentage=12.0,
                                     const BOOLEAN& verbose=FALSE);
@@ -128 +128 @@
 
 extern int change_cost(INPUT_FILE GROEBNER, INPUT_FILE NEW_COST,
-                       const short& version=1,
-                       const short& S_pair_criteria=11,
+                       const int& version=1,
+                       const int& S_pair_criteria=11,
                        const float& interred_percentage=12.0,
                        const BOOLEAN& verbose=FALSE);

IntegerProgramming/globals.h

@@ -60 +60 @@
 // The general data type to deal with can be short, long or int...
 
-#define _SHORT_
+//#define _SHORT_
 // For an overflow control for thE result of the LLL algorithm, we have to
 // know the data type used.

IntegerProgramming/ideal.cc

@@ -19 +19 @@
 void ideal::create_subset_tree()
 {
-  for(short i=0;i<Number_of_Lists;i++)
+  for(int i=0;i<Number_of_Lists;i++)
   {
 
@@ -27 +27 @@
 // bits in i that are 1. Hence the desired number is 2^s.
 
-    short s=0;
-
-    for(short k=0;k<List_Support_Variables;k++)
+    int s=0;
+
+    for(int k=0;k<List_Support_Variables;k++)
       if( (i&(1<<k)) == (1<<k) )
         // bit k of i is 1
@@ -43 +43 @@
 // in this function.)
 
-    S.subsets_of_support[i]=new short[S.number_of_subsets[i]];
+    S.subsets_of_support[i]=new int[S.number_of_subsets[i]];
     // memory allocation for subsets_of_support[i]
 
-    short index=0;
-    for(short j=0;j<Number_of_Lists;j++)
+    int index=0;
+    for(int j=0;j<Number_of_Lists;j++)
       if((i&j)==j)
         // If the support of j as a bit vector is contained in the support of
@@ -60 +60 @@
 void ideal::destroy_subset_tree()
 {
-  for(short i=0;i<Number_of_Lists;i++)
+  for(int i=0;i<Number_of_Lists;i++)
     delete[] S.subsets_of_support[i];
-  // The arrays number_of_subsets and subsets_of_support (the (short*)-array)
+  // The arrays number_of_subsets and subsets_of_support (the (int*)-array)
   // are not dynamically allocated and do not have to be deleted.
 }
@@ -134 +134 @@
 
   // build initial ideal generators
-  for(short j=0;j<A.columns;j++)
-  {
-    for(short k=0;k<A.columns;k++)
+  for(int j=0;j<A.columns;j++)
+  {
+    for(int k=0;k<A.columns;k++)
       // original variables
       if(j==k)
@@ -143 +143 @@
         generator[k]=0;
 
-    for(short i=0;i<A.rows;i++)
+    for(int i=0;i<A.rows;i++)
       // elimination variables
       generator[A.columns+i]=A.coefficients[i][j];
@@ -159 +159 @@
 
   // now add the "inversion generator"
-  for(short j=0;j<A.columns;j++)
+  for(int j=0;j<A.columns;j++)
     generator[j]=0;
-  for(short i=0;i<A.rows+1;i++)
+  for(int i=0;i<A.rows+1;i++)
     generator[A.columns+i]=1;
   binomial* bin=new binomial(A.rows+1+A.columns,generator,w);
@@ -188 +188 @@
 
   // build the initial ideal generators
-  for(short j=0;j<A.columns;j++)
-  {
-    for(short k=0;k<A.columns;k++)
+  for(int j=0;j<A.columns;j++)
+  {
+    for(int k=0;k<A.columns;k++)
       // original variables
       if(j==k)
@@ -197 +197 @@
         generator[k]=0;
 
-    for(short i=0;i<A.rows;i++)
+    for(int i=0;i<A.rows;i++)
       // elimination variables
       generator[A.columns+i]=A.coefficients[i][j];
@@ -239 +239 @@
 
   // compute initial generating system from the kernel of A
-  for(short j=0;j<A._kernel_dimension;j++)
-  {
-
-    for(short k=0;k<A.columns;k++)
+  for(int j=0;j<A._kernel_dimension;j++)
+  {
+
+    for(int k=0;k<A.columns;k++)
     {
 
@@ -257 +257 @@
           "term_ordering&):\n"
           "LLL-reduced kernel basis does not fit into the used "
-          "basic data type short."<<endl;
+          "basic data type int."<<endl;
         size=-3;
         delete[] generator;
@@ -315 +315 @@
   // of the computed saturation generator is smaller if less variables are
   // involved.
-  short* sat_var = NULL;  
-  short number_of_sat_var = A.hosten_shapiro(sat_var);
+  int* sat_var = NULL;  
+  int number_of_sat_var = A.hosten_shapiro(sat_var);
   if( (number_of_sat_var == 0) || (sat_var == NULL) )
   {
@@ -323 +323 @@
   }
 
-  for(short j=0;j<A.columns;j++)
+  for(int j=0;j<A.columns;j++)
     generator[j]=0;
 
-  for(short k=0;k<number_of_sat_var;k++)
+  for(int k=0;k<number_of_sat_var;k++)
     generator[sat_var[k]]=1;
 
@@ -373 +373 @@
 
   // compute initial generating system from the kernel of A
-  for(short j=0;j<A._kernel_dimension;j++)
-  {
-
-    for(short k=0;k<A.columns;k++)
+  for(int j=0;j<A._kernel_dimension;j++)
+  {
+
+    for(int k=0;k<A.columns;k++)
     {
 
@@ -390 +390 @@
         cerr<<"\nWARNING: ideal& ideal::Hosten_Sturmfels_ideal(matrix&, const "
           "term_ordering&):\nLLL-reduced kernel basis does not fit "
-          "into the used basic data type short."<<endl;
+          "into the used basic data type int."<<endl;
         size=-3;
         delete[] generator;
@@ -462 +462 @@
   // now compute flip variables
 
-  short* F;
+  int* F;
   // set of flip variables
   // If F[i]==j, x_j will be flipped.
 
-  short r=A.compute_flip_variables(F);
+  int r=A.compute_flip_variables(F);
   // number of flip variables
 
@@ -485 +485 @@
   if(r>0)
   {
-    for(short i=0;i<_w.number_of_weighted_variables();i++)
+    for(int i=0;i<_w.number_of_weighted_variables();i++)
       if((_w[i]!=0) && (i!=F[0]))
         ordering_okay=FALSE;
@@ -499 +499 @@
 
   // compute initial generating system from the kernel of A
-  for(short j=0;j<A._kernel_dimension;j++)
-  {
-
-    for(short k=0;k<A.columns;k++)
+  for(int j=0;j<A._kernel_dimension;j++)
+  {
+
+    for(int k=0;k<A.columns;k++)
     {
 
@@ -516 +516 @@
         cerr<<"\nWARNING: ideal& ideal::DiBiase_Urbanke_ideal(matrix&, const "
           "term_ordering&):\nLLL-reduced kernel basis does not fit "
-          "into the used basic data type short."<<endl;
+          "into the used basic data type int."<<endl;
         size=-3;
         delete[] generator;
@@ -555 +555 @@
 
     // flip variables
-    for(short l=0;l<r;l++)
+    for(int l=0;l<r;l++)
       generator[F[l]]*=-1;
 
@@ -599 +599 @@
   //   smaller in term ordering.
   // - The weight of the pseudo-elimination variable is smaller.
-  short* sat_var;
-  short number_of_sat_var=A.hosten_shapiro(sat_var);
+  int* sat_var;
+  int number_of_sat_var=A.hosten_shapiro(sat_var);
 
   float weight=0;
-  for(short i=0;i<number_of_sat_var;i++)
+  for(int i=0;i<number_of_sat_var;i++)
     weight+=w[sat_var[i]];
 
@@ -614 +614 @@
 
   // first build "saturation generator"
-  for(short k=0;k<A.columns;k++)
+  for(int k=0;k<A.columns;k++)
     generator[k]=0;
-  for(short i=0;i<number_of_sat_var;i++)
+  for(int i=0;i<number_of_sat_var;i++)
     generator[sat_var[i]]=1;
   generator[A.columns]=-1;
@@ -626 +626 @@
 
   // compute initial generating system from the kernel of A
-  for(short j=0;j<A._kernel_dimension;j++)
-  {
-    for(short k=0;k<A.columns;k++)
+  for(int j=0;j<A._kernel_dimension;j++)
+  {
+    for(int k=0;k<A.columns;k++)
     {
       // We should first verifie if the components of the LLL-reduced lattice
@@ -641 +641 @@
         cerr<<"\nWARNING: ideal& ideal::Bigatti_LaScala_Robbiano_ideal"
           "(matrix&, const term_ordering&):\nLLL-reduced kernel basis does "
-          "not fit into the used basic data type short."<<endl;
+          "not fit into the used basic data type int."<<endl;
         size=-3;
         delete[] generator;
@@ -701 +701 @@
 /////////////////// constructors and destructor /////////////////////////////
 
-ideal::ideal(matrix& A, const term_ordering& _w, const short& algorithm)
+ideal::ideal(matrix& A, const term_ordering& _w, const int& algorithm)
 {
 
@@ -709 +709 @@
   {
     cerr<<"\nWARNING: ideal::ideal(matrix&, const term_ordering&, const "
-      "short&):\ncannot create ideal from a corrupt input matrix"<<endl;
+      "int&):\ncannot create ideal from a corrupt input matrix"<<endl;
     size=-1;
     return;
@@ -717 +717 @@
   {
     cerr<<"\nWARNING: ideal::ideal(matrix&, const term_ordering&, const "
-      "short&):\ncannot create ideal with a corrupt input ordering"<<endl;
+      "int&):\ncannot create ideal with a corrupt input ordering"<<endl;
     size=-1;
     return;
@@ -769 +769 @@
       default:
         cerr<<"\nWARNING: ideal::ideal(matrix&, const term_ordering&, const "
-          "short&):\nunknown algorithm for ideal construction"<<endl;
+          "int&):\nunknown algorithm for ideal construction"<<endl;
         size=-1;
         return;
@@ -828 +828 @@
   create_subset_tree();
 
-  for(short i=0;i<Number_of_Lists;i++)
+  for(int i=0;i<Number_of_Lists;i++)
   {
     iter.set_to_list(I.generators[i]);
@@ -840 +840 @@
   }
 
-  for(short i=0;i<Number_of_Lists;i++)
+  for(int i=0;i<Number_of_Lists;i++)
   {
     iter.set_to_list(I.new_generators[i]);
@@ -865 +865 @@
 }
 
-ideal::ideal(ifstream& input, const term_ordering& _w, const short&
+ideal::ideal(ifstream& input, const term_ordering& _w, const int&
              number_of_generators)
 {
@@ -871 +871 @@
   {
     cerr<<"\nWARNING: ideal::ideal(ifstream&, const term_ordering&, const "
-      "short&):\ncannot create ideal with a corrupt input ordering"<<endl;
+      "int&):\ncannot create ideal with a corrupt input ordering"<<endl;
     size=-1;
     return;
@@ -895 +895 @@
 #endif  // SUPPORT_DRIVEN_METHODS_EXTENDED
 
-  short number_of_variables=
+  int number_of_variables=
     w.number_of_elimination_variables()+w.number_of_weighted_variables();
   Integer* generator=new Integer[number_of_variables];
@@ -901 +901 @@
   for(long i=0;i<number_of_generators;i++)
   {
-    for(short j=0;j<number_of_variables;j++)
+    for(int j=0;j<number_of_variables;j++)
     {
       input>>generator[j];
@@ -909 +909 @@
       {
         cerr<<"\nWARNING: ideal::ideal(ifstream&, const term_ordering&, "
-          "const short&): \ninput failure when reading generator "<<i<<endl;
+          "const int&): \ninput failure when reading generator "<<i<<endl;
         size=-2;
         delete[] generator;
@@ -942 +942 @@
 }
 
-short ideal::error_status() const
+int ideal::error_status() const
 {
   if(size<0)
@@ -961 +961 @@
 #ifdef SUPPORT_DRIVEN_METHODS_EXTENDED
 
-  for(short i=0;i<Number_of_Lists;i++)
+  for(int i=0;i<Number_of_Lists;i++)
     generators[i].ordered_print(w);
 
@@ -1002 +1002 @@
 #ifdef SUPPORT_DRIVEN_METHODS_EXTENDED
 
-  for(short i=0;i<Number_of_Lists;i++)
+  for(int i=0;i<Number_of_Lists;i++)
     generators[i].ordered_print(output,w);
 
@@ -1043 +1043 @@
 #ifdef SUPPORT_DRIVEN_METHODS_EXTENDED
 
-  for(short i=0;i<Number_of_Lists;i++)
+  for(int i=0;i<Number_of_Lists;i++)
     generators[i].ordered_print(output,w);
 
@@ -1079 +1079 @@
 #ifdef SUPPORT_DRIVEN_METHODS_EXTENDED
 
-  for(short i=0;i<Number_of_Lists;i++)
+  for(int i=0;i<Number_of_Lists;i++)
     generators[i].ordered_format_print(output,w);
 

IntegerProgramming/ideal.h

@@ -33 +33 @@
 
 
-const short Number_of_Lists=1<<List_Support_Variables;
+const int Number_of_Lists=1<<List_Support_Variables;
 
 
@@ -42 +42 @@
 typedef struct
 {
-  short* subsets_of_support[Number_of_Lists];
-  short number_of_subsets[Number_of_Lists];
+  int* subsets_of_support[Number_of_Lists];
+  int number_of_subsets[Number_of_Lists];
 } subset_tree;
 
@@ -80 +80 @@
 // flags for the use of the S-pair criteria and the autoreduction
 
-  short rel_primeness;
-  short M_criterion;
-  short F_criterion;
-  short B_criterion;
-  short second_criterion;
+  int rel_primeness;
+  int M_criterion;
+  int F_criterion;
+  int B_criterion;
+  int second_criterion;
   // When BuchbergerŽs algorithm is called, we only use one argument which
   // describes the combination of the criteria to be used (see in globals.h).
@@ -150 +150 @@
   // Inserts a (new) generator in the appropriate list.
 
-  short add_new_generators();
+  int add_new_generators();
   // Moves the new generators to the generator lists.
 
@@ -221 +221 @@
 // constructors and destructor (implemented in ideal.cc)
 
-  ideal(matrix&, const term_ordering&, const short& algorithm);
+  ideal(matrix&, const term_ordering&, const int& algorithm);
   // Creates a binomial ideal from the given matrix using the given algorithm
   // (see in globals.h).
@@ -239 +239 @@
   // (or of an ideal and its elimination ideal).
 
-  ideal(ifstream&, const term_ordering&, const short& number_of_generators);
+  ideal(ifstream&, const term_ordering&, const int& number_of_generators);
   // Reads an ideal from a given ifstream in the following way:
   // A block of integers is converted into a binomial
@@ -255 +255 @@
   // Returns the actual number of generators.
 
-  short error_status() const;
+  int error_status() const;
   // Returns -1 if an error has occurred (i.e. size<0), else 0.
 
 // Buchberger stuff (implemented in Buchberger.cc)
 
-  ideal& reduced_Groebner_basis_1(const short& S_pair_criteria=11,
+  ideal& reduced_Groebner_basis_1(const int& S_pair_criteria=11,
                                   const float& interred_percentage=12.0);
-  ideal& reduced_Groebner_basis_1a(const short& S_pair_criteria=11,
+  ideal& reduced_Groebner_basis_1a(const int& S_pair_criteria=11,
                                    const float& interred_percentage=12.0);
-  ideal& reduced_Groebner_basis_2(const short& S_pair_criteria=11,
+  ideal& reduced_Groebner_basis_2(const int& S_pair_criteria=11,
                                   const float& interred_percentage=12.0);
-  ideal& reduced_Groebner_basis_3(const short& S_pair_criteria=11,
+  ideal& reduced_Groebner_basis_3(const int& S_pair_criteria=11,
                                   const float& interred_percentage=12.0);
   // Several different versions of BuchbergerŽs algorithm for computing
@@ -294 +294 @@
   // "between" the input ideal and its saturation.
 
-  ideal& reduced_Groebner_basis(const short& version=1,
-                                const short& S_pair_criteria=11,
+  ideal& reduced_Groebner_basis(const int& version=1,
+                                const int& S_pair_criteria=11,
                                 const float& interred_percentage=12.0);
   // Takes the version of BuchbergerŽs algorithm as above as an argument
@@ -331 +331 @@
   // SUPPORT_DRIVEN_METHODS_EXTENDED are enabled.
 
-  ideal& swap_variables(const short& i, const short& j);
+  ideal& swap_variables(const int& i, const int& j);
   // Swaps the i-th and the j-th variable in all generators as well as the
   // corresponding components of the term ordering's weight vector.
@@ -337 +337 @@
   // according to the new order on the variables.
 
-  ideal& swap_variables_unsafe(const short& i, const short& j);
+  ideal& swap_variables_unsafe(const int& i, const int& j);
   // Swaps the i-th and the j-th variable in all generators as well as the
   // corresponding components of the term ordering's weight vector.
   // DANGER: The head/tail structure is not rebuilt!
 
-  ideal& flip_variable_unsafe(const short& i);
+  ideal& flip_variable_unsafe(const int& i);
   // Inverts the sign of the i-th variable in all generators.
   // DANGER: The list structure is not rebuilt!

IntegerProgramming/ideal_stuff.cc

@@ -65 +65 @@
 
   // elimination
-  for(short i=0;i<Number_of_Lists;i++)
+  for(int i=0;i<Number_of_Lists;i++)
   {
     iter.set_to_list(generators[i]);
@@ -125 +125 @@
   list_iterator iter;
 
-  short last_weighted_variable=w.number_of_weighted_variables()-1;
+  int last_weighted_variable=w.number_of_weighted_variables()-1;
 
 
@@ -167 +167 @@
 // For the time needed by this function see the remarks for ideal::eliminate().
 
-  for(short i=0;i<Number_of_Lists;i++)
+  for(int i=0;i<Number_of_Lists;i++)
   {
     iter.set_to_list(generators[i]);
@@ -260 +260 @@
 // the aux_list and then reinserted according to their new head.
 
-  for(short i=0;i<Number_of_Lists;i++)
+  for(int i=0;i<Number_of_Lists;i++)
   {
     iter.set_to_list(generators[i]);
@@ -314 +314 @@
 
 
-ideal& ideal::swap_variables_unsafe(const short& i, const short& j)
+ideal& ideal::swap_variables_unsafe(const int& i, const int& j)
 {
   // first check arguments
@@ -320 +320 @@
      || (j<0) || (j>=w.number_of_weighted_variables()))
   {
-    cout<<"WARNING: ideal::swap_variables(const short&, const short&)\n "
-      "or ideal::swap_variables_unsafe(const short&, const short&):\n"
+    cout<<"WARNING: ideal::swap_variables(const int&, const int&)\n "
+      "or ideal::swap_variables_unsafe(const int&, const int&):\n"
       "index out of range"<<endl;
     return *this;
@@ -353 +353 @@
 // But head and tail are not adapted to the new term ordering induced by
 // the change of the variable order - this is only done in the "safe"
-// routine swap_variables(const short&, const short&).
-
-  for(short l=0;l<Number_of_Lists;l++)
+// routine swap_variables(const int&, const int&).
+
+  for(int l=0;l<Number_of_Lists;l++)
   {
     iter.set_to_list(generators[l]);
@@ -393 +393 @@
 
 
-ideal& ideal::swap_variables(const short& i, const short& j)
+ideal& ideal::swap_variables(const int& i, const int& j)
 {
 
@@ -407 +407 @@
 
 
-ideal& ideal::flip_variable_unsafe(const short& i)
+ideal& ideal::flip_variable_unsafe(const int& i)
 {
   // first check argument
   if((i<0) || (i>=w.number_of_weighted_variables()))
   {
-    cout<<"WARNING: ideal::flip_variables(const short&):\n"
+    cout<<"WARNING: ideal::flip_variables(const int&):\n"
       "argument out of range, nothing done"<<endl;
     return *this;
@@ -439 +439 @@
 // to the aux_list and then reinserted according to their new head.
 
-  for(short l=0;l<Number_of_Lists;l++)
+  for(int l=0;l<Number_of_Lists;l++)
   {
     iter.set_to_list(generators[l]);

IntegerProgramming/matrix.cc

@@ -12 +12 @@
 typedef BigInt* BigIntP;
 
-matrix::matrix(const short& row_number, const short& column_number)
+matrix::matrix(const int& row_number, const int& column_number)
     :rows(row_number),columns(column_number)
 {
@@ -22 +22 @@
     // bad input, set "error flag"
   {
-    cerr<<"\nWARNING: matrix::matrix(const short&, const short&):\n"
+    cerr<<"\nWARNING: matrix::matrix(const int&, const int&):\n"
       "argument out of range"<<endl;
     columns=-1;
@@ -31 +31 @@
 
   coefficients=new IntegerP[rows];
-  for(short i=0;i<rows;i++)
+  for(int i=0;i<rows;i++)
     coefficients[i]=new Integer[columns];
-  for(short i=0;i<rows;i++)
-    for(short j=0;j<columns;j++)
+  for(int i=0;i<rows;i++)
+    for(int j=0;j<columns;j++)
       coefficients[i][j]=0;
 }
 
-matrix::matrix(const short& row_number, const short& column_number,
+matrix::matrix(const int& row_number, const int& column_number,
                Integer** entries)
     :rows(row_number),columns(column_number)
@@ -49 +49 @@
     // bad input, set "error flag"
   {
-    cerr<<"\nWARNING: matrix::matrix(const short&, const short&, Integr**):\n"
+    cerr<<"\nWARNING: matrix::matrix(const int&, const int&, Integr**):\n"
       "argument out of range"<<endl;
     columns=-1;
@@ -58 +58 @@
 
   coefficients=new IntegerP[rows];
-  for(short i=0;i<rows;i++)
+  for(int i=0;i<rows;i++)
     coefficients[i]=new Integer[columns];
-  for(short i=0;i<rows;i++)
-    for(short j=0;j<columns;j++)
+  for(int i=0;i<rows;i++)
+    for(int j=0;j<columns;j++)
       coefficients[i][j]=entries[i][j];
   // coefficients[i] is the i-th row vector
@@ -101 +101 @@
 
   coefficients=new IntegerP[rows];
-  for(short i=0;i<rows;i++)
+  for(int i=0;i<rows;i++)
     coefficients[i]=new Integer[columns];
-  for(short i=0;i<rows;i++)
-    for(short j=0;j<columns;j++)
+  for(int i=0;i<rows;i++)
+    for(int j=0;j<columns;j++)
     {
       input>>coefficients[i][j];
@@ -120 +120 @@
 
 
-matrix::matrix(const short& m, const short& n, ifstream& input)
+matrix::matrix(const int& m, const int& n, ifstream& input)
 {
   _kernel_dimension=-2;
@@ -129 +129 @@
     // bad input, set "error flag"
   {
-    cerr<<"\nWARNING: matrix::matrix(const short&, const short&, ifstream&):\n"
+    cerr<<"\nWARNING: matrix::matrix(const int&, const int&, ifstream&):\n"
       "argument out of range"<<endl;
     columns=-1;
@@ -141 +141 @@
 
   coefficients=new IntegerP[rows];
-  for(short i=0;i<rows;i++)
+  for(int i=0;i<rows;i++)
     coefficients[i]=new Integer[columns];
-  for(short i=0;i<rows;i++)
-    for(short j=0;j<columns;j++)
+  for(int i=0;i<rows;i++)
+    for(int j=0;j<columns;j++)
     {
       input>>coefficients[i][j];
@@ -173 +173 @@
 
   coefficients=new IntegerP[rows];
-  for(short i=0;i<rows;i++)
+  for(int i=0;i<rows;i++)
     coefficients[i]=new Integer[columns];
-  for(short i=0;i<rows;i++)
-    for(short j=0;j<columns;j++)
+  for(int i=0;i<rows;i++)
+    for(int j=0;j<columns;j++)
       coefficients[i][j]=A.coefficients[i][j];
 
@@ -182 +182 @@
   {
     H=new BigIntP[_kernel_dimension];
-    for(short k=0;k<_kernel_dimension;k++)
+    for(int k=0;k<_kernel_dimension;k++)
       H[k]=new BigInt[columns];
-    for(short k=0;k<_kernel_dimension;k++)
-      for(short j=0;j<columns;j++)
+    for(int k=0;k<_kernel_dimension;k++)
+      for(int j=0;j<columns;j++)
         H[k][j]=(A.H)[k][j];
   }
@@ -195 +195 @@
 matrix::~matrix()
 {
-  for(short i=0;i<rows;i++)
+  for(int i=0;i<rows;i++)
     delete[] coefficients[i];
   delete[] coefficients;
@@ -202 +202 @@
     // LLL-algorithm performed
   {
-    for(short i=0;i<_kernel_dimension;i++)
+    for(int i=0;i<_kernel_dimension;i++)
       delete[] H[i];
     delete[] H;
@@ -218 +218 @@
 BOOLEAN matrix::is_nonnegative() const
 {
-  for(short i=0;i<rows;i++)
-    for(short j=0;j<columns;j++)
+  for(int i=0;i<rows;i++)
+    for(int j=0;j<columns;j++)
       if(coefficients[i][j]<0)
         return FALSE;
@@ -227 +227 @@
 
 
-short matrix::error_status() const
+int matrix::error_status() const
 {
   if(columns<0)
@@ -237 +237 @@
 
 
-short matrix::row_number() const
+int matrix::row_number() const
 {
   return rows;
@@ -244 +244 @@
 
 
-short matrix::column_number() const
+int matrix::column_number() const
 {
   return columns;
@@ -257 +257 @@
 
 
-short matrix::LLL_kernel_basis()
+int matrix::LLL_kernel_basis()
 {
 
@@ -263 +263 @@
   // (They are modified by the LLL-algorithm!)
   BigInt** b=new BigIntP[columns];
-  for(short n=0;n<columns;n++)
+  for(int n=0;n<columns;n++)
     b[n]=new BigInt[rows];
-  for(short n=0;n<columns;n++)
-    for(short m=0;m<rows;m++)
+  for(int n=0;n<columns;n++)
+    for(int m=0;m<rows;m++)
       b[n][m]=coefficients[m][n];
 
@@ -276 +276 @@
 
   // delete auxiliary vectors
-  for(short n=0;n<columns;n++)
+  for(int n=0;n<columns;n++)
     delete[] b[n];
   delete[] b;
@@ -286 +286 @@
 
 
-short matrix::compute_nonzero_kernel_vector()
+int matrix::compute_nonzero_kernel_vector()
 {
 
@@ -295 +295 @@
   if(_kernel_dimension==-1)
   {
-    cerr<<"\nWARNING: short matrix::compute_non_zero_kernel_vector(BigInt*&):"
+    cerr<<"\nWARNING: int matrix::compute_non_zero_kernel_vector(BigInt*&):"
       "\nerror in kernel basis, cannot compute the desired vector"<<endl;
     return 0;
@@ -302 +302 @@
   if(_kernel_dimension==0)
   {
-    cerr<<"\nWARNING: short matrix::compute_non_zero_kernel_vector(BigInt*&): "
+    cerr<<"\nWARNING: int matrix::compute_non_zero_kernel_vector(BigInt*&): "
       "\nkernel dimension is zero"<<endl;
     return 0;
@@ -318 +318 @@
 
   // determine number of zero components
-  for(short i=0;i<_kernel_dimension;i++)
+  for(int i=0;i<_kernel_dimension;i++)
   {
     M[i]=0;
-    for(short j=0;j<columns;j++)
+    for(int j=0;j<columns;j++)
       if(H[i][j]==BigInt(0))
         M[i]++;
@@ -330 +330 @@
   // columns is an upper bound (not reached because the kernel basis cannot
   // contain the zero vector)
-  for(short i=0;i<_kernel_dimension;i++)
+  for(int i=0;i<_kernel_dimension;i++)
     if(M[i]<min)
       min=M[i];
@@ -337 +337 @@
   // and discard the others (the norm computation is why we have chosen the
   // M[i] to be BigInts)
-  for(short i=0;i<_kernel_dimension;i++)
+  for(int i=0;i<_kernel_dimension;i++)
     if(M[i]!=min)
       M[i]=-1;
     else
-      for(short j=0;j<columns;j++)
+      for(int j=0;j<columns;j++)
         M[i]+=H[i][j]*H[i][j];
   // As the lattice basis does not contain the zero vector, at least one M[i]
@@ -348 +348 @@
   // determine the start vector, i.e. the one with least zero components, but
   // smallest possible (euclidian) norm
-  short min_index=-1;
-  for(short i=0;i<_kernel_dimension;i++)
+  int min_index=-1;
+  for(int i=0;i<_kernel_dimension;i++)
     if(M[i]>BigInt(0))
       if(min_index==-1)
@@ -377 +377 @@
 // still a  l a t t i c e   basis).
 
-  for(short current_position=1;current_position<columns;current_position++)
+  for(int current_position=1;current_position<columns;current_position++)
     // in fact, this loop will terminate before the condition in the
     // for-statement is satisfied...
@@ -386 +386 @@
 
     BOOLEAN found=TRUE;
-    for(short j=0;j<columns;j++)
+    for(int j=0;j<columns;j++)
       if(H[0][j]==BigInt(0))
         found=FALSE;
@@ -401 +401 @@
     // determine number of components in each remaining vector that are zero
     // in the vector itself as well as in the already constructed vector
-    for(short i=current_position;i<_kernel_dimension;i++)
+    for(int i=current_position;i<_kernel_dimension;i++)
       M[i]=0;
 
-    short remaining_zero_components=0;
-
-    for(short j=0;j<columns;j++)
+    int remaining_zero_components=0;
+
+    for(int j=0;j<columns;j++)
       if(H[0][j]==BigInt(0))
       {
         remaining_zero_components++;
-        for(short i=current_position;i<_kernel_dimension;i++)
+        for(int i=current_position;i<_kernel_dimension;i++)
           if(H[i][j]==BigInt(0))
             M[i]++;
@@ -419 +419 @@
     // this is the number of zero components in H[0] and an upper bound
     // for the M[i]
-    for(short i=current_position;i<_kernel_dimension;i++)
+    for(int i=current_position;i<_kernel_dimension;i++)
       if(M[i]<min)
         min=M[i];
@@ -431 +431 @@
     // components
     // discard the others
-    for(short i=current_position;i<_kernel_dimension;i++)
+    for(int i=current_position;i<_kernel_dimension;i++)
       if(M[i]!=min)
         M[i]=-1;
       else
-        for(short j=0;j<columns;j++)
+        for(int j=0;j<columns;j++)
           M[i]+=H[i][j]*H[i][j];
     //  Again, at least one M[i] is positive!
@@ -442 +442 @@
     // This is the vector with the least common zero components with respect
     // to H[0], but the smallest possible norm.
-    short min_index=0;
-    for(short i=current_position;i<_kernel_dimension;i++)
+    int min_index=0;
+    for(int i=current_position;i<_kernel_dimension;i++)
       if(M[i]>BigInt(0))
         if(min_index==0)
@@ -472 +472 @@
     found=FALSE;
 
-    for(short mult=1;found==FALSE;mult++)
+    for(int mult=1;found==FALSE;mult++)
     {
       found=TRUE;
@@ -478 +478 @@
       // check if any component !=0 of H[0] becomes zero by adding
       // mult*H[current_position]
-      for(short j=0;j<columns;j++)
+      for(int j=0;j<columns;j++)
         if(H[0][j]!=BigInt(0))
           if(H[0][j]+(const BigInt&)mult*H[current_position][j]
@@ -485 +485 @@
 
       if(found==TRUE)
-        for(short j=0;j<columns;j++)
+        for(int j=0;j<columns;j++)
           H[0][j]+=(const BigInt&)mult*H[current_position][j];
       else
@@ -495 +495 @@
         // check if any component !=0 of H[0] becomes zero by subtracting
         // mult*H[current_position]
-        for(short j=0;j<columns;j++)
+        for(int j=0;j<columns;j++)
           if(H[0][j]!=BigInt(0))
             if(H[0][j]-(const BigInt&)mult*H[current_position][j]
@@ -502 +502 @@
 
         if(found==TRUE)
-          for(short j=0;j<columns;j++)
+          for(int j=0;j<columns;j++)
             H[0][j]-=(const BigInt&)mult*H[current_position][j];
       }
@@ -509 +509 @@
 
 // When reaching this line, an error must have occurred.
-  cerr<<"FATAL ERROR in short matrix::compute_nonnegative_vector()"<<endl;
+  cerr<<"FATAL ERROR in int matrix::compute_nonnegative_vector()"<<endl;
   abort();
 }
 
-short matrix::compute_flip_variables(short*& F)
+int matrix::compute_flip_variables(int*& F)
 {
   // first compute nonzero vector
@@ -520 +520 @@
   if(!okay)
   {
-    cout<<"\nWARNING: short matrix::compute_flip_variables(short*&):\n"
+    cout<<"\nWARNING: int matrix::compute_flip_variables(int*&):\n"
       "kernel of the matrix contains no vector with nonzero components,\n"
       "no flip variables computed"<<endl;
@@ -530 +530 @@
   // or those corresponding to the negative ones
 
-  short r=0;
+  int r=0;
   // number of flip variables
 
-  for(short j=0;j<columns;j++)
+  for(int j=0;j<columns;j++)
     if(H[0][j]<BigInt(0))
       r++;
@@ -547 +547 @@
   {
     r=columns-r;
-    F=new short[r];
-    memset(F,0,r*sizeof(short));
-    short counter=0;
-    for(short j=0;j<columns;j++)
+    F=new int[r];
+    memset(F,0,r*sizeof(int));
+    int counter=0;
+    for(int j=0;j<columns;j++)
       if(H[0][j]> BigInt(0))
       {
@@ -561 +561 @@
     // all variables corresponding to negative components will be flipped
   {
-    F=new short[r];
-    memset(F,0,r*sizeof(short));
-    short counter=0;
-    for(short j=0;j<columns;j++)
+    F=new int[r];
+    memset(F,0,r*sizeof(int));
+    int counter=0;
+    for(int j=0;j<columns;j++)
       if(H[0][j]< BigInt(0))
       {
@@ -578 +578 @@
 
 
-short matrix::hosten_shapiro(short*& sat_var)
+int matrix::hosten_shapiro(int*& sat_var)
 {
 
@@ -587 +587 @@
   if(_kernel_dimension==-1)
   {
-    cerr<<"\nWARNING: short matrix::hosten_shapiro(short*&):\n"
+    cerr<<"\nWARNING: int matrix::hosten_shapiro(int*&):\n"
       "error in kernel basis, cannot compute the saturation variables"<<endl;
     return 0;
@@ -604 +604 @@
     return 0;
 
-  short number_of_sat_var=0;
-  sat_var=new short[columns/2];
-  memset(sat_var,0,sizeof(short)*(columns/2));
+  int number_of_sat_var=0;
+  sat_var=new int[columns/2];
+  memset(sat_var,0,sizeof(int)*(columns/2));
 
   BOOLEAN* ideal_saturated_by_var=new BOOLEAN[columns];
   // auxiliary array used to remember by which variables the ideal has still to
   // be saturated
-  for(short j=0;j<columns;j++)
+  for(int j=0;j<columns;j++)
     ideal_saturated_by_var[j]=FALSE;
 
-  for(short k=0;k<_kernel_dimension;k++)
+  for(int k=0;k<_kernel_dimension;k++)
   {
     // determine number of positive and negative components in H[k]
     // corresponding to variables by which the ideal has still to be saturated
-    short pos_sat_var=0;
-    short neg_sat_var=0;
-
-    for(short j=0;j<columns;j++)
+    int pos_sat_var=0;
+    int neg_sat_var=0;
+
+    for(int j=0;j<columns;j++)
     {
       if(ideal_saturated_by_var[j]==FALSE)
@@ -637 +637 @@
     if(pos_sat_var<=neg_sat_var)
     {
-      for(short j=0;j<columns;j++)
+      for(int j=0;j<columns;j++)
         if(ideal_saturated_by_var[j]==FALSE)
           if(H[k][j]> BigInt(0))
@@ -655 +655 @@
     else
     {
-      for(short j=0;j<columns;j++)
+      for(int j=0;j<columns;j++)
         if(ideal_saturated_by_var[j]==FALSE)
           if(H[k][j]< BigInt(0))
@@ -691 +691 @@
   printf("\n%3d x %3d\n",rows,columns);
 
-  for(short i=0;i<rows;i++)
-  {
-    for(short j=0;j<columns;j++)
+  for(int i=0;i<rows;i++)
+  {
+    for(int j=0;j<columns;j++)
       printf("%6d",coefficients[i][j]);
     printf("\n");
@@ -704 +704 @@
   fprintf(output,"\n%3d x %3d\n",rows,columns);
 
-  for(short i=0;i<rows;i++)
-  {
-    for(short j=0;j<columns;j++)
+  for(int i=0;i<rows;i++)
+  {
+    for(int j=0;j<columns;j++)
       fprintf(output,"%6d",coefficients[i][j]);
     fprintf(output,"\n");
@@ -717 +717 @@
   output<<endl<<setw(3)<<rows<<" x "<<setw(3)<<columns<<endl;
 
-  for(short i=0;i<rows;i++)
-  {
-    for(short j=0;j<columns;j++)
+  for(int i=0;i<rows;i++)
+  {
+    for(int j=0;j<columns;j++)
       output<<setw(6)<<coefficients[i][j];
     output<<endl;

IntegerProgramming/matrix.h

@@ -32 +32 @@
 private:
 
-  short rows;
+  int rows;
 
-  short columns;
+  int columns;
   // Also used as error flag (values <0):
   // -1 indicates a "semantic" error (which occurs e.g. if some constructor
@@ -48 +48 @@
   // allocated if such a basis is really computed.
 
-  short _kernel_dimension;
+  int _kernel_dimension;
   // the number of vectors stored in H (the size of these vectors is columns)
   // If _kernel_dimension==-2, no kernel basis has been computed yet.
@@ -62 +62 @@
 // constructors and destructor
 
-  matrix(const short& row_number, const short& column_number);
+  matrix(const int& row_number, const int& column_number);
   // Creates a zero matrix of the specified size.
 
-  matrix(const short& row_number, const short& column_number,
+  matrix(const int& row_number, const int& column_number,
          Integer** entries);
   // Builds a matrix from its coefficient array.
@@ -80 +80 @@
   //    coefficients 0..n-1 of row m
 
-  matrix(const short& m, const short& n, ifstream& input);
+  matrix(const int& m, const int& n, ifstream& input);
   // Reads a (m x n)-matrix from the given ifstream.
   // The input stream must have the following format:
@@ -102 +102 @@
   // Returns TRUE, if all entries of the matrix are >=0, else FALSE.
 
-  short error_status() const;
+  int error_status() const;
   // Returns columns iff columns<0 (this is the "error flag"), else 0.
 
-  short row_number() const;
+  int row_number() const;
   // Retuns the row number.
 
-  short column_number() const;
+  int column_number() const;
   // Returns the column number.
 
-  short kernel_dimension() const;
+  int kernel_dimension() const;
   // Returns the kernel dimension.
 
@@ -118 +118 @@
 // special routines for the IP-algorithms
 
-  short LLL_kernel_basis();
+  int LLL_kernel_basis();
   // Computes a LLL-reduced integer basis of the matrix kernel and returns
   // the kernel dimension (-1 if an error has occurred).
   // This dimension is also stored in the member kernel_dimension.
 
-  short compute_nonzero_kernel_vector();
+  int compute_nonzero_kernel_vector();
   // Transforms the kernel lattice basis stored in H so that it contains
   // a vector whose components are all !=0;
@@ -129 +129 @@
   // If no such basis has been computed before, this is done now.
 
-  short compute_flip_variables(short*&);
+  int compute_flip_variables(int*&);
   // Computes a set of flip variables for the algorithm of DiBiase and
   // Urbanke from a kernel vector with no zero components.
@@ -137 +137 @@
   // is done in the routine) to be accessible for the calling function.
 
-  short hosten_shapiro(short*& sat_var);
+  int hosten_shapiro(int*& sat_var);
   // Computes a set of saturation variables for the ideal defined by the
   // kernel lattice and returns the size of that set.

IntegerProgramming/solve_IP.cc

@@ -16 +16 @@
   // with default settings
   BOOLEAN verbose=FALSE;
-  short version=1;
-  short S_pair_criteria=11;
+  int version=1;
+  int S_pair_criteria=11;
   double interreduction_percentage=12.0;
 
 ///////////////////////// parse options /////////////////////////////////////
 
-  short alg_option=0;
+  int alg_option=0;
   // no algorithm specified yet
 
@@ -30 +30 @@
   {
 
-    for(short i=1;i<argc-2;i++)
+    for(int i=1;i<argc-2;i++)
       // these are the input options
     {
@@ -250 +250 @@
       char* GROEBNER=new char[128];
       memset(GROEBNER,0,128);
-      short i=0;
+      int i=0;
       while(argv[argc-2][i]!='\0' && argv[argc-2][i]!='.' && argv[argc-2][i]>' ')
       {