Changeset 74afe1f in git

Timestamp:

May 23, 2012, 8:26:06 PM (12 years ago)

Author:

Oleksandr Motsak <motsak@…>

Branches:

(u'spielwiese', '17f1d200f27c5bd38f5dfc6e8a0879242279d1d8')

Children:

8e650e4e942e4e3510a0d6fddf77ac0f30d32fb5

Parents:

5020a60f5779ffc1406febfaaefb86db176ddc13

git-author:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2012-05-23 20:26:06+02:00

git-committer:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2014-05-07 04:41:43+02:00

Message:

moved 'Compute2LeadingSyzygyTerms' into the dyn.mod.

TODO/TEST: interred & tailred

Files:

• Singular/LIB/schreyer.lib (modified) (8 diffs)
• dyn_modules/syzextra/mod_main.cc (modified) (7 diffs)

Singular/LIB/schreyer.lib

@@ -703 +703 @@
   
 //  attrib(S, "InducionStart", @RANK);
-  attrib(S, "LEAD2SYZ", 0);
+  attrib(S, "LEAD2SYZ", 1);
   attrib(S, "TAILREDSYZ", 1);
   attrib(S, "DEBUG", @DEBUG);
@@ -857 +857 @@
 
 /// Compute Syz(L), where L is a monomial (leading) module
-proc SSCompute2LeadingSyzygyTerms(def L, int @TAILREDSYZ)
+proc SSCompute2LeadingSyzygyTerms(def L)
 {
   if( typeof( attrib(basering, "DEBUG") ) == "int" )
@@ -874 +874 @@
     int @SYZCHECK = @DEBUG;
   }
+
+  int @TAILREDSYZ = 1;
+  if( typeof( attrib(basering, "TAILREDSYZ") ) == "int" )
+  {
+    @TAILREDSYZ = attrib(basering, "TAILREDSYZ");
+  }
+  
   
   if( @DEBUG )
@@ -879 +886 @@
     "SSCompute2LeadingSyzygyTerms::Input: ";
     L;
-    "@TAILREDSYZ: ", @TAILREDSYZ;
   }
 
@@ -956 +962 @@
       }
     }
-  }
+    
+    module SS = Compute2LeadingSyzygyTerms(L);
+
+    "S: ";  DetailedPrint(S);
+    "SS: "; DetailedPrint(SS);
+    
+    if( size(module(matrix(S) - matrix(SS))) > 0 )
+    {
+      "ERROR: S != SS ";
+
+      "basering: ";
+      DetailedPrint(basering);
+
+      "S: ";  S;
+      DetailedPrint(S, 2);
+      "SS: "; SS;
+      DetailedPrint(SS, 2);
+
+      "DIFF: ";
+      print(matrix(S) - matrix(SS));
+      DetailedPrint(module(matrix(S) - matrix(SS)), 4);
+      $
+    }
+    
+  }  
 
   module S2 = Tail(S);
@@ -1146 +1176 @@
     def a2; int r2; poly aa2;  
     module LL, LL2;
-    (LL, LL2) = SSCompute2LeadingSyzygyTerms(L, @TAILREDSYZ); // ++ 
+    (LL, LL2) = SSCompute2LeadingSyzygyTerms(L); // ++ 
   } else
   {
@@ -1562 +1592 @@
       exportto(Schreyer, Syzextra::Tail);
       exportto(Schreyer, Syzextra::ComputeLeadingSyzygyTerms);      
+      exportto(Schreyer, Syzextra::Compute2LeadingSyzygyTerms);
       exportto(Schreyer, Syzextra::Sort_c_ds);
     }
@@ -1605 +1636 @@
       exportto(Schreyer, Syzextra_g::Tail);
       exportto(Schreyer, Syzextra_g::ComputeLeadingSyzygyTerms);
+      exportto(Schreyer, Syzextra_g::Compute2LeadingSyzygyTerms);
       exportto(Schreyer, Syzextra_g::Sort_c_ds);
       

dyn_modules/syzextra/mod_main.cc

@@ -8 +8 @@
 
 #include <misc/intvec.h>
+#include <misc/options.h>
 
 #include <coeffs/coeffs.h>
@@ -531 +532 @@
   const poly b = *(const poly*)p2;
 
+  assume( a != NULL );
+  assume( b != NULL );
+  
   assume( p_LmTest(a, r) );
   assume( p_LmTest(b, r) );
