Changeset 7088f18 in git

Timestamp:

Jul 9, 2012, 9:34:12 PM (12 years ago)

Author:

Oleksandr Motsak <motsak@…>

Branches:

(u'spielwiese', '6e5adcba05493683b94648c659a729c189812c77')

Children:

92992c08c2f387188f53d5f874a342fb60dccc06

Parents:

20409220dfe91ce9647c6b8d12e43f086961aa14

git-author:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2012-07-09 21:34:12+02:00

git-committer:

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

Message:

Old Schreyer Syzygy functions went to a namespace accesed via a class + wrappers & moved internal declarations to syzextra.cc

Location:

dyn_modules/syzextra

Files:

• syzextra.cc (modified) (3 diffs)
• syzextra.h (modified) (1 diff)

dyn_modules/syzextra/syzextra.cc

@@ -56 +56 @@
 BEGIN_NAMESPACE_SINGULARXX     BEGIN_NAMESPACE(SYZEXTRA)
 
+
 BEGIN_NAMESPACE(SORT_c_ds)
 
@@ -223 +224 @@
 
 
+BEGIN_NAMESPACE(INTERNAL)
 
 ideal ComputeLeadingSyzygyTerms(const ideal& id, const ring r)
@@ -791 +793 @@
 }
 
-
-
-
-
-
+END_NAMESPACE
+
+
+void SchreyerSyzygyComputation::ComputeSyzygy()
+{
+  /// assumes m_syzLeads == m_syzTails == NULL!
+  INTERNAL::ComputeSyzygy(m_idLeads, m_idTails, m_syzLeads, m_syzTails, m_rBaseRing); // TODO: just a wrapper for now :/
+}
+
+void SchreyerSyzygyComputation::ComputeLeadingSyzygyTerms(bool bComputeSecondTerms)
+{
+  if( bComputeSecondTerms )
+    m_syzLeads = INTERNAL::Compute2LeadingSyzygyTerms(m_idLeads, m_rBaseRing);
+  else
+    m_syzLeads = INTERNAL::ComputeLeadingSyzygyTerms(m_idLeads, m_rBaseRing);
+  
+  // NOTE: set m_LS if tails are to be reduced!
+}
+
+poly SchreyerSyzygyComputation::FindReducer(poly product, poly syzterm)
+{
+  return INTERNAL::FindReducer(product, syzterm, m_idLeads, m_LS, m_rBaseRing);
+}
+
+poly SchreyerSyzygyComputation::SchreyerSyzygyNF(poly syz_lead, poly syz_2)
+{
+  return INTERNAL::SchreyerSyzygyNF(syz_lead, syz_2, m_idLeads, m_idTails, m_LS, m_rBaseRing);
+}
+
+poly SchreyerSyzygyComputation::TraverseTail(poly multiplier, poly tail)
+{
+  return INTERNAL::TraverseTail(multiplier, tail, m_idLeads, m_idTails, m_LS, m_rBaseRing);
+}
+
+poly SchreyerSyzygyComputation::ReduceTerm(poly multiplier, poly term4reduction, poly syztermCheck)
+{
+  return INTERNAL::ReduceTerm(multiplier, term4reduction, syztermCheck, m_idLeads, m_idTails, m_LS, m_rBaseRing);
+}
+
+   
 
 

dyn_modules/syzextra/syzextra.h

@@ -47 +47 @@
 ideal id_Tail(const ideal id, const ring r);
 
-
 /// inplace sorting of the module (ideal) id wrt >_(c,ds)
 void Sort_c_ds(const ideal id, const ring r);
 
-ideal ComputeLeadingSyzygyTerms(const ideal& id, const ring r);
 
