Changeset c1a0fc in git

Timestamp:

Oct 23, 2018, 10:30:45 AM (6 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'b4f17ed1d25f93d46dbe29e4b499baecc2fd51bb')

Children:

3e40698da5deaf816542e4d0e16cd3a7e99e4145

Parents:

bf2a471a7ccc420f3cf5a55dd1454967b35fd6234ab28ee27b200665a3b67d61dddfca2c136e0552

git-author:

Hans Schoenemann <hannes@mathematik.uni-kl.de>2018-10-23 10:30:45+02:00

git-committer:

GitHub <noreply@github.com>2018-10-23 10:30:45+02:00

Message:

Merge pull request #886 from kabouzeid/invalid-lp-warnings

Warn when invalid letterplace polynom is printed

Files:

• kernel/GBEngine/kstd2.cc (modified) (2 diffs)
• kernel/GBEngine/kutil.cc (modified) (2 diffs)
• kernel/GBEngine/shiftgb.cc (modified) (1 diff)
• kernel/GBEngine/shiftgb.h (modified) (1 diff)
• libpolys/polys/polys0.cc (modified) (2 diffs)
• libpolys/polys/shiftop.cc (modified) (2 diffs)
• libpolys/polys/shiftop.h (modified) (1 diff)

kernel/GBEngine/kstd2.cc

@@ -74 +74 @@
 // #include "timer.h"
 
-/* shiftgb stuff */
-#include "kernel/GBEngine/shiftgb.h"
+#ifdef HAVE_SHIFTBBA
+#include "polys/shiftop.h"
+#endif
 
   int (*test_PosInT)(const TSet T,const int tl,LObject &h);
@@ -4334 +4335 @@
 {
   assume(rIsLPRing(currRing));
-  assume(ideal_isInV(I, currRing));
+  assume(idIsInV(I));
   ideal RS = kStdShift(I,NULL, testHomog, NULL,NULL,0,0,NULL);
   idSkipZeroes(RS); // is this even necessary?
-  assume(ideal_isInV(RS, currRing));
+  assume(idIsInV(RS));
   return(RS);
 }

kernel/GBEngine/kutil.cc

@@ -66 +66 @@
 #include "polys/operations/pShallowCopyDelete.h"
 
-/* shiftgb stuff */
-#include "kernel/GBEngine/shiftgb.h"
+#ifdef HAVE_SHIFTBBA
+#include "polys/shiftop.h"
+#endif
+
 #include "polys/prCopy.h"
 
@@ -12163 +12165 @@
 
   /* apply the V criterion */
-  if (!isInV(Lp.lcm, currRing))
+  if (!pIsInV(Lp.lcm))
   {
 #ifdef KDEBUG

kernel/GBEngine/shiftgb.cc

@@ -43 +43 @@
 }
 
