Changeset f3094a in git for libpolys/polys/monomials

Timestamp:

Jul 23, 2012, 5:29:18 PM (12 years ago)

Author:

Oleksandr Motsak <motsak@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

6779bb431ba1eced98b7cb0e1fed5fbfef1f0244

Parents:

98223c2d11013c57837511c1adb1ef9a16193b3d

git-author:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2012-07-23 17:29:18+02:00

git-committer:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2012-07-25 15:25:07+02:00

Message:

moved the definition of p_GetShortExpVector(poly, ring) to p_polys.cc

Location:

libpolys/polys/monomials

Files:

• monomials.cc (modified) (1 diff)
• p_polys.cc (modified) (2 diffs)
• p_polys.h (modified) (1 diff)
• ring.cc (modified) (1 diff)

libpolys/polys/monomials/monomials.cc

@@ -30 +30 @@
 #endif
 
-#include <polys/monomials/ring.h>
-#include <reporter/reporter.h>
-#include <coeffs/numbers.h>
-#include <polys/monomials/ring.h>
-#include <polys/monomials/p_polys.h>
-#include <reporter/reporter.h>
-
-#ifdef PDEBUG
-int pDBsyzComp=0;
-#endif
-
-/***************************************************************
- *
- * Storage Managament Routines
- *
- ***************************************************************/
-
-
-static inline unsigned long GetBitFields(long e,
-                                         unsigned int s, unsigned int n)
-{
-#define Sy_bit_L(x)     (((unsigned long)1L)<<(x))
-  unsigned int i = 0;
-  unsigned long  ev = 0L;
-  assume(n > 0 && s < BIT_SIZEOF_LONG);
-  do
-  {
-    assume(s+i < BIT_SIZEOF_LONG);
-    if (e > (long) i) ev |= Sy_bit_L(s+i);
-    else break;
-    i++;
-  }
-  while (i < n);
-  return ev;
-}
-
-// Short Exponent Vectors are used for fast divisibility tests
-// ShortExpVectors "squeeze" an exponent vector into one word as follows:
-// Let n = BIT_SIZEOF_LONG / pVariables.
-// If n == 0 (i.e. pVariables > BIT_SIZE_OF_LONG), let m == the number
-// of non-zero exponents. If (m>BIT_SIZEOF_LONG), then sev = ~0, else
-// first m bits of sev are set to 1.
-// Otherwise (i.e. pVariables <= BIT_SIZE_OF_LONG)
-// represented by a bit-field of length n (resp. n+1 for some
-// exponents). If the value of an exponent is greater or equal to n, then
-// all of its respective n bits are set to 1. If the value of an exponent
-// is smaller than n, say m, then only the first m bits of the respective
-// n bits are set to 1, the others are set to 0.
-// This way, we have:
-// exp1 / exp2 ==> (ev1 & ~ev2) == 0, i.e.,
-// if (ev1 & ~ev2) then exp1 does not divide exp2
-unsigned long p_GetShortExpVector(poly p, const ring r)
-{
-  assume(p != NULL);
-  if (p == NULL) return 0;
-  unsigned long ev = 0; // short exponent vector
-  unsigned int n = BIT_SIZEOF_LONG / r->N; // number of bits per exp
-  unsigned int m1; // highest bit which is filled with (n+1)
-  unsigned int i = 0, j=1;
-
-  if (n == 0)
-  {
-    if (r->N <2*BIT_SIZEOF_LONG)
-    {
-      n=1;
-      m1=0;
-    }
-    else
-    {
-      for (; j<=(unsigned long) r->N; j++)
-      {
-        if (p_GetExp(p,j,r) > 0) i++;
-        if (i == BIT_SIZEOF_LONG) break;
-      }
-      if (i>0)
-      ev = ~((unsigned long)0) >> ((unsigned long) (BIT_SIZEOF_LONG - i));
-      return ev;
-    }
-  }
-  else
-  {
-    m1 = (n+1)*(BIT_SIZEOF_LONG - n*r->N);
-  }
-
-  n++;
-  while (i<m1)
-  {
-    ev |= GetBitFields(p_GetExp(p, j,r), i, n);
-    i += n;
-    j++;
-  }
-
-  n--;
-  while (i<BIT_SIZEOF_LONG)
-  {
-    ev |= GetBitFields(p_GetExp(p, j,r), i, n);
-    i += n;
-    j++;
-  }
-  return ev;
-}
 
 #endif // POLYS_IMPL_CC