-ideal Compute2LeadingSyzygyTerms(const ideal& id, const ring r);
+/** @class SchreyerSyzygyComputation syzextra.h
+ * 
+ * Computing syzygies after Schreyer
+ *
+ * Storing/accumulating data during the computation requires some global
+ * object, like this class. Ideally the above global functions should not
+ * be used in favour of this class.
+ *
+ * @sa Schreyer Syzygy Computation Paper & Talk & Python prototype
+ */
+class SchreyerSyzygyComputation
+{
+  public:
+    /// Construct a global object for given input data (separated into leads & tails)
+    SchreyerSyzygyComputation(const ideal idLeads, const ideal idTails, const ring rBaseRing):
+        m_idLeads(idLeads), m_idTails(idTails), m_rBaseRing(rBaseRing),
+        m_syzLeads(NULL), m_syzTails(NULL), m_LS(NULL) {}
 
 
-poly FindReducer(poly product, poly syzterm,
-                 ideal L, ideal LS,
-                 const ring r);
+    /// Construct a global object for given input data (separated into leads & tails)
+    SchreyerSyzygyComputation(const ideal idLeads, const ideal idTails, const ideal syzLeads, const ring rBaseRing):
+        m_idLeads(idLeads), m_idTails(idTails), m_rBaseRing(rBaseRing),
+        m_syzLeads(NULL), m_syzTails(NULL), m_LS(syzLeads) {}
+
+    
+    /// Destructor should not destruct the resulting m_syzLeads, m_syzTails. 
+    ~SchreyerSyzygyComputation(){ CleanUp(); }
+
+    /// Read off the results while detaching them from this object
+    /// NOTE: no copy!
+    inline void ReadOffResult(ideal& syzL, ideal& syzT)
+    {
+      syzL = m_syzLeads; syzT = m_syzTails; 
+
+      m_syzLeads = m_syzTails = NULL; // m_LS ?
+    }
+    
+    /// The main driver function: computes
+    void ComputeSyzygy();
+
+    /// Computes Syz(leads) or only LEAD of it.
+    /// The result is stored into m_syzLeads
+    void ComputeLeadingSyzygyTerms(bool bComputeSecondTerms = true);
+
+    poly FindReducer(poly product, poly syzterm);
+    poly SchreyerSyzygyNF(poly syz_lead, poly syz_2);
+    poly TraverseTail(poly multiplier, poly tail);
+    poly ReduceTerm(poly multiplier, poly term4reduction, poly syztermCheck);
+
+    
+  protected:
+    
+    /// Clean up all the accumulated data
+    void CleanUp() {}
+
+  private:
+    /// global base ring
+    const ring  m_rBaseRing;
+
+    /// input leading terms
+    const ideal m_idLeads;
+
+    /// input tails
+    const ideal m_idTails;
+
+    /// output (syzygy) leading terms (+2nd terms?)
+    ideal m_syzLeads;
+
+    /// output (syzygy) tails
+    ideal m_syzTails;
+
+    /*mutable?*/ ideal m_LS; ///< leading syzygy terms used for reducing syzygy tails
+};
 
 
-poly TraverseTail(poly multiplier, poly tail, 
-                  ideal L, ideal T, ideal LS,
-                  const ring r);
+// The following wrappers are just for testing separate functions on highest level (within schreyer.lib)
 
-poly ReduceTerm(poly multiplier, poly term4reduction, poly syztermCheck,
-                ideal L, ideal T, ideal LS, const ring r);
+static inline void ComputeSyzygy(const ideal L, const ideal T, ideal& LL, ideal& TT, const ring R)
+{
+  SchreyerSyzygyComputation syz(L, T, R);
+  syz.ComputeSyzygy();
+  syz.ReadOffResult(LL, TT);
+}
+
+static inline ideal ComputeLeadingSyzygyTerms(const ideal& L, const ring R)
+{
+  SchreyerSyzygyComputation syz(L, NULL, R);
+  syz.ComputeLeadingSyzygyTerms(false);
+  ideal LL, TT;
+  syz.ReadOffResult(LL, TT);
+  return LL; // assume TT is NULL!
+}
+
+static inline ideal Compute2LeadingSyzygyTerms(const ideal& L, const ring R)
+{
+  SchreyerSyzygyComputation syz(L, NULL, R);
+  syz.ComputeLeadingSyzygyTerms(true);
+  ideal LL, TT;
+  syz.ReadOffResult(LL, TT);
+  return LL; // assume TT is NULL!
+}
+
+static inline poly FindReducer(poly product, poly syzterm,
+                               ideal L, ideal LS, const ring R)
+{
+  SchreyerSyzygyComputation syz(L, NULL, LS, R);
+  return syz.FindReducer(product, syzterm);
+}
+
+static inline poly TraverseTail(poly multiplier, poly tail, 
+                                ideal L, ideal T, ideal LS, const ring R)
+{
+  SchreyerSyzygyComputation syz(L, T, LS, R);
+  return syz.TraverseTail(multiplier, tail);
+}
+
+static inline poly ReduceTerm(poly multiplier, poly term4reduction, poly syztermCheck,
+                              ideal L, ideal T, ideal LS, const ring R)
+{
+  SchreyerSyzygyComputation syz(L, T, LS, R);
+  return syz.ReduceTerm(multiplier, term4reduction, syztermCheck);
+}
+
+
+static inline poly SchreyerSyzygyNF(poly syz_lead, poly syz_2,
+                                    ideal L, ideal T, ideal LS, const ring R)
+{
+  SchreyerSyzygyComputation syz(L, T, LS, R);
+  return syz.SchreyerSyzygyNF(syz_lead, syz_2);
+}
 
 
 
-poly SchreyerSyzygyNF(poly syz_lead, poly syz_2, ideal L, ideal T, ideal LS, const ring r);
-
-
-void ComputeSyzygy(const ideal L, const ideal T, ideal& LL, ideal& TT, const ring R);
-
-
-END_NAMESPACE               END_NAMESPACE_SINGULARXX
+END_NAMESPACE
+   
+END_NAMESPACE_SINGULARXX
 
 #endif