-/* there should be two routines: */
-/* 1. test place-squarefreeness: in homog this suffices: isInV */
-/* 2. test the presence of a hole -> in the tail??? */
-
-int isInV(poly p, const ring r)
-{
-  int lV = r->isLPring;
-  /* investigate only the leading monomial of p in currRing */
-  if ( pTotaldegree(p)==0 ) return(1);
-  /* returns 1 iff p is in V */
-  /* that is in each block up to a certain one there is only one nonzero exponent */
-  /* lV = the length of V = the number of orig vars */
-  int *e = (int *)omAlloc0((currRing->N+1)*sizeof(int));
-  int  b = (int)((currRing->N +lV-1)/lV); /* the number of blocks */
-  //int b  = (int)(currRing->N)/lV;
-  int *B = (int *)omAlloc0((b+1)*sizeof(int)); /* the num of elements in a block */
-  p_GetExpV(p,e,currRing);
-  int i,j;
-  for (j=1; j<=b; j++)
-  {
-    /* we go through all the vars */
-    /* by blocks in lV vars */
-    for (i=(j-1)*lV + 1; i<= j*lV; i++)
-    {
-      if (e[i]) B[j] = B[j]+1;
-    }
-  }
-  //  j = b;
-  //  while ( (!B[j]) && (j>=1)) j--;
-  for (j=b; j>=1; j--)
-  {
-    if (B[j]!=0) break;
-  }
-  /* do not need e anymore */
-  omFreeSize((ADDRESS) e, (currRing->N+1)*sizeof(int));
-
-  if (j==0) goto ret_true;
-//   {
-//     /* it is a zero exp vector, which is in V */
-//     freeT(B, b);
-//     return(1);
-//   }
-  /* now B[j] != 0 and we test place-squarefreeness */
-  for (; j>=1; j--)
-  {
-    if (B[j]!=1)
-    {
-      omFreeSize((ADDRESS) B, (b+1)*sizeof(int));
-      return(0);
-    }
-  }
- ret_true:
-  omFreeSize((ADDRESS) B, (b+1)*sizeof(int));
-  return(1);
-}
-
-/* tests whether the whole polynomial p in in V */
-int poly_isInV(poly p, const ring r)
-{
-  poly q = p;
-  while (q!=NULL)
-  {
-    if ( !isInV(q, r) )
-    {
-      return(0);
-    }
-    q = pNext(q);
-  }
-  return(1);
-}
-
-/* tests whether each polynomial of an ideal I lies in in V */
-int ideal_isInV(ideal I, const ring r)
-{
-  int i;
-  int s    = IDELEMS(I)-1;
-  for(i = 0; i <= s; i++)
-  {
-    if ( !poly_isInV(I->m[i], r) )
-    {
-      return(0);
-    }
-  }
-  return(1);
-}
-
-
 /* for poly in lmCR/tailTR presentation */
 int itoInsert(poly p, const ring r)

kernel/GBEngine/shiftgb.h

@@ -15 +15 @@
 #define pLPCopyAndShiftLM(p, sh) p_LPCopyAndShiftLM(p, sh, currRing)
 
-int isInV(poly p, const ring r);
-int poly_isInV(poly p, const ring r);
-int ideal_isInV(ideal I, const ring r);
-
 int itoInsert(poly p, const ring r);
 

libpolys/polys/polys0.cc

@@ -14 +14 @@
 #include "polys/monomials/ring.h"
 #include "polys/monomials/p_polys.h"
+#ifdef HAVE_SHIFTBBA
+#include "polys/shiftop.h"
+#endif
 
 /*2
@@ -24 +27 @@
   const coeffs C = r->cf;
   assume(C != NULL);
+
+#ifdef HAVE_SHIFTBBA
+  if (r->isLPring)
+  {
+    if (!p_mIsInV(p, r))
+    {
+      /*
+      * the monomial is not a valid letterplace monomial
+      * without this warning one cannot distinguish between
+      * x(1)*x(3) and x(1)*x(2) because they would both be displayed
+      * as x*x
+      */
+      int *expV = (int *) omAlloc((r->N+1)*sizeof(int));
+      p_GetExpV(p, expV, r);
+      char* s = LPExpVString(expV, r);
+      Warn("invalid letterplace monomial: (%s)", s);
+      omFreeSize((ADDRESS) expV, (r->N+1)*sizeof(int));
+      omFree(s);
+    }
+  }
+#endif
 
   BOOLEAN wroteCoef=FALSE,writeGen=FALSE;

libpolys/polys/shiftop.cc

@@ -5 +5 @@
 #include "templates/p_MemCopy.h"
 #include "monomials/p_polys.h"
+#include "polys/simpleideals.h"
 
 /* #define SHIFT_MULT_DEBUG */
