Changeset 14e93b in git for Singular/LIB/schreyer.lib

Timestamp:

Jun 14, 2012, 10:18:24 PM (12 years ago)

Author:

Oleksandr Motsak <motsak@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

ff7993e279b46dbac09bfb1762c976061c50eb24

Parents:

2c16b81352589f222e0e327ed8ce64db62736728

git-author:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2012-06-14 22:18:24+02:00

git-committer:

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

Message:

moved the main driver function ComputeSyzygy to the dyn.module

TODO: preprocessing

File:

• Singular/LIB/schreyer.lib (modified) (3 diffs)

Singular/LIB/schreyer.lib

@@ -1578 +1578 @@
   }
 
-  def a; bigint c; int r, k; poly aa;
-
-  int @LEAD2SYZ = 0;
-  if( typeof( attrib(basering, "LEAD2SYZ") ) == "int" )
-  {
-    @LEAD2SYZ = attrib(basering, "LEAD2SYZ");
-  }
-
-  int @TAILREDSYZ = 1;
-  if( typeof( attrib(basering, "TAILREDSYZ") ) == "int" )
-  {
-    @TAILREDSYZ = attrib(basering, "TAILREDSYZ");
-  }
-
-  int @HYBRIDNF = 0;
-  if( typeof( attrib(basering, "HYBRIDNF") ) == "int" )
-  {
-    @HYBRIDNF = attrib(basering, "HYBRIDNF");
-  }
-
-  module LL;
-  def a2; int r2; poly aa2;  
-
-  /// Get the critical leading syzygy terms
-  if( @LEAD2SYZ ) // & 2nd syz. term
-  {
-    module LL2;
-    (LL, LL2) = SSCompute2LeadingSyzygyTerms(L); // ++ 
-  } else
-  {
-    LL = SSComputeLeadingSyzygyTerms(L);
-  }
-
-  module TT, SYZ; def spoly;
-
-  if( size(LL) > 0 )
-  {
-    list LS;
-
-    if( @TAILREDSYZ)
-    {
-      LS = list(LL);
-    }
-
-    vector @tail;
-
-    for(k = ncols(LL); k > 0; k-- )
-    {
-      // leading syz. term:
-      a = LL[k]; c = leadcomp(a); r = int(c); aa = leadmonomial(a);
-      //    "A: ", a, " --->>>> ", aa, " **** [", r, "]: ";
-
-      // NF reduction:
-      if( !@HYBRIDNF )
+  list @res = ComputeSyzygy(L, T); 
+
+  module @LL = @res[1]; module @TT = @res[2];
+
+  if( @KERCHECK )
+  {
+    if( typeof( attrib(basering, "SYZCHECK") ) == "int" )
+    {
+      int @SYZCHECK = attrib(basering, "SYZCHECK");
+    } else
+    {
+      int @SYZCHECK = @DEBUG;
+    }
+
+    int @LEAD2SYZ = 1;
+    if( typeof( attrib(basering, "LEAD2SYZ") ) == "int" )
+    {
+      @LEAD2SYZ = attrib(basering, "LEAD2SYZ");
+    }
+
+    int @TAILREDSYZ = 1;
+    if( typeof( attrib(basering, "TAILREDSYZ") ) == "int" )
+    {
+      @TAILREDSYZ = attrib(basering, "TAILREDSYZ");
+    }
+
+    int @HYBRIDNF = 0;
+    if( typeof( attrib(basering, "HYBRIDNF") ) == "int" )
+    {
+      @HYBRIDNF = attrib(basering, "HYBRIDNF");
+    }
+
+    module LL;
+
+    /// Get the critical leading syzygy terms
+    if( @LEAD2SYZ ) // & 2nd syz. term
+    {
+      module LL2;
+      (LL, LL2) = SSCompute2LeadingSyzygyTerms(L); 
+    } else
+    {
+      LL = SSComputeLeadingSyzygyTerms(L);
+    }
+
+    module TT, SYZ;
+
+    vector a, a2; bigint c; int r; poly aa;
+
+    if( size(LL) > 0 )
+    {
+      list LS;
+
+      if( @TAILREDSYZ)
       {
-        /// TODO: save shortcut (aa) * T[r] -> ?
-        @tail = SSTraverseTail(aa, T[r], L, T, LS);
-  // //      @tail = SSTraverseTail(a, L, T, LS);
-
-        // get the 2nd syzygy term...
-
-        if( @LEAD2SYZ ) // with the 2nd syz. term:
-        {      
-          a2 = LL2[k]; c = leadcomp(a2); r2 = int(c); aa2 = leadmonomial(a2);
-
-          @tail = @tail + a2 + 
-               /// TODO: save shortcut (aa2) * T[r2] -> ?
-               SSTraverseTail(aa2, T[r2], L, T, LS);
-  // //               SSTraverseTail(a2, L, T, LS);
-        } else
+        LS = list(LL);
+      }
+
+      vector @tail;
+
+      for(int k = ncols(LL); k > 0; k-- )
+      {
+        // leading syz. term:
+        a = LL[k]; c = leadcomp(a); r = int(c); aa = leadmonomial(a);
+
+        // NF reduction:
+        if( !@HYBRIDNF ) // Traverse approach:
+        {        
+          @tail = SSTraverseTail(aa, T[r], L, T, LS);
+
+          // get the 2nd syzygy term...
+          if( @LEAD2SYZ ) // with the 2nd syz. term:
+          {      
+            a2 = LL2[k]; c = leadcomp(a2); r = int(c); aa = leadmonomial(a2);
+
+            @tail = a2 + @tail + SSTraverseTail(aa, T[r], L, T, LS);
+          } else
+          {
+            @tail = @tail + SSReduceTerm(aa, L[r], a, L, T, LS);
+          }
+
+        } else // Hybrid approach:
         {
-          @tail = @tail +
-                  SSReduceTerm(aa, L[r], a, L, T, LS);
-  // //                  SSReduceTerm(a, L, T, LS);
+
+          // get the 2nd syzygy term...
+          if( @LEAD2SYZ )
+          {
+            a2 = LL2[k];
+          } else
+          {
+            a2 = SSFindReducer( aa * L[r], a, L, LS);
+          }
+
+          if ( (@SYZCHECK || @DEBUG) )
+          {
+            if( size(a2) == 0 ) // if syzterm == 0!!!!
+            {
+              "ERROR in SSComputeSyzygy: could not find the 2nd syzygy term during the hybrid NF!!!";
+              $
+            }
+          }
+
+          @tail = SSSchreyerSyzygyNF(a, a2, L, T, LS);
         }
-      } else
-      {
-        if( @LEAD2SYZ )
-        {
-          a2 = LL2[k];
-        } else
-        {
-          a2 = SSFindReducer( aa * L[r], a, L, LS);
-        }
-
-        if ( (@SYZCHECK || @DEBUG) )
-        {
-          if( size(a2) == 0 ) // if syzterm == 0!!!!
-          {
-            "ERROR: could not find the 2nd syzygy term during the hybrid NF!!!";
-            $
-          }
-        }
-
-        @tail = SSSchreyerSyzygyNF(a, a2, L, T, LS);
+
+        TT[k] = @tail;
+        SYZ[k] = a + @tail;
       }
-      
-      TT[k] = @tail;
-      SYZ[k] = a + @tail;
-    }
-  }
-
+    }
+
+    if( ncols(LL) != ncols(@LL) )
+    {
+      "ERROR in SSComputeSyzygy: wrong leading syzygies!?";
+      "";
+      L; T;
+      "";
+      type(LL);
+      type(@LL);
+      $
+    }
+
+    if( ncols(TT) != ncols(@TT) )
+    {
+      "ERROR in SSComputeSyzygy: wrong tail syzygies!?";
+      "";
+      L; T;
+      "";
+      type(LL);
+      type(@LL);
+      "";
+      type(TT);
+      type(@TT);
+      $
+    }
+    
+    if( size( module( matrix(LL) - matrix(@LL) ) ) != 0 )
+    {
+      "ERROR in SSComputeSyzygy: wrong leading syzygies!?";
+      "";
+      L; T;
+      "";
+      type(LL);
+      type(@LL);
+      $
+    }
+
+
+    if( size( module( matrix(TT) - matrix(@TT) ) ) != 0 )
+    {
+      "ERROR in SSComputeSyzygy: wrong tail syzygies!?";
+      TT; @TT;
+      L; T;
+      $
+    }   
+    
+  }
+
+  module @SYZ;
+  
+  for(int @k = ncols(@LL); @k > 0; @k-- )
+  {
+    @SYZ[@k] = @LL[@k] + @TT[@k];
+  }
+  
   if( @DEBUG )
   {
     "SSComputeSyzygy::Output";
 
-    "SYZ: "; SYZ;
-    "LL: "; LL;
-    "TT: "; TT;
-  }
-
-  return (SYZ, LL, TT);
+//    "SYZ: "; @SYZ;
+    "LL: "; @LL;
+    "TT: "; @TT;
+  }
+
+  return (@SYZ, @LL, @TT);
 }
 
@@ -2050 +2111 @@
 
       exportto(Schreyer, Syzextra::SchreyerSyzygyNF);
+      exportto(Schreyer, Syzextra::ComputeSyzygy);
     }
 /*
@@ -2101 +2163 @@
 
       exportto(Schreyer, Syzextra_g::SchreyerSyzygyNF);
+      exportto(Schreyer, Syzextra_g::ComputeSyzygy);
     }
 */