Changeset e95747 in git

Timestamp:

Apr 13, 2016, 3:13:58 PM (7 years ago)

Author:

Andreas Steenpass <steenpass@…>

Branches:

(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')

Children:

c64ae28929a59f8f299f7b19c3a1f8e0add66d6c

Parents:

7d09f3ae72357972dd5a2f399332c16aa125f56b

git-author:

Andreas Steenpass <steenpass@mathematik.uni-kl.de>2016-04-13 15:13:58+02:00

git-committer:

Andreas Steenpass <steenpass@mathematik.uni-kl.de>2017-12-15 12:17:07+01:00

Message:

chg: remove class CReducerFinder_test

File:

• kernel/GBEngine/syz4.cc (modified) (9 diffs)

kernel/GBEngine/syz4.cc

@@ -294 +294 @@
 } CLeadingTerm_struct;
 
-class CReducerFinder_test
-{
-  public:
-    typedef long TComponentKey;
-    typedef std::vector<const CLeadingTerm_struct*> TReducers;
-
-  private:
-    typedef std::map< TComponentKey, TReducers> CReducersHash;
-
-  public:
-    /// goes over all leading terms
-    CReducerFinder_test(const ideal L);
-
-    void redefine(const ideal L);
-
-    void Initialize(const ideal L);
-
-    ~CReducerFinder_test();
-
-    static poly FindReducer(const poly multiplier, const poly monom, const poly syzterm, const CReducerFinder_test& checker);
-
-    bool IsDivisible(const poly q) const;
-
-    inline bool IsNonempty() const { return !m_hash.empty(); }
-
-    int PreProcessTerm(const poly t, CReducerFinder_test& syzChecker) const;
-
-  private:
-    ideal m_L; ///< only for debug
-
-    CReducersHash m_hash; // can also be replaced with a vector indexed by components
-
-  private:
-    CReducerFinder_test(const CReducerFinder_test&);
-    void operator=(const CReducerFinder_test&);
-};
-
-CReducerFinder_test::CReducerFinder_test(const ideal L):
-    m_L(const_cast<ideal>(L)), // for debug anyway
-    m_hash()
-{
-  if( L != NULL )
-    Initialize(L);
-}
-
-CReducerFinder_test::~CReducerFinder_test()
-{
-  for( CReducersHash::iterator it = m_hash.begin(); it != m_hash.end(); it++ )
-  {
-    TReducers& v = it->second;
-    for(TReducers::const_iterator vit = v.begin(); vit != v.end(); vit++ )
-      omfree(const_cast<CLeadingTerm_struct*>(*vit));
-    v.erase(v.begin(), v.end());
-  }
-  m_hash.erase(m_hash.begin(), m_hash.end());
-}
-
-void CReducerFinder_test::redefine(const ideal L)
-{
-  m_L = const_cast<ideal>(L); // for debug anyway
-  for( CReducersHash::iterator it = m_hash.begin(); it != m_hash.end(); it++ )
-  {
-    TReducers& v = it->second;
-    for(TReducers::const_iterator vit = v.begin(); vit != v.end(); vit++ )
-      omfree(const_cast<CLeadingTerm_struct*>(*vit));
-    v.erase(v.begin(), v.end());
-  }
-  m_hash.erase(m_hash.begin(), m_hash.end());
-  m_hash.clear();
-  if( L != NULL )
-    Initialize(L);
-}
-
-static CReducerFinder_test m_checker(NULL);
-static CReducerFinder_test m_div(NULL);
-
-poly CReducerFinder_test::FindReducer(const poly multiplier, const poly t,
-                                 const poly syzterm,
-                                 const CReducerFinder_test& syz_checker)
+typedef std::vector<const CLeadingTerm_struct*> TReducers_test;
+typedef std::map<long, TReducers_test> CReducersHash_test;
+
+static void deleteCRH(CReducersHash_test *C)
+{
+    for (CReducersHash_test::iterator it = C->begin(); it != C->end(); it++) {
+        TReducers_test& v = it->second;
+        for (TReducers_test::const_iterator vit = v.begin(); vit != v.end();
+            vit++) {
+            omfree(const_cast<CLeadingTerm_struct*>(*vit));
+        }
+        v.erase(v.begin(), v.end());
+    }
+    C->erase(C->begin(), C->end());
+}
+
+static void initialize(CReducersHash_test &C, const ideal L);
+
+static void redefine(CReducersHash_test *C, const ideal L)
+{
+    deleteCRH(C);
+    initialize(*C, L);
+}
+
+static CReducersHash_test m_checker;
+static CReducersHash_test m_div;
+
+bool IsDivisible(const CReducersHash_test *C, const poly product);
+
+poly FindReducer(const poly multiplier, const poly t, const poly syzterm,
+    const CReducersHash_test &syz_checker)
 {
   const ring r = currRing;
-  CReducerFinder_test::CReducersHash::const_iterator m_itr
-      = m_div.m_hash.find(p_GetComp(t, currRing));
-  if (m_itr == m_div.m_hash.end()) {
+  CReducersHash_test::const_iterator m_itr
+      = m_div.find(p_GetComp(t, currRing));
+  if (m_itr == m_div.end()) {
     return NULL;
   }
-  CReducerFinder_test::TReducers::const_iterator m_current
-      = (m_itr->second).begin();
-  CReducerFinder_test::TReducers::const_iterator m_finish
-      = (m_itr->second).end();
+  TReducers_test::const_iterator m_current = (m_itr->second).begin();
+  TReducers_test::const_iterator m_finish  = (m_itr->second).end();
   if (m_current == m_finish) {
     return NULL;
@@ -390 +340 @@
   if (syzterm != NULL)
     c = p_GetComp(syzterm, r) - 1;
-  const BOOLEAN to_check = (syz_checker.IsNonempty());
+  const BOOLEAN to_check = !syz_checker.empty();
   const poly q = p_New(r);
   pNext(q) = NULL;
@@ -413 +363 @@
     // cannot allow something like: a*gen(i) - a*gen(i)
     if (syzterm != NULL && (k == c))
-    if (p_ExpVectorEqual(syzterm, q, r))
-    {
+    if (p_ExpVectorEqual(syzterm, q, r)) {
       continue;
     }
-    // while the complement (the fraction) is not reducible by leading syzygies
-    if( to_check && syz_checker.IsDivisible(q) )
-    {
+    if (to_check && IsDivisible(&syz_checker, q)) {
       continue;
     }
-    number n = n_Mult( p_GetCoeff(multiplier, r), p_GetCoeff(t, r), r);
+    number n = n_Mult(p_GetCoeff(multiplier, r), p_GetCoeff(t, r), r);
     p_SetCoeff0(q, n_InpNeg(n, r), r);
     return q;
@@ -430 +377 @@
 }
 
-bool CReducerFinder_test::IsDivisible(const poly product) const
-{
-    CReducerFinder_test::CReducersHash::const_iterator m_itr
-        = (*this).m_hash.find(p_GetComp(product, currRing));
-    if (m_itr == (*this).m_hash.end()) {
+bool IsDivisible(const CReducersHash_test *C, const poly product)
+{
+    CReducersHash_test::const_iterator m_itr
+        = C->find(p_GetComp(product, currRing));
+    if (m_itr == C->end()) {
         return false;
     }
-    CReducerFinder_test::TReducers::const_iterator m_current
-        = (m_itr->second).begin();
-    CReducerFinder_test::TReducers::const_iterator m_finish
-        = (m_itr->second).end();
+    TReducers_test::const_iterator m_current = (m_itr->second).begin();
+    TReducers_test::const_iterator m_finish  = (m_itr->second).end();
     const unsigned long m_not_sev = ~p_GetShortExpVector(product, currRing);
     for ( ; m_current != m_finish; ++m_current) {
@@ -457 +402 @@
   if( CLCM_test_Check(m_lcm, multiplier) )
   {
-    s = CReducerFinder_test::FindReducer(multiplier, term4reduction, syztermCheck, m_checker);
+    s = FindReducer(multiplier, term4reduction, syztermCheck, m_checker);
   }
   if( s == NULL )
@@ -472 +417 @@
 }
 
-void CReducerFinder_test::Initialize(const ideal L)
-{
-  if( m_L == NULL )
-    m_L = L;
+static void initialize(CReducersHash_test &C, const ideal L)
+{
   if( L != NULL )
   {
@@ -489 +432 @@
         CLT->sev = p_GetShortExpVector(a, R);
         CLT->label = k;
-        m_hash[p_GetComp(a, R)].push_back( CLT );
+        C[p_GetComp(a, R)].push_back( CLT );
       }
     }
@@ -679 +622 @@
         m_idLeads_test->m[i]->next = NULL;
     }
-    m_div.redefine(m_idLeads_test);
+    redefine(&m_div, m_idLeads_test);
     m_lcm = CLCM_test_redefine(m_idLeads_test);
     m_syzLeads_test = idCopy(res[index]);
@@ -686 +629 @@
         m_syzLeads_test->m[i]->next = NULL;
     }
-    m_checker.redefine(m_syzLeads_test);
+    redefine(&m_checker, m_syzLeads_test);
 #if CACHE
     for (TCache_test::iterator it = m_cache_test.begin();