libpolys/polys/monomials/p_polys.cc

@@ -10 +10 @@
 
 
-
 #include "config.h"
+
+#include <ctype.h>
+
+#include <omalloc/omalloc.h>
+
 #include <misc/auxiliary.h>
 
-#include <ctype.h>
-#include <omalloc/omalloc.h>
 #include <misc/options.h>
 #include <misc/intvec.h>
@@ -4091 +4093 @@
   }
 }
+
+/***************************************************************
+ *
+ * Storage Managament Routines
+ *
+ ***************************************************************/
+
+
+static inline unsigned long GetBitFields(long e,
+                                         unsigned int s, unsigned int n)
+{
+#define Sy_bit_L(x)     (((unsigned long)1L)<<(x))
+  unsigned int i = 0;
+  unsigned long  ev = 0L;
+  assume(n > 0 && s < BIT_SIZEOF_LONG);
+  do
+  {
+    assume(s+i < BIT_SIZEOF_LONG);
+    if (e > (long) i) ev |= Sy_bit_L(s+i);
+    else break;
+    i++;
+  }
+  while (i < n);
+  return ev;
+}
+
+// Short Exponent Vectors are used for fast divisibility tests
+// ShortExpVectors "squeeze" an exponent vector into one word as follows:
+// Let n = BIT_SIZEOF_LONG / pVariables.
+// If n == 0 (i.e. pVariables > BIT_SIZE_OF_LONG), let m == the number
+// of non-zero exponents. If (m>BIT_SIZEOF_LONG), then sev = ~0, else
+// first m bits of sev are set to 1.
+// Otherwise (i.e. pVariables <= BIT_SIZE_OF_LONG)
+// represented by a bit-field of length n (resp. n+1 for some
+// exponents). If the value of an exponent is greater or equal to n, then
+// all of its respective n bits are set to 1. If the value of an exponent
+// is smaller than n, say m, then only the first m bits of the respective
+// n bits are set to 1, the others are set to 0.
+// This way, we have:
+// exp1 / exp2 ==> (ev1 & ~ev2) == 0, i.e.,
+// if (ev1 & ~ev2) then exp1 does not divide exp2
+unsigned long p_GetShortExpVector(poly p, const ring r)
+{
+  assume(p != NULL);
+  if (p == NULL) return 0;
+  unsigned long ev = 0; // short exponent vector
+  unsigned int n = BIT_SIZEOF_LONG / r->N; // number of bits per exp
+  unsigned int m1; // highest bit which is filled with (n+1)
+  unsigned int i = 0, j=1;
+
+  if (n == 0)
+  {
+    if (r->N <2*BIT_SIZEOF_LONG)
+    {
+      n=1;
+      m1=0;
+    }
+    else
+    {
+      for (; j<=(unsigned long) r->N; j++)
+      {
+        if (p_GetExp(p,j,r) > 0) i++;
+        if (i == BIT_SIZEOF_LONG) break;
+      }
+      if (i>0)
+        ev = ~((unsigned long)0) >> ((unsigned long) (BIT_SIZEOF_LONG - i));
+      return ev;
+    }
+  }
+  else
+  {
+    m1 = (n+1)*(BIT_SIZEOF_LONG - n*r->N);
+  }
+
+  n++;
+  while (i<m1)
+  {
+    ev |= GetBitFields(p_GetExp(p, j,r), i, n);
+    i += n;
+    j++;
+  }
+
+  n--;
+  while (i<BIT_SIZEOF_LONG)
+  {
+    ev |= GetBitFields(p_GetExp(p, j,r), i, n);
+    i += n;
+    j++;
+  }
+  return ev;
+}
+
 /***************************************************************
  *

libpolys/polys/monomials/p_polys.h

@@ -18 +18 @@
 
 #include <omalloc/omalloc.h>
+
 #include <misc/mylimits.h>
 #include <misc/intvec.h>
 #include <coeffs/coeffs.h>
 
+#include <polys/monomials/monomials.h>
 #include <polys/monomials/ring.h>
-#include <polys/monomials/monomials.h>
 
 #include <polys/templates/p_MemAdd.h>

libpolys/polys/monomials/ring.cc

@@ -5005 +5005 @@
 }
 
+#ifdef PDEBUG
+int pDBsyzComp=0;
+#endif
+
 
 void rSetSyzComp(int k, const ring r)