@@ -551 +552 @@
 void WriteLPExpV(int *expV, ring ri)
 {
+  char *s = LPExpVString(expV, ri);
+  PrintS(s);
+  omFree(s);
+}
+
+char* LPExpVString(int *expV, ring ri)
+{
+  StringSetS("");
   for (int i = 0; i <= ri->N; ++i)
   {
-    Print("%d", expV[i]);
+    StringAppend("%d", expV[i]);
     if (i == 0)
     {
-      Print("| ");
+      StringAppendS("| ");
     }
     if (i % ri->isLPring == 0)
     {
-      Print(" ");
-    }
-  }
-}
-
-#endif
+      StringAppendS(" ");
+    }
+  }
+  return StringEndS();
+}
+
+/* tests whether each polynomial of an ideal I lies in in V */
+int id_IsInV(ideal I, const ring r)
+{
+  int i;
+  int s    = IDELEMS(I)-1;
+  for(i = 0; i <= s; i++)
+  {
+    if ( !p_IsInV(I->m[i], r) )
+    {
+      return(0);
+    }
+  }
+  return(1);
+}
+
+/* tests whether the whole polynomial p in in V */
+int p_IsInV(poly p, const ring r)
+{
+  poly q = p;
+  while (q!=NULL)
+  {
+    if ( !p_mIsInV(q, r) )
+    {
+      return(0);
+    }
+    q = pNext(q);
+  }
+  return(1);
+}
+
+/* there should be two routines: */
+/* 1. test place-squarefreeness: in homog this suffices: isInV */
+/* 2. test the presence of a hole -> in the tail??? */
+
+int p_mIsInV(poly p, const ring r)
+{
+  int lV = r->isLPring;
+  /* investigate only the leading monomial of p in currRing */
+  if ( p_Totaldegree(p, r)==0 ) return(1);
+  /* returns 1 iff p is in V */
+  /* that is in each block up to a certain one there is only one nonzero exponent */
+  /* lV = the length of V = the number of orig vars */
+  int *e = (int *)omAlloc0((r->N+1)*sizeof(int));
+  int  b = (int)((r->N+lV-1)/lV); /* the number of blocks */
+  //int b  = (int)(currRing->N)/lV;
+  int *B = (int *)omAlloc0((b+1)*sizeof(int)); /* the num of elements in a block */
+  p_GetExpV(p,e,r);
+  int i,j;
+  for (j=1; j<=b; j++)
+  {
+    /* we go through all the vars */
+    /* by blocks in lV vars */
+    for (i=(j-1)*lV + 1; i<= j*lV; i++)
+    {
+      if (e[i]) B[j] = B[j]+1;
+    }
+  }
+  //  j = b;
+  //  while ( (!B[j]) && (j>=1)) j--;
+  for (j=b; j>=1; j--)
+  {
+    if (B[j]!=0) break;
+  }
+  /* do not need e anymore */
+  omFreeSize((ADDRESS) e, (r->N+1)*sizeof(int));
+
+  if (j==0) goto ret_true;
+//   {
+//     /* it is a zero exp vector, which is in V */
+//     freeT(B, b);
+//     return(1);
+//   }
+  /* now B[j] != 0 and we test place-squarefreeness */
+  for (; j>=1; j--)
+  {
+    if (B[j]!=1)
+    {
+      omFreeSize((ADDRESS) B, (b+1)*sizeof(int));
+      return(0);
+    }
+  }
+ ret_true:
+  omFreeSize((ADDRESS) B, (b+1)*sizeof(int));
+  return(1);
+}
+
+#endif

libpolys/polys/shiftop.h

@@ -39 +39 @@
 
 void WriteLPExpV(int *expV, ring ri);
+char* LPExpVString(int *expV, ring ri);
+
+int id_IsInV(ideal I, const ring r);
+int p_IsInV(poly p, const ring r);
+int p_mIsInV(poly p, const ring r);
+#define idIsInV(I) id_IsInV(I, currRing)
+#define pIsInV(p) p_IsInV(p, currRing)
+#define pmIsInV(p) p_mIsInV(p, currRing)
 
 #endif