Changeset e78f35 in git

Timestamp:

Feb 19, 2013, 8:32:57 PM (10 years ago)

Author:

Oleksandr Motsak <motsak@…>

Branches:

(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'f875bbaccd0831e36aaed09ff6adeb3eb45aeb94')

Children:

2a3743b6431021631dff0bb9d7b7888a205302b1bc03ea6301177ce6360abcfc3922ff0edc5f9a73

Parents:

26e817f3b4db82c0b0a5376b16c2e9648ecf55e3d81e39d347055cad093a2ae53302e036ae2a449c

Message:

Merge pull request #280 from malex984/adapting_commits_from_master_minors

Adapting commits from master minors

Files:

• Singular/MinorInterface.cc (modified) (2 diffs)
• kernel/ideals.cc (modified) (2 diffs)
• kernel/ideals.h (modified) (1 diff)

Singular/MinorInterface.cc

@@ -190 +190 @@
   /* before we return the result, let's omit zero generators
      in iii which come after the computed minors */
-  ideal jjj;
-  if (collectedMinors == 0) jjj = idInit(1);
-  else                      jjj = idCopyFirstK(iii, collectedMinors);
-  idDelete(&iii);
+  idKeepFirstK(iii, collectedMinors);
   delete[] myColumnIndices;
   delete[] myRowIndices;
-  return jjj;
+  return(iii);
 }
 
@@ -542 +539 @@
     else
     { /* k == 0, i.e., all minors are requested */
-      int minorCount = 1;
-      for (int i = rowCount - minorSize + 1; i <= rowCount; i++)
-        minorCount = minorCount * i;
-      for (int i = 2; i <= minorSize; i++) minorCount = minorCount / i;
-      for (int i = columnCount - minorSize + 1; i <= columnCount; i++)
-        minorCount = minorCount * i;
-      for (int i = 2; i <= minorSize; i++) minorCount = minorCount / i;
-      /* now: minorCount =   (rowCount over minorSize)
-                           * (columnCount over minorSize) */
+      int minorCount = binom(rowCount, minorSize);
+      minorCount *= binom(columnCount, minorSize);
       if      ((minorSize >= 3) && (vars <= 4)
                && (minorCount >= 100))                           c = true;

kernel/ideals.cc

@@ -11 +11 @@
 
 #include <omalloc/omalloc.h>
-#include <misc/auxiliary.h>
-
 
 #ifndef NDEBUG
@@ -2559 +2557 @@
 */
 
-
-
+/// keeps the first k (>= 1) entries of the given ideal
+/// (Note that the kept polynomials may be zero.)
+void idKeepFirstK(ideal id, const int k)
+{
+   for (int i = IDELEMS(id)-1; i >= k; i--)
+   {
+      if (id->m[i] != NULL) pDelete(&id->m[i]);
+   }
+   int kk=k;                                                                                                                 
+   if (k==0) kk=1; /* ideals must have at least one element(0)*/                                                             
+   pEnlargeSet(&(id->m), IDELEMS(id), kk-IDELEMS(id));                                                                       
+   IDELEMS(id) = kk; 
+}
+
+/*
+* compare the leading terms of a and b
+*/
+static int tCompare(const poly a, const poly b)
+{
+  if (b == NULL) return(a != NULL);
+  if (a == NULL) return(-1);
+
+  /* a != NULL && b != NULL */
+  int r = pLmCmp(a, b);
+  if (r != 0) return(r);
+  number h = nSub(pGetCoeff(a), pGetCoeff(b));
+  r = -1 + nIsZero(h) + 2*nGreaterZero(h);   /* -1: <, 0:==, 1: > */
+  nDelete(&h);
+  return(r);
+}
+
+/*
+* compare a and b (rev-lex on terms)
+*/
+static int pCompare(const poly a, const poly b)
+{
+  int r = tCompare(a, b);
+  if (r != 0) return(r);
+
+  poly aa = a;
+  poly bb = b;
+  while (r == 0 && aa != NULL && bb != NULL)
+  {
+    pIter(aa);
+    pIter(bb);
+    r = tCompare(aa, bb);
+  }
+  return(r);
+}
+
+typedef struct
+{
+  poly p;
+  int index;
+} poly_sort;
+
+int pCompare_qsort(const void *a, const void *b)
+{
+  int res = pCompare(((poly_sort *)a)->p, ((poly_sort *)b)->p);
+  return(res);
+}
+
+void idSort_qsort(poly_sort *id_sort, int idsize)
+{
+  qsort(id_sort, idsize, sizeof(poly_sort), pCompare_qsort);
+}
+
+/*2
+* ideal id = (id[i])
+* if id[i] = id[j] then id[j] is deleted for j > i
+*/
+void idDelEquals(ideal id)
+{
+  int idsize = IDELEMS(id);
+  poly_sort *id_sort = (poly_sort *)omAlloc0(idsize*sizeof(poly_sort));
+  for (int i = 0; i < idsize; i++)
+  {
+    id_sort[i].p = id->m[i];
+    id_sort[i].index = i;
+  }
+  idSort_qsort(id_sort, idsize);
+  int index, index_i, index_j;
+  int i = 0;
+  for (int j = 1; j < idsize; j++)
+  {
+    if (id_sort[i].p != NULL && pEqualPolys(id_sort[i].p, id_sort[j].p))
+    {
+      index_i = id_sort[i].index;
+      index_j = id_sort[j].index;
+      if (index_j > index_i)
+      {
+        index = index_j;
+      }
+      else
+      {
+        index = index_i;
+        i = j;
+      }
+      pDelete(&id->m[index]);
+    }
+    else
+    {
+      i = j;
+    }
+  }
+  omFreeSize((ADDRESS)(id_sort), idsize*sizeof(poly_sort));
+}

kernel/ideals.h

@@ -24 +24 @@
 }
 
+void idKeepFirstK(ideal ide, const int k);
+void idDelEquals(ideal id);
+
 /// delete an ideal
 inline void idDelete (ideal* h, ring r = currRing)