@@ -629 +633 @@
       const BOOLEAN __LEAD2SYZ__ = (BOOLEAN)((long)(atGet(currRingHdl,"LEAD2SYZ",INT_CMD, (void*)0)));
       const BOOLEAN __TAILREDSYZ__ = (BOOLEAN)((long)(atGet(currRingHdl,"TAILREDSYZ",INT_CMD, (void*)0)));
-      const BOOLEAN __SYZCHECK__ = (BOOLEAN)((long)(atGet(currRingHdl,"SYZCHECK",INT_CMD, (void*)0)));   
+      const BOOLEAN __SYZCHECK__ = (BOOLEAN)((long)(atGet(currRingHdl,"SYZCHECK",INT_CMD, (void*)0)));
+
 
       Print("\nSYZCHECK: \t%d", __SYZCHECK__);
@@ -637 +642 @@
 
       dPrint(id, r, r, 1);
+
+      assume( !__LEAD2SYZ__ );
     }
 
@@ -747 +754 @@
     if( sizeNew >= 2 )
       qsort_r(newid->m, sizeNew, sizeof(poly), cmp_c_ds, r);
+
+    if (IDELEMS(newid) == 0 || (IDELEMS(newid) == 1 && newid->m[0] == NULL) )
+      newid->rank = 1;    
     
     // TODO: add sorting wrt <c,ds> & reversing...
@@ -836 +846 @@
 }
 
