[mathicgb] 361/393: Light cleanup of the reducer implementatio files.
Doug Torrance
dtorrance-guest at moszumanska.debian.org
Fri Apr 3 15:59:34 UTC 2015
This is an automated email from the git hooks/post-receive script.
dtorrance-guest pushed a commit to branch upstream
in repository mathicgb.
commit f2c837347973dafa671fa08d2ee8eb63a32043a3
Author: Bjarke Hammersholt Roune <bjarkehr.code at gmail.com>
Date: Fri Sep 6 12:59:39 2013 +0200
Light cleanup of the reducer implementatio files.
---
src/mathicgb/F4Reducer.cpp | 26 +++++++-------
src/mathicgb/ReducerDedup.cpp | 66 +++++++++++++----------------------
src/mathicgb/ReducerHash.cpp | 51 +++++++++------------------
src/mathicgb/ReducerHashPack.cpp | 62 ++++++++++++++-------------------
src/mathicgb/ReducerNoDedup.cpp | 55 +++++++++--------------------
src/mathicgb/ReducerPack.cpp | 1 -
src/mathicgb/ReducerPackDedup.cpp | 73 ++++++++++++++++++---------------------
7 files changed, 128 insertions(+), 206 deletions(-)
diff --git a/src/mathicgb/F4Reducer.cpp b/src/mathicgb/F4Reducer.cpp
index f73b464..2f0f25a 100755
--- a/src/mathicgb/F4Reducer.cpp
+++ b/src/mathicgb/F4Reducer.cpp
@@ -51,8 +51,6 @@ MATHICGB_NAMESPACE_BEGIN
void f4ReducerDependency() {}
-class QuadMatrix;
-
class F4Reducer : public Reducer {
public:
enum Type {
@@ -136,7 +134,8 @@ void F4Reducer::writeMatricesTo(std::string file, size_t minEntries) {
}
std::unique_ptr<Poly> F4Reducer::classicReduce
-(const Poly& poly, const PolyBasis& basis) {
+ (const Poly& poly, const PolyBasis& basis)
+{
if (tracingLevel >= 2)
std::cerr <<
"F4Reducer: Using fall-back reducer for single classic reduction\n";
@@ -146,7 +145,8 @@ std::unique_ptr<Poly> F4Reducer::classicReduce
}
std::unique_ptr<Poly> F4Reducer::classicTailReduce
-(const Poly& poly, const PolyBasis& basis) {
+ (const Poly& poly, const PolyBasis& basis)
+{
if (tracingLevel >= 2)
std::cerr <<
"F4Reducer: Using fall-back reducer for single classic tail reduction\n";
@@ -233,11 +233,11 @@ void F4Reducer::classicReduceSPolySet(
mRing.freeMonomial(*it);
}
-void F4Reducer::classicReducePolySet
-(const std::vector< std::unique_ptr<Poly> >& polys,
- const PolyBasis& basis,
- std::vector< std::unique_ptr<Poly> >& reducedOut)
-{
+void F4Reducer::classicReducePolySet(
+ const std::vector< std::unique_ptr<Poly> >& polys,
+ const PolyBasis& basis,
+ std::vector< std::unique_ptr<Poly> >& reducedOut
+) {
if (polys.size() <= 1 && false) {
if (tracingLevel >= 2)
std::cerr << "F4Reducer: Using fall-back reducer for "
@@ -351,12 +351,10 @@ std::unique_ptr<Reducer> makeF4Reducer(
return std::move(reducer);
}
-Reducer::Registration r19(
+MATHICGB_REGISTER_REDUCER(
"F4Old",
- Reducer::Reducer_F4_Old,
- [](const PolyRing& ring) -> std::unique_ptr<Reducer> {
- return make_unique<F4Reducer>(ring, F4Reducer::OldType);
- }
+ Reducer_F4_Old,
+ (make_unique<F4Reducer>(ring, F4Reducer::OldType))
);
MATHICGB_REGISTER_REDUCER(
diff --git a/src/mathicgb/ReducerDedup.cpp b/src/mathicgb/ReducerDedup.cpp
index 9c59ef2..7a324c8 100644
--- a/src/mathicgb/ReducerDedup.cpp
+++ b/src/mathicgb/ReducerDedup.cpp
@@ -12,8 +12,6 @@ MATHICGB_NAMESPACE_BEGIN
void reducerDedupDependency() {}
-template<template<typename ConfigType> class Queue> class ReducerDedup;
-
template<template<typename> class Queue>
class ReducerDedup : public TypicalReducer {
public:
@@ -72,8 +70,7 @@ ReducerDedup<Q>::ReducerDedup(const PolyRing& ring):
}
template<template<typename> class Q>
-class ReducerDedup<Q>::MonomialFree
-{
+class ReducerDedup<Q>::MonomialFree {
public:
MonomialFree(const PolyRing& ring): mRing(ring) {}
@@ -87,8 +84,7 @@ private:
};
template<template<typename> class Q>
-ReducerDedup<Q>::~ReducerDedup()
-{
+ReducerDedup<Q>::~ReducerDedup() {
resetReducer();
mRing.freeMonomial(mLeadTerm.monom);
}
@@ -97,26 +93,23 @@ ReducerDedup<Q>::~ReducerDedup()
// External interface routines ////////
///////////////////////////////////////
template<template<typename> class Q>
-void ReducerDedup<Q>::insertTail(const_term multiple, const Poly* poly)
-{
+void ReducerDedup<Q>::insertTail(const_term multiple, const Poly* poly) {
if (poly->nTerms() <= 1)
return;
mLeadTermKnown = false;
Poly::const_iterator i = poly->begin();
- for (++i; i != poly->end(); ++i)
- {
- term t;
- t.monom = mRing.allocMonomial();
- mRing.monomialMult(multiple.monom, i.getMonomial(), t.monom);
- mRing.coefficientMult(multiple.coeff, i.getCoefficient(), t.coeff);
- mQueue.push(t);
- }
+ for (++i; i != poly->end(); ++i) {
+ term t;
+ t.monom = mRing.allocMonomial();
+ mRing.monomialMult(multiple.monom, i.getMonomial(), t.monom);
+ mRing.coefficientMult(multiple.coeff, i.getCoefficient(), t.coeff);
+ mQueue.push(t);
+ }
}
template<template<typename> class Q>
-void ReducerDedup<Q>::insert(monomial multiple, const Poly* poly)
-{
+void ReducerDedup<Q>::insert(monomial multiple, const Poly* poly) {
if (poly->isZero())
return;
mLeadTermKnown = false;
@@ -129,8 +122,7 @@ void ReducerDedup<Q>::insert(monomial multiple, const Poly* poly)
}
template<template<typename> class Q>
-bool ReducerDedup<Q>::leadTerm(const_term& result)
-{
+bool ReducerDedup<Q>::leadTerm(const_term& result) {
if (mLeadTermKnown) {
result = mLeadTerm;
return true;
@@ -161,8 +153,7 @@ bool ReducerDedup<Q>::leadTerm(const_term& result)
}
template<template<typename> class Q>
-void ReducerDedup<Q>::removeLeadTerm()
-{
+void ReducerDedup<Q>::removeLeadTerm() {
if (!mLeadTermKnown) {
const_term dummy;
leadTerm(dummy);
@@ -171,42 +162,33 @@ void ReducerDedup<Q>::removeLeadTerm()
}
template<template<typename> class Q>
-void ReducerDedup<Q>::resetReducer()
-{
+void ReducerDedup<Q>::resetReducer() {
MonomialFree freeer(mRing);
mQueue.forAll(freeer);
mQueue.clear();
}
template<template<typename> class Q>
-size_t ReducerDedup<Q>::getMemoryUse() const
-{
+size_t ReducerDedup<Q>::getMemoryUse() const {
return TypicalReducer::getMemoryUse() + mQueue.getMemoryUse();
}
-
-Reducer::Registration r2(
+MATHICGB_REGISTER_REDUCER(
"TourDedup",
- Reducer::Reducer_TourTree_Dedup,
- [](const PolyRing& ring) -> std::unique_ptr<Reducer> {
- return make_unique<ReducerDedup<mic::TourTree>>(ring);
- }
+ Reducer_TourTree_Dedup,
+ make_unique<ReducerDedup<mic::TourTree>>(ring)
);
-Reducer::Registration r8(
+MATHICGB_REGISTER_REDUCER(
"HeapDedup",
- Reducer::Reducer_Heap_Dedup,
- [](const PolyRing& ring) -> std::unique_ptr<Reducer> {
- return make_unique<ReducerDedup<mic::Heap>>(ring);
- }
+ Reducer_Heap_Dedup,
+ make_unique<ReducerDedup<mic::Heap>>(ring)
);
-Reducer::Registration r14(
+MATHICGB_REGISTER_REDUCER(
"GeoDedup",
- Reducer::Reducer_Geobucket_Dedup,
- [](const PolyRing& ring) -> std::unique_ptr<Reducer> {
- return make_unique<ReducerDedup<mic::Geobucket>>(ring);
- }
+ Reducer_Geobucket_Dedup,
+ make_unique<ReducerDedup<mic::Geobucket>>(ring)
);
MATHICGB_NAMESPACE_END
diff --git a/src/mathicgb/ReducerHash.cpp b/src/mathicgb/ReducerHash.cpp
index 5a5304f..b19561f 100644
--- a/src/mathicgb/ReducerHash.cpp
+++ b/src/mathicgb/ReducerHash.cpp
@@ -13,8 +13,6 @@ MATHICGB_NAMESPACE_BEGIN
void reducerHashDependency() {}
-template<template<typename ConfigType> class Queue> class ReducerHash;
-
template<template<typename> class Queue>
class ReducerHash : public TypicalReducer {
public:
@@ -61,13 +59,8 @@ ReducerHash<Q>::ReducerHash(const PolyRing &ring):
mQueue(Configuration(ring))
{}
-///////////////////////////////////////
-// External interface routines ////////
-///////////////////////////////////////
-
template<template<typename> class Q>
-void ReducerHash<Q>::insertTail(const_term multiplier, const Poly *g1)
-{
+void ReducerHash<Q>::insertTail(const_term multiplier, const Poly *g1) {
if (g1->nTerms() <= 1) return;
mNodesTmp.clear();
@@ -83,8 +76,7 @@ void ReducerHash<Q>::insertTail(const_term multiplier, const Poly *g1)
}
template<template<typename> class Q>
-void ReducerHash<Q>::insert(monomial multiplier, const Poly *g1)
-{
+void ReducerHash<Q>::insert(monomial multiplier, const Poly *g1) {
mNodesTmp.clear();
const auto end = g1->end();
for (auto it = g1->begin(); it != end; ++it) {
@@ -98,8 +90,7 @@ void ReducerHash<Q>::insert(monomial multiplier, const Poly *g1)
}
template<template<typename> class Q>
-bool ReducerHash<Q>::leadTerm(const_term& result)
-{
+bool ReducerHash<Q>::leadTerm(const_term& result) {
while (!mQueue.empty()) {
const auto top = mQueue.top();
if (!mRing.coefficientIsZero(top->value())) {
@@ -114,17 +105,14 @@ bool ReducerHash<Q>::leadTerm(const_term& result)
}
template<template<typename> class Q>
-void ReducerHash<Q>::removeLeadTerm()
-// returns true if there is a term to extract
-{
+void ReducerHash<Q>::removeLeadTerm() {
const auto top = mQueue.top();
mQueue.pop();
mHashTable.remove(top);
}
template<template<typename> class Q>
-void ReducerHash<Q>::resetReducer()
-{
+void ReducerHash<Q>::resetReducer() {
while (!mQueue.empty()) {
const auto top = mQueue.top();
mQueue.pop();
@@ -134,34 +122,29 @@ void ReducerHash<Q>::resetReducer()
}
template<template<typename> class Q>
-size_t ReducerHash<Q>::getMemoryUse() const
-{
+size_t ReducerHash<Q>::getMemoryUse() const {
size_t result = TypicalReducer::getMemoryUse();
result += mHashTable.getMemoryUse();
result += mQueue.getMemoryUse();
return result;
}
-Reducer::Registration r3(
+MATHICGB_REGISTER_REDUCER(
"TourHash",
- Reducer::Reducer_TourTree_Hashed,
- [](const PolyRing& ring) -> std::unique_ptr<Reducer> {
- return make_unique<ReducerHash<mic::TourTree>>(ring);
- }
+ Reducer_TourTree_Hashed,
+ make_unique<ReducerHash<mic::TourTree>>(ring)
);
-Reducer::Registration r9(
+
+MATHICGB_REGISTER_REDUCER(
"HeapHash",
- Reducer::Reducer_Heap_Hashed,
- [](const PolyRing& ring) -> std::unique_ptr<Reducer> {
- return make_unique<ReducerHash<mic::Heap>>(ring);
- }
+ Reducer_Heap_Hashed,
+ make_unique<ReducerHash<mic::Heap>>(ring)
);
-Reducer::Registration r15(
+
+MATHICGB_REGISTER_REDUCER(
"GeoHash",
- Reducer::Reducer_Geobucket_Hashed,
- [](const PolyRing& ring) -> std::unique_ptr<Reducer> {
- return make_unique<ReducerHash<mic::Geobucket>>(ring);
- }
+ Reducer_Geobucket_Hashed,
+ make_unique<ReducerHash<mic::Geobucket>>(ring)
);
MATHICGB_NAMESPACE_END
diff --git a/src/mathicgb/ReducerHashPack.cpp b/src/mathicgb/ReducerHashPack.cpp
index 6c8d7af..7864d95 100644
--- a/src/mathicgb/ReducerHashPack.cpp
+++ b/src/mathicgb/ReducerHashPack.cpp
@@ -13,8 +13,6 @@ MATHICGB_NAMESPACE_BEGIN
void reducerHashPackDependency() {}
-template<template<typename ConfigType> class Queue> class ReducerHashPack;
-
template<template<typename> class Queue>
class ReducerHashPack : public TypicalReducer {
public:
@@ -78,8 +76,7 @@ ReducerHashPack<Q>::ReducerHashPack(const PolyRing& ring):
{}
template<template<typename> class Q>
-class ReducerHashPack<Q>::MonomialFree
-{
+class ReducerHashPack<Q>::MonomialFree {
public:
MonomialFree(const PolyRing& ring): mRing(ring) {}
@@ -92,17 +89,12 @@ private:
};
template<template<typename> class Q>
-ReducerHashPack<Q>::~ReducerHashPack()
-{
+ReducerHashPack<Q>::~ReducerHashPack() {
resetReducer();
}
-///////////////////////////////////////
-// External interface routines ////////
-///////////////////////////////////////
template<template<typename> class Q>
-void ReducerHashPack<Q>::insertTail(const_term multiple, const Poly* poly)
-{
+void ReducerHashPack<Q>::insertTail(const_term multiple, const Poly* poly) {
MATHICGB_ASSERT(poly != 0);
MATHICGB_ASSERT(&poly->ring() == &mRing);
if (poly->nTerms() < 2)
@@ -114,8 +106,7 @@ void ReducerHashPack<Q>::insertTail(const_term multiple, const Poly* poly)
}
template<template<typename> class Q>
-void ReducerHashPack<Q>::insert(monomial multiple, const Poly* poly)
-{
+void ReducerHashPack<Q>::insert(monomial multiple, const Poly* poly) {
MATHICGB_ASSERT(poly != 0);
MATHICGB_ASSERT(&poly->ring() == &mRing);
if (poly->isZero())
@@ -133,16 +124,20 @@ namespace {
}
template<template<typename> class Q>
-ReducerHashPack<Q>::MultipleWithPos::MultipleWithPos
-(const Poly& poly, const_term multiple):
+ReducerHashPack<Q>::MultipleWithPos::MultipleWithPos(
+ const Poly& poly,
+ const_term multiple
+):
pos(poly.begin()),
end(poly.end()),
multiple(allocTerm(poly.ring(), multiple)),
- node(0) {}
+ node(0)
+{}
template<template<typename> class Q>
void ReducerHashPack<Q>::MultipleWithPos::destroy(const PolyRing& ring) {
- ring.freeMonomial(const_cast<ConstMonomial&>(multiple.monom).castAwayConst());
+ ring.freeMonomial
+ (const_cast<ConstMonomial&>(multiple.monom).castAwayConst());
// Call the destructor to destruct the iterators into std::vector.
// In debug mode MSVC puts those in a linked list and the destructor
@@ -216,8 +211,7 @@ void ReducerHashPack<Q>::insertEntry(MultipleWithPos* entry) {
}
template<template<typename> class Q>
-void ReducerHashPack<Q>::resetReducer()
-{
+void ReducerHashPack<Q>::resetReducer() {
MonomialFree freeer(mRing);
mQueue.forAll(freeer);
mQueue.clear();
@@ -225,34 +219,28 @@ void ReducerHashPack<Q>::resetReducer()
}
template<template<typename> class Q>
-size_t ReducerHashPack<Q>::getMemoryUse() const
-{
+size_t ReducerHashPack<Q>::getMemoryUse() const {
return mQueue.getMemoryUse() +
mPool.getMemoryUse() +
mHashTable.getMemoryUse();
}
-Reducer::Registration r6(
+MATHICGB_REGISTER_REDUCER(
"TourHashPack",
- Reducer::Reducer_TourTree_Hashed_Packed,
- [](const PolyRing& ring) -> std::unique_ptr<Reducer> {
- return make_unique<ReducerHashPack<mic::TourTree>>(ring);
- }
+ Reducer_TourTree_Hashed_Packed,
+ make_unique<ReducerHashPack<mic::TourTree>>(ring)
);
-
-Reducer::Registration r12(
+
+MATHICGB_REGISTER_REDUCER(
"HeapHashPack",
- Reducer::Reducer_Heap_Hashed_Packed,
- [](const PolyRing& ring) -> std::unique_ptr<Reducer> {
- return make_unique<ReducerHashPack<mic::Heap>>(ring);
- }
+ Reducer_Heap_Hashed_Packed,
+ make_unique<ReducerHashPack<mic::Heap>>(ring)
);
-Reducer::Registration r18(
+
+MATHICGB_REGISTER_REDUCER(
"GeoHashPack",
- Reducer::Reducer_Geobucket_Hashed_Packed,
- [](const PolyRing& ring) -> std::unique_ptr<Reducer> {
- return make_unique<ReducerHashPack<mic::Geobucket>>(ring);
- }
+ Reducer_Geobucket_Hashed_Packed,
+ make_unique<ReducerHashPack<mic::Geobucket>>(ring)
);
MATHICGB_NAMESPACE_END
diff --git a/src/mathicgb/ReducerNoDedup.cpp b/src/mathicgb/ReducerNoDedup.cpp
index 78dd7b7..90b47a1 100644
--- a/src/mathicgb/ReducerNoDedup.cpp
+++ b/src/mathicgb/ReducerNoDedup.cpp
@@ -12,8 +12,6 @@ MATHICGB_NAMESPACE_BEGIN
void reducerNoDedupDependency() {}
-template<template<typename ConfigType> class Queue> class ReducerNoDedup;
-
template<template<typename> class Queue>
class ReducerNoDedup : public TypicalReducer {
public:
@@ -38,7 +36,6 @@ protected:
public:
// This Configuration is designed to work with
// mathic::TourTree, mathic::Heap, and mathic::Geobucket
-
class Configuration : public ReducerHelper::PlainConfiguration {
public:
typedef term Entry;
@@ -66,8 +63,7 @@ ReducerNoDedup<Q>::ReducerNoDedup(const PolyRing& ring):
}
template<template<typename> class Q>
-class ReducerNoDedup<Q>::MonomialFree
-{
+class ReducerNoDedup<Q>::MonomialFree {
public:
MonomialFree(const PolyRing& ring): mRing(ring) {}
@@ -81,18 +77,13 @@ private:
};
template<template<typename> class Q>
-ReducerNoDedup<Q>::~ReducerNoDedup()
-{
+ReducerNoDedup<Q>::~ReducerNoDedup() {
resetReducer();
mRing.freeMonomial(mLeadTerm.monom);
}
-///////////////////////////////////////
-// External interface routines ////////
-///////////////////////////////////////
template<template<typename> class Q>
-void ReducerNoDedup<Q>::insertTail(const_term multiple, const Poly* poly)
-{
+void ReducerNoDedup<Q>::insertTail(const_term multiple, const Poly* poly) {
if (poly->nTerms() <= 1)
return;
mLeadTermKnown = false;
@@ -109,8 +100,7 @@ void ReducerNoDedup<Q>::insertTail(const_term multiple, const Poly* poly)
}
template<template<typename> class Q>
-void ReducerNoDedup<Q>::insert(monomial multiple, const Poly* poly)
-{
+void ReducerNoDedup<Q>::insert(monomial multiple, const Poly* poly) {
if (poly->isZero())
return;
mLeadTermKnown = false;
@@ -123,8 +113,7 @@ void ReducerNoDedup<Q>::insert(monomial multiple, const Poly* poly)
}
template<template<typename> class Q>
-bool ReducerNoDedup<Q>::leadTerm(const_term& result)
-{
+bool ReducerNoDedup<Q>::leadTerm(const_term& result) {
if (mLeadTermKnown) {
result = mLeadTerm;
return true;
@@ -155,8 +144,7 @@ bool ReducerNoDedup<Q>::leadTerm(const_term& result)
}
template<template<typename> class Q>
-void ReducerNoDedup<Q>::removeLeadTerm()
-{
+void ReducerNoDedup<Q>::removeLeadTerm() {
if (!mLeadTermKnown) {
const_term dummy;
leadTerm(dummy);
@@ -165,42 +153,33 @@ void ReducerNoDedup<Q>::removeLeadTerm()
}
template<template<typename> class Q>
-void ReducerNoDedup<Q>::resetReducer()
-{
+void ReducerNoDedup<Q>::resetReducer() {
MonomialFree freeer(mRing);
//mQueue.forAll(freeer);
// mQueue.clear();
}
template<template<typename> class Q>
-size_t ReducerNoDedup<Q>::getMemoryUse() const
-{
+size_t ReducerNoDedup<Q>::getMemoryUse() const {
return TypicalReducer::getMemoryUse() + mQueue.getMemoryUse();
}
-Reducer::Registration r1(
+MATHICGB_REGISTER_REDUCER(
"TourNoDedup",
- Reducer::Reducer_TourTree_NoDedup,
- [](const PolyRing& ring) -> std::unique_ptr<Reducer> {
- return make_unique<ReducerNoDedup<mic::TourTree>>(ring);
- }
+ Reducer_TourTree_NoDedup,
+ make_unique<ReducerNoDedup<mic::TourTree>>(ring)
);
-Reducer::Registration r7(
+MATHICGB_REGISTER_REDUCER(
"HeapNoDedup",
- Reducer::Reducer_Heap_NoDedup,
- [](const PolyRing& ring) -> std::unique_ptr<Reducer> {
- return make_unique<ReducerNoDedup<mic::Heap>>(ring);
- }
+ Reducer_Heap_NoDedup,
+ make_unique<ReducerNoDedup<mic::Heap>>(ring)
);
-Reducer::Registration r13(
+MATHICGB_REGISTER_REDUCER(
"GeoNoDedup",
- Reducer::Reducer_Geobucket_NoDedup,
- [](const PolyRing& ring) -> std::unique_ptr<Reducer> {
- return make_unique<ReducerNoDedup<mic::Geobucket>>(ring);
- }
+ Reducer_Geobucket_NoDedup,
+ make_unique<ReducerNoDedup<mic::Geobucket>>(ring)
);
-
MATHICGB_NAMESPACE_END
diff --git a/src/mathicgb/ReducerPack.cpp b/src/mathicgb/ReducerPack.cpp
index a7151aa..60ca977 100644
--- a/src/mathicgb/ReducerPack.cpp
+++ b/src/mathicgb/ReducerPack.cpp
@@ -46,7 +46,6 @@ protected:
private:
// Represents a term multiple of a polynomial,
// together with a current term of the multiple.
-public:
struct MultipleWithPos {
MultipleWithPos(const Poly& poly, const_term multiple);
diff --git a/src/mathicgb/ReducerPackDedup.cpp b/src/mathicgb/ReducerPackDedup.cpp
index 839959b..848168b 100644
--- a/src/mathicgb/ReducerPackDedup.cpp
+++ b/src/mathicgb/ReducerPackDedup.cpp
@@ -114,18 +114,13 @@ private:
};
template<template<typename> class Q>
-ReducerPackDedup<Q>::~ReducerPackDedup()
-{
+ReducerPackDedup<Q>::~ReducerPackDedup() {
resetReducer();
mRing.freeMonomial(mLeadTerm.monom);
}
-///////////////////////////////////////
-// External interface routines ////////
-///////////////////////////////////////
template<template<typename> class Q>
-void ReducerPackDedup<Q>::insertTail(const_term multiple, const Poly* poly)
-{
+void ReducerPackDedup<Q>::insertTail(const_term multiple, const Poly* poly) {
if (poly->nTerms() <= 1)
return;
mLeadTermKnown = false;
@@ -138,8 +133,7 @@ void ReducerPackDedup<Q>::insertTail(const_term multiple, const Poly* poly)
}
template<template<typename> class Q>
-void ReducerPackDedup<Q>::insert(monomial multiple, const Poly* poly)
-{
+void ReducerPackDedup<Q>::insert(monomial multiple, const Poly* poly) {
if (poly->isZero())
return;
mLeadTermKnown = false;
@@ -153,28 +147,37 @@ void ReducerPackDedup<Q>::insert(monomial multiple, const Poly* poly)
}
template<template<typename> class Q>
-ReducerPackDedup<Q>::MultipleWithPos::MultipleWithPos
-(const Poly& poly, const_term multipleParam):
+ReducerPackDedup<Q>::MultipleWithPos::MultipleWithPos(
+ const Poly& poly,
+ const_term multipleParam
+):
pos(poly.begin()),
end(poly.end()),
multiple(ReducerHelper::allocTermCopy(poly.ring(), multipleParam)),
current(poly.ring().allocMonomial()),
- chain(this) {}
+ chain(this)
+{}
template<template<typename> class Q>
-void ReducerPackDedup<Q>::MultipleWithPos::computeCurrent(const PolyRing& ring) {
+void ReducerPackDedup<Q>::MultipleWithPos::computeCurrent
+ (const PolyRing& ring)
+{
ring.monomialMult(multiple.monom, pos.getMonomial(), current);
}
template<template<typename> class Q>
-void ReducerPackDedup<Q>::MultipleWithPos::currentCoefficient
-(const PolyRing& ring, coefficient& coeff) {
+void ReducerPackDedup<Q>::MultipleWithPos::currentCoefficient(
+ const PolyRing& ring,
+ coefficient& coeff
+) {
ring.coefficientMult(multiple.coeff, pos.getCoefficient(), coeff);
}
template<template<typename> class Q>
-void ReducerPackDedup<Q>::MultipleWithPos::addCurrentCoefficient
-(const PolyRing& ring, coefficient& coeff) {
+void ReducerPackDedup<Q>::MultipleWithPos::addCurrentCoefficient(
+ const PolyRing& ring,
+ coefficient& coeff
+) {
coefficient tmp;
ring.coefficientMult(multiple.coeff, pos.getCoefficient(), tmp);
ring.coefficientAddTo(coeff, tmp);
@@ -201,8 +204,7 @@ void ReducerPackDedup<Q>::MultipleWithPos::destroy(const PolyRing& ring) {
}
template<template<typename> class Q>
-bool ReducerPackDedup<Q>::leadTerm(const_term& result)
-{
+bool ReducerPackDedup<Q>::leadTerm(const_term& result) {
if (mLeadTermKnown) {
result = mLeadTerm;
return true;
@@ -274,8 +276,7 @@ bool ReducerPackDedup<Q>::leadTerm(const_term& result)
}
template<template<typename> class Q>
-void ReducerPackDedup<Q>::removeLeadTerm()
-{
+void ReducerPackDedup<Q>::removeLeadTerm() {
if (!mLeadTermKnown) {
const_term dummy;
leadTerm(dummy);
@@ -284,44 +285,36 @@ void ReducerPackDedup<Q>::removeLeadTerm()
}
template<template<typename> class Q>
-void ReducerPackDedup<Q>::resetReducer()
-{
+void ReducerPackDedup<Q>::resetReducer() {
MonomialFree freeer(mRing);
mQueue.forAll(freeer);
mQueue.clear();
}
template<template<typename> class Q>
-size_t ReducerPackDedup<Q>::getMemoryUse() const
-{
+size_t ReducerPackDedup<Q>::getMemoryUse() const {
return
TypicalReducer::getMemoryUse() +
mQueue.getMemoryUse() +
mPool.getMemoryUse();
}
-Reducer::Registration r5(
+MATHICGB_REGISTER_REDUCER(
"TourDedupPack",
- Reducer::Reducer_TourTree_Dedup_Packed,
- [](const PolyRing& ring) -> std::unique_ptr<Reducer> {
- return make_unique<ReducerPackDedup<mic::TourTree>>(ring);
- }
+ Reducer_TourTree_Dedup_Packed,
+ make_unique<ReducerPackDedup<mic::TourTree>>(ring)
);
-Reducer::Registration r11(
+MATHICGB_REGISTER_REDUCER(
"HeapDedupPack",
- Reducer::Reducer_Heap_Dedup_Packed,
- [](const PolyRing& ring) -> std::unique_ptr<Reducer> {
- return make_unique<ReducerPackDedup<mic::Heap>>(ring);
- }
+ Reducer_Heap_Dedup_Packed,
+ make_unique<ReducerPackDedup<mic::Heap>>(ring)
);
-Reducer::Registration r17(
+MATHICGB_REGISTER_REDUCER(
"GeoDedupPack",
- Reducer::Reducer_Geobucket_Dedup_Packed,
- [](const PolyRing& ring) -> std::unique_ptr<Reducer> {
- return make_unique<ReducerPackDedup<mic::Geobucket>>(ring);
- }
+ Reducer_Geobucket_Dedup_Packed,
+ make_unique<ReducerPackDedup<mic::Geobucket>>(ring)
);
MATHICGB_NAMESPACE_END
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/mathicgb.git
More information about the debian-science-commits
mailing list