+
+
+static BOOLEAN Compute2LeadingSyzygyTerms(leftv res, leftv h)
+{
+  const ring r = currRing;
+  NoReturn(res);
+
+  if( h == NULL )
+  {
+    WarnS("Compute2LeadingSyzygyTerms needs an argument...");
+    return TRUE;
+  }
+
+  assume( h != NULL );  
+
+#ifndef NDEBUG
+  const BOOLEAN __DEBUG__ = (BOOLEAN)((long)(atGet(currRingHdl,"DEBUG",INT_CMD, (void*)TRUE)));
+#else
+  const BOOLEAN __DEBUG__ = (BOOLEAN)((long)(atGet(currRingHdl,"DEBUG",INT_CMD, (void*)FALSE)));
+#endif
+
+  const BOOLEAN __TAILREDSYZ__ = (BOOLEAN)((long)(atGet(currRingHdl,"TAILREDSYZ",INT_CMD, (void*)0)));
+  const BOOLEAN __LEAD2SYZ__ = (BOOLEAN)((long)(atGet(currRingHdl,"LEAD2SYZ",INT_CMD, (void*)0)));
+  const BOOLEAN __SYZCHECK__ = (BOOLEAN)((long)(atGet(currRingHdl,"SYZCHECK",INT_CMD, (void*)0)));   
+
+
+  assume( __LEAD2SYZ__ );
+  
+  if( h->Typ() == IDEAL_CMD || h->Typ() == MODUL_CMD)
+  {
+    const ideal id = (const ideal)h->Data();
+
+    assume(id != NULL);
+
+    if( __DEBUG__ )
+    {
+      PrintS("Compute2LeadingSyzygyTerms::Input: \n");
+
+      Print("\nSYZCHECK: \t%d", __SYZCHECK__);
+      Print(", DEBUG: \t%d", __DEBUG__);
+      Print(", LEAD2SYZ: \t%d", __LEAD2SYZ__);
+      Print(", TAILREDSYZ: \t%d\n", __TAILREDSYZ__);
+
+      dPrint(id, r, r, 1);
+    }
+
+    h = h->Next(); assume (h == NULL);
+
+    // 1. set of components S?
+    // 2. for each component c from S: set of indices of leading terms
+    // with this component?
+    // 3. short exp. vectors for each leading term?
+
+    const int size = IDELEMS(id);
+
+    if( size < 2 )
+    {
+      const ideal newid = idInit(1, 1); // zero module...
+
+      newid->m[0] = NULL;
+
+      res->data = newid;
+      res->rtyp = MODUL_CMD;
+
+      return FALSE;
+    }
+
+
+    // TODO/NOTE: input is supposed to be sorted wrt "C,ds"!??
+
+    // components should come in groups: count elements in each group
+    // && estimate the real size!!!
+
+
+    // use just a vector instead???
+    ideal newid = idInit( (size * (size-1))/2, size); // maximal size: ideal case!
+
+    int k = 0;
+
+    for (int j = 0; j < size; j++)
+    {
+      const poly p = id->m[j];
+      assume( p != NULL );
+      const int  c = p_GetComp(p, r);
+
+      for (int i = j - 1; i >= 0; i--)
+      {
+        const poly pp = id->m[i];
+        assume( pp != NULL );
+        const int  cc = p_GetComp(pp, r);
+
+        if( c != cc )
+          continue;
+
+        // allocate memory & zero it out!
+        const poly m = p_Init(r); const poly mm = p_Init(r);
+        
+
+        // m = LCM(p, pp) / p! mm = LCM(p, pp) / pp!
+        // TODO: optimize: knowing the ring structure: (C/lp)!
+        
+        for (int v = rVar(r); v > 0; v--)
+        {
+          assume( v > 0 );
+          assume( v <= rVar(r) );
+
+          const short e1 = p_GetExp(p , v, r);
+          const short e2 = p_GetExp(pp, v, r);
+
+          if( e1 >= e2 )
+            p_SetExp(mm, v, e1 - e2, r); //            p_SetExp(m, v, 0, r);
+          else
+            p_SetExp(m, v, e2 - e1, r); //            p_SetExp(mm, v, 0, r);
+
+        }
+
+        assume( (j > i) && (i >= 0) );
+
+        p_SetComp(m, j + 1, r);
+        p_SetComp(mm, i + 1, r);
+        
+        const number& lc1 = p_GetCoeff(p , r);
+        const number& lc2 = p_GetCoeff(pp, r);
+
+        number g = n_Lcm( lc1, lc2, r );
+
+        p_SetCoeff0(m ,       n_Div(g, lc1, r), r);
+        p_SetCoeff0(mm, n_Neg(n_Div(g, lc2, r), r), r);
+
+        n_Delete(&g, r);
+
+        p_Setm(m, r); // should not do anything!!!
+        p_Setm(mm, r); // should not do anything!!!
+
+        pNext(m) = mm; //        pNext(mm) = NULL;
+        
+        newid->m[k++] = m;
+      }
+    }
+
+    if( __DEBUG__ && FALSE )
+    {
+      PrintS("Compute2LeadingSyzygyTerms::Temp0: \n");
+      dPrint(newid, r, r, 1);
+    }
+
+    if( !__TAILREDSYZ__ )
+    {
+      // simplify(newid, 2 + 32)??
+      // sort(newid, "C,ds")[1]???
+      id_DelDiv(newid, r); // #define SIMPL_LMDIV 32
+
+      if( __DEBUG__ && FALSE )
+      {
+        PrintS("Compute2LeadingSyzygyTerms::Temp1 (deldiv): \n");
+        dPrint(newid, r, r, 1);
+      }
+    }
+    else
+    {
+      //      option(redSB); option(redTail);
+      //      TEST_OPT_REDSB
+      //      TEST_OPT_REDTAIL
+      assume( r == currRing );
+      BITSET _save_test = test;
+      test |= (Sy_bit(OPT_REDTAIL) | Sy_bit(OPT_REDSB));
+
+      intvec* w=new intvec(IDELEMS(newid));
+      ideal tmp = kStd(newid, currQuotient, isHomog, &w);
+      delete w;
+      
+      test = _save_test;
+      
+      id_Delete(&newid, r);
+      newid = tmp;
+
+      if( __DEBUG__ && FALSE )
+      {
+        PrintS("Compute2LeadingSyzygyTerms::Temp1 (std): \n");
+        dPrint(newid, r, r, 1);
+      }
+      
+    }
+
+    idSkipZeroes(newid);
+
+    const int sizeNew = IDELEMS(newid);
+
+    if( sizeNew >= 2 )
+      qsort_r(newid->m, sizeNew, sizeof(poly), cmp_c_ds, r);
+
+    if (IDELEMS(newid) == 0 || (IDELEMS(newid) == 1 && newid->m[0] == NULL) )
+      newid->rank = 1;
+
+    // TODO: add sorting wrt <c,ds> & reversing...
+
+    res->data = newid;
+    res->rtyp = MODUL_CMD;
+
+    return FALSE;
+  }
+
+  WarnS("Compute2LeadingSyzygyTerms needs a single ideal/module argument...");
+  return TRUE;
+}
 
 
@@ -1484 +1699 @@
 
   ADD(psModulFunctions, currPack->libname, "Tail", FALSE, Tail);
+  
   ADD(psModulFunctions, currPack->libname, "ComputeLeadingSyzygyTerms", FALSE, ComputeLeadingSyzygyTerms);
+  ADD(psModulFunctions, currPack->libname, "Compute2LeadingSyzygyTerms", FALSE, Compute2LeadingSyzygyTerms);
+  
   ADD(psModulFunctions, currPack->libname, "Sort_c_ds", FALSE, Sort_c_ds);