[mathicgb] 291/393: Renamed Ideal to Basis to avoid name conflict with Frobby.
Doug Torrance
dtorrance-guest at moszumanska.debian.org
Fri Apr 3 15:59:22 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 a6f269796dee1d9e9e06c79c03d2e5dc70751269
Author: Bjarke Hammersholt Roune <bjarkehr.code at gmail.com>
Date: Fri Apr 19 21:25:24 2013 -0400
Renamed Ideal to Basis to avoid name conflict with Frobby.
---
Makefile.am | 5 ++--
src/cli/GBAction.cpp | 16 ++++++------
src/cli/SigGBAction.cpp | 24 +++++++++---------
src/mathicgb.cpp | 46 +++++++++++++++++------------------
src/mathicgb/{Ideal.cpp => Basis.cpp} | 27 +++++++++-----------
src/mathicgb/{Ideal.hpp => Basis.hpp} | 15 +++++-------
src/mathicgb/BuchbergerAlg.cpp | 16 ++++++------
src/mathicgb/BuchbergerAlg.hpp | 4 ++-
src/mathicgb/PolyBasis.cpp | 24 +++++++++---------
src/mathicgb/PolyBasis.hpp | 10 ++++----
src/mathicgb/SignatureGB.cpp | 26 ++++++++++----------
src/mathicgb/SignatureGB.hpp | 6 +----
src/mathicgb/io-util.cpp | 8 +++---
src/mathicgb/io-util.hpp | 6 ++---
src/test/F4MatrixBuilder.cpp | 4 +--
src/test/FreeModuleOrderTest.cpp | 26 ++++++++++----------
src/test/QuadMatrixBuilder.cpp | 6 ++---
src/test/gb-test.cpp | 8 +++---
src/test/poly-test.cpp | 20 +++++++--------
19 files changed, 144 insertions(+), 153 deletions(-)
diff --git a/Makefile.am b/Makefile.am
index 0e589e3..96879c8 100755
--- a/Makefile.am
+++ b/Makefile.am
@@ -22,7 +22,7 @@ libmathicgb_la_SOURCES = src/mathicgb/BjarkeGeobucket2.cpp \
src/mathicgb/FreeModuleOrder.cpp src/mathicgb/FreeModuleOrder.hpp \
src/mathicgb/GroebnerBasis.cpp src/mathicgb/GroebnerBasis.hpp \
src/mathicgb/HashTourReducer.cpp src/mathicgb/HashTourReducer.hpp \
- src/mathicgb/Ideal.cpp src/mathicgb/Ideal.hpp \
+ src/mathicgb/Basis.cpp src/mathicgb/Basis.hpp \
src/mathicgb/io-util.cpp src/mathicgb/io-util.hpp \
src/mathicgb/KoszulQueue.cpp src/mathicgb/KoszulQueue.hpp \
src/mathicgb/MonomialHashTable.hpp src/mathicgb/MonTableDivList.hpp \
@@ -64,7 +64,8 @@ libmathicgb_la_SOURCES = src/mathicgb/BjarkeGeobucket2.cpp \
src/mathicgb/F4ProtoMatrix.cpp src/mathicgb/F4MatrixProject.hpp \
src/mathicgb/F4MatrixProjection.cpp src/mathicgb/ScopeExit.hpp \
src/mathicgb.cpp src/mathicgb.h src/mathicgb/mtbb.hpp \
- src/mathicgb/PrimeField.hpp src/mathicgb/MonoMonoid.hpp
+ src/mathicgb/PrimeField.hpp src/mathicgb/MonoMonoid.hpp \
+ MonoProcessor.hpp
# The headers that libmathicgb installs.
diff --git a/src/cli/GBAction.cpp b/src/cli/GBAction.cpp
index 8e00ef5..02babb4 100755
--- a/src/cli/GBAction.cpp
+++ b/src/cli/GBAction.cpp
@@ -2,7 +2,7 @@
#include "GBAction.hpp"
#include "mathicgb/BuchbergerAlg.hpp"
-#include "mathicgb/Ideal.hpp"
+#include "mathicgb/Basis.hpp"
#include "mathicgb/io-util.hpp"
#include "mathicgb/F4Reducer.hpp"
#include <fstream>
@@ -58,15 +58,15 @@ void GBAction::performAction() {
const std::string projectName = mParams.inputFileNameStem(0);
// read input
- std::unique_ptr<Ideal> ideal;
+ std::unique_ptr<Basis> basis;
{
- const std::string inputIdealFile = projectName + ".ideal";
- std::ifstream inputFile(inputIdealFile.c_str());
+ const std::string inputBasisFile = projectName + ".ideal";
+ std::ifstream inputFile(inputBasisFile.c_str());
if (inputFile.fail())
- mic::reportError("Could not read input file \"" + inputIdealFile + '\n');
- ideal = Ideal::parse(inputFile);
+ mic::reportError("Could not read input file \"" + inputBasisFile + '\n');
+ basis = Basis::parse(inputFile);
}
- std::unique_ptr<PolyRing const> ring(&(ideal->ring()));
+ std::unique_ptr<PolyRing const> ring(&(basis->ring()));
// run algorithm
const auto reducerType = Reducer::reducerType(mGBParams.mReducer.value());
@@ -86,7 +86,7 @@ void GBAction::performAction() {
}
BuchbergerAlg alg(
- *ideal,
+ *basis,
4 /*mModuleOrder.value()*/ , // todo: alg should not take a *module* order
*reducer,
mGBParams.mDivisorLookup.value(),
diff --git a/src/cli/SigGBAction.cpp b/src/cli/SigGBAction.cpp
index 5d19316..7d32653 100755
--- a/src/cli/SigGBAction.cpp
+++ b/src/cli/SigGBAction.cpp
@@ -1,12 +1,12 @@
-#include "mathicgb/stdinc.h"
-#include "SigGBAction.hpp"
-
-#include "mathicgb/Ideal.hpp"
+#include "mathicgb/stdinc.h"
+#include "SigGBAction.hpp"
+
+#include "mathicgb/Basis.hpp"
#include "mathicgb/SignatureGB.hpp"
#include "mathicgb/io-util.hpp"
#include <fstream>
#include <iostream>
-
+
SigGBAction::SigGBAction():
mUseSingularCriterionEarly("earlySingularCriterion",
"Apply the singular S-pair elimination criterion before queueing "
@@ -48,18 +48,18 @@ void SigGBAction::performAction() {
mGBParams.perform();
// read input file
- std::unique_ptr<Ideal> ideal;
+ std::unique_ptr<Basis> basis;
{
- const std::string inputIdealFile = mParams.inputFileNameStem(0) + ".ideal";
- std::ifstream inputFile(inputIdealFile.c_str());
+ const std::string inputBasisFile = mParams.inputFileNameStem(0) + ".ideal";
+ std::ifstream inputFile(inputBasisFile.c_str());
if (inputFile.fail())
- mic::reportError("Could not read input file \"" + inputIdealFile + '\n');
- ideal = Ideal::parse(inputFile);
+ mic::reportError("Could not read input file \"" + inputBasisFile + '\n');
+ basis = Basis::parse(inputFile);
}
- std::unique_ptr<PolyRing const> ring(&(ideal->ring()));
+ std::unique_ptr<PolyRing const> ring(&(basis->ring()));
SignatureGB alg(
- std::move(*ideal),
+ std::move(*basis),
mModuleOrder.value(),
Reducer::reducerType(mGBParams.mReducer.value()),
mGBParams.mDivisorLookup.value(),
diff --git a/src/mathicgb.cpp b/src/mathicgb.cpp
index d3e491b..c49c4a0 100755
--- a/src/mathicgb.cpp
+++ b/src/mathicgb.cpp
@@ -1,7 +1,7 @@
#include "mathicgb/stdinc.h"
#include "mathicgb.h"
-#include "mathicgb/Ideal.hpp"
+#include "mathicgb/Basis.hpp"
#include "mathicgb/PolyRing.hpp"
#include "mathicgb/Poly.hpp"
#include "mathicgb/Reducer.hpp"
@@ -484,7 +484,7 @@ namespace mgb {
GroebnerConfiguration::LexicographicBaseOrder,
conf.monomialOrder().second
),
- ideal(ring),
+ basis(ring),
poly(ring),
monomial(ring.allocMonomial()),
conf(conf)
@@ -499,7 +499,7 @@ namespace mgb {
}
const PolyRing ring;
- Ideal ideal;
+ Basis basis;
Poly poly;
Monomial monomial;
const GroebnerConfiguration conf;
@@ -542,7 +542,7 @@ namespace mgb {
MATHICGB_ASSERT(debugAssertValid());
MATHICGB_IF_DEBUG(mPimpl->checker.idealBegin());
MATHICGB_ASSERT(mPimpl->poly.isZero());
- MATHICGB_ASSERT(mPimpl->ideal.empty());
+ MATHICGB_ASSERT(mPimpl->basis.empty());
MATHICGB_ASSERT(debugAssertValid());
}
@@ -551,9 +551,9 @@ namespace mgb {
MATHICGB_ASSERT(debugAssertValid());
MATHICGB_IF_DEBUG(mPimpl->checker.idealBegin(polyCount));
MATHICGB_ASSERT(mPimpl->poly.isZero());
- MATHICGB_ASSERT(mPimpl->ideal.empty());
+ MATHICGB_ASSERT(mPimpl->basis.empty());
- mPimpl->ideal.reserve(polyCount);
+ mPimpl->basis.reserve(polyCount);
MATHICGB_ASSERT(debugAssertValid());
}
@@ -606,7 +606,7 @@ namespace mgb {
auto poly = make_unique<Poly>(std::move(mPimpl->poly));
if (!poly->termsAreInDescendingOrder())
poly->sortTermsDescending();
- mPimpl->ideal.insert(std::move(poly));
+ mPimpl->basis.insert(std::move(poly));
mPimpl->poly.setToZero();
MATHICGB_ASSERT(debugAssertValid());
@@ -623,7 +623,7 @@ namespace mgb {
MATHICGB_ASSERT(mPimpl != 0);
MATHICGB_ASSERT_NO_ASSUME(!mPimpl->hasBeenDestroyed);
MATHICGB_ASSERT(!mPimpl->monomial.isNull());
- MATHICGB_ASSERT(&mPimpl->ideal.ring() == &mPimpl->ring);
+ MATHICGB_ASSERT(&mPimpl->basis.ring() == &mPimpl->ring);
MATHICGB_ASSERT(&mPimpl->poly.ring() == &mPimpl->ring);
MATHICGB_ASSERT(mPimpl->ring.getNumVars() == mPimpl->conf.varCount());
MATHICGB_ASSERT(mPimpl->ring.charac() == mPimpl->conf.modulus());
@@ -646,7 +646,7 @@ namespace mgbi {
// ** Implementation of mgbi::IdealAdapter
namespace mgbi {
struct IdealAdapter::Pimpl {
- std::unique_ptr<Ideal> ideal;
+ std::unique_ptr<Basis> basis;
};
IdealAdapter::IdealAdapter():
@@ -659,28 +659,28 @@ namespace mgbi {
}
auto IdealAdapter::varCount() const -> VarIndex {
- MATHICGB_ASSERT(mPimpl->ideal.get() != 0);
- return mPimpl->ideal->ring().getNumVars();
+ MATHICGB_ASSERT(mPimpl->basis.get() != 0);
+ return mPimpl->basis->ring().getNumVars();
}
size_t IdealAdapter::polyCount() const {
- MATHICGB_ASSERT(mPimpl->ideal.get() != 0);
- return mPimpl->ideal->size();
+ MATHICGB_ASSERT(mPimpl->basis.get() != 0);
+ return mPimpl->basis->size();
}
size_t IdealAdapter::termCount(PolyIndex poly) const {
- MATHICGB_ASSERT(mPimpl->ideal.get() != 0);
- MATHICGB_ASSERT(poly < mPimpl->ideal->size());
- return mPimpl->ideal->getPoly(poly)->nTerms();
+ MATHICGB_ASSERT(mPimpl->basis.get() != 0);
+ MATHICGB_ASSERT(poly < mPimpl->basis->size());
+ return mPimpl->basis->getPoly(poly)->nTerms();
}
auto IdealAdapter::term(
PolyIndex poly,
TermIndex term
) const -> std::pair<Coefficient, const Exponent*> {
- MATHICGB_ASSERT(mPimpl->ideal.get() != 0);
- MATHICGB_ASSERT(poly < mPimpl->ideal->size());
- const auto& p = *mPimpl->ideal->getPoly(poly);
+ MATHICGB_ASSERT(mPimpl->basis.get() != 0);
+ MATHICGB_ASSERT(poly < mPimpl->basis->size());
+ const auto& p = *mPimpl->basis->getPoly(poly);
MATHICGB_ASSERT(term < p.nTerms());
return std::make_pair(
@@ -700,9 +700,9 @@ namespace mgbi {
/// polynomial-by-polynomial as data is transferred to out. Also
/// make it so that ideal is not copied.
- auto&& ideal = PimplOf()(inputWhichWillBeCleared).ideal;
+ auto&& basis = PimplOf()(inputWhichWillBeCleared).basis;
auto&& conf = inputWhichWillBeCleared.configuration();
- auto&& ring = ideal.ring();
+ auto&& ring = basis.ring();
const auto varCount = ring.getNumVars();
MATHICGB_ASSERT(PimplOf()(conf).debugAssertValid());
@@ -733,7 +733,7 @@ namespace mgbi {
const auto reducer = Reducer::makeReducer(reducerType, ring);
// Set up and configure algorithm
- BuchbergerAlg alg(ideal, 4, *reducer, 2, true, 0);
+ BuchbergerAlg alg(basis, 4, *reducer, 2, true, 0);
alg.setReducerMemoryQuantum(100 * 1024);
alg.setUseAutoTopReduction(true);
alg.setUseAutoTailReduction(false);
@@ -741,6 +741,6 @@ namespace mgbi {
// Compute Groebner basis
alg.computeGrobnerBasis();
- PimplOf()(output).ideal = alg.basis().toIdealAndRetireAll();
+ PimplOf()(output).basis = alg.basis().toBasisAndRetireAll();
}
}
diff --git a/src/mathicgb/Ideal.cpp b/src/mathicgb/Basis.cpp
similarity index 71%
rename from src/mathicgb/Ideal.cpp
rename to src/mathicgb/Basis.cpp
index 2123438..771bd12 100755
--- a/src/mathicgb/Ideal.cpp
+++ b/src/mathicgb/Basis.cpp
@@ -1,22 +1,21 @@
-// Copyright 2011 Michael E. Stillman
#include "stdinc.h"
-#include "PolyRing.hpp"
+#include "Basis.hpp"
+#include "PolyRing.hpp"
#include "Poly.hpp"
#include "FreeModuleOrder.hpp"
-#include "Ideal.hpp"
#include <ostream>
#include <istream>
#include <iostream>
#include <cctype>
-Ideal::~Ideal()
+Basis::~Basis()
{
for (size_t i = 0; i<mGenerators.size(); i++)
delete mGenerators[i];
}
-void Ideal::insert(std::unique_ptr<Poly> p) {
+void Basis::insert(std::unique_ptr<Poly> p) {
MATHICGB_ASSERT(p.get() != 0);
MATHICGB_ASSERT(p->termsAreInDescendingOrder());
mGenerators.reserve(mGenerators.size() + 1);
@@ -24,9 +23,9 @@ void Ideal::insert(std::unique_ptr<Poly> p) {
}
namespace {
- class IdealSort {
+ class BasisSort {
public:
- IdealSort(const FreeModuleOrder& order): mOrder(order) {}
+ BasisSort(const FreeModuleOrder& order): mOrder(order) {}
bool operator()(const Poly* a, const Poly* b) {
return mOrder.signatureCompare
(a->getLeadMonomial(), b->getLeadMonomial()) == LT;
@@ -37,21 +36,17 @@ namespace {
};
}
-void Ideal::reverse() {
- std::reverse(mGenerators.begin(), mGenerators.end());
-}
-
-void Ideal::sort(FreeModuleOrder& order) {
- IdealSort cmp(order);
+void Basis::sort(FreeModuleOrder& order) {
+ BasisSort cmp(order);
std::sort(mGenerators.begin(), mGenerators.end(), cmp);
}
-std::unique_ptr<Ideal> Ideal::parse(std::istream& in)
+std::unique_ptr<Basis> Basis::parse(std::istream& in)
{
PolyRing *R = PolyRing::read(in); // todo: fix this leak
size_t npolys;
in >> npolys;
- auto result = make_unique<Ideal>(*R);
+ auto result = make_unique<Basis>(*R);
for (size_t j = 0; j < npolys; ++j) {
auto g = make_unique<Poly>(*R);
while (std::isspace(in.peek()))
@@ -62,7 +57,7 @@ std::unique_ptr<Ideal> Ideal::parse(std::istream& in)
return result;
}
-void Ideal::display(std::ostream& out, bool printComponent) const
+void Basis::display(std::ostream& out, bool printComponent) const
{
mRing.write(out);
out << '\n' << mGenerators.size() << '\n';
diff --git a/src/mathicgb/Ideal.hpp b/src/mathicgb/Basis.hpp
similarity index 82%
rename from src/mathicgb/Ideal.hpp
rename to src/mathicgb/Basis.hpp
index 3173674..70b66ba 100755
--- a/src/mathicgb/Ideal.hpp
+++ b/src/mathicgb/Basis.hpp
@@ -1,7 +1,5 @@
-// Copyright 2011 Michael E. Stillman
-
-#ifndef _ideal_h_
-#define _ideal_h_
+#ifndef MATHICGB_BASIS_GUARD
+#define MATHICGB_BASIS_GUARD
#include <memory>
#include <algorithm>
@@ -12,17 +10,17 @@
class Poly;
class FreeModuleOrder;
-class Ideal {
+class Basis {
// Really: a list of polynomials
// BUT ALSO maybe: includes memory areas for the polynomials?
public:
- Ideal(const PolyRing &R) : mRing(R) {}
- ~Ideal();
+ Basis(const PolyRing &R) : mRing(R) {}
+ ~Basis();
void insert(std::unique_ptr<Poly> p);
/// reads ring, #gens, each generator in turn
- static std::unique_ptr<Ideal> parse(std::istream &i);
+ static std::unique_ptr<Basis> parse(std::istream &i);
/// inverse operation to parse().
void display(std::ostream &o, bool print_comp) const;
@@ -36,7 +34,6 @@ public:
bool empty() const {return mGenerators.empty();}
void reserve(size_t size) {mGenerators.reserve(size);}
- void reverse();
void sort(FreeModuleOrder& order);
private:
diff --git a/src/mathicgb/BuchbergerAlg.cpp b/src/mathicgb/BuchbergerAlg.cpp
index 23648b0..5194241 100755
--- a/src/mathicgb/BuchbergerAlg.cpp
+++ b/src/mathicgb/BuchbergerAlg.cpp
@@ -1,6 +1,6 @@
#include "stdinc.h"
#include "BuchbergerAlg.hpp"
-#include "Ideal.hpp"
+#include "Basis.hpp"
#include "LogDomain.hpp"
#include <iostream>
@@ -11,7 +11,7 @@ MATHICGB_DEFINE_LOG_DOMAIN(
);
BuchbergerAlg::BuchbergerAlg(
- const Ideal& ideal,
+ const Basis& basis,
FreeModuleOrderType orderType,
Reducer& reducer,
int divisorLookupType,
@@ -23,21 +23,21 @@ BuchbergerAlg::BuchbergerAlg(
mSPairGroupSize(reducer.preferredSetSize()),
mUseAutoTopReduction(true),
mUseAutoTailReduction(false),
- mRing(*ideal.getPolyRing()),
- mOrder(FreeModuleOrder::makeOrder(orderType, *ideal.getPolyRing())),
+ mRing(*basis.getPolyRing()),
+ mOrder(FreeModuleOrder::makeOrder(orderType, *basis.getPolyRing())),
mReducer(reducer),
mBasis(mRing, *mOrder, DivisorLookup::makeFactory(
- *ideal.getPolyRing(),
+ *basis.getPolyRing(),
divisorLookupType)->create(preferSparseReducers, true)
),
mSPairs(mBasis, preferSparseReducers),
mSPolyReductionCount(0)
{
// Reduce and insert the generators of the ideal into the starting basis
- size_t const idealSize = ideal.size();
+ size_t const basisSize = basis.size();
std::vector<std::unique_ptr<Poly> > polys;
- for (size_t gen = 0; gen != idealSize; ++gen)
- polys.push_back(make_unique<Poly>(*ideal.getPoly(gen)));
+ for (size_t gen = 0; gen != basisSize; ++gen)
+ polys.push_back(make_unique<Poly>(*basis.getPoly(gen)));
insertPolys(polys);
}
diff --git a/src/mathicgb/BuchbergerAlg.hpp b/src/mathicgb/BuchbergerAlg.hpp
index 39277ae..98c6b47 100755
--- a/src/mathicgb/BuchbergerAlg.hpp
+++ b/src/mathicgb/BuchbergerAlg.hpp
@@ -10,11 +10,13 @@
#include <ostream>
#include <vector>
+class Basis;
+
/// Calculates a classic Grobner basis using Buchberger's algorithm.
class BuchbergerAlg {
public:
BuchbergerAlg(
- const Ideal& ideal,
+ const Basis& basis,
FreeModuleOrderType orderType,
Reducer& reducer,
int divisorLookupType,
diff --git a/src/mathicgb/PolyBasis.cpp b/src/mathicgb/PolyBasis.cpp
index cf1b75a..4ed5546 100755
--- a/src/mathicgb/PolyBasis.cpp
+++ b/src/mathicgb/PolyBasis.cpp
@@ -1,5 +1,5 @@
#include "stdinc.h"
-#include "Ideal.hpp"
+#include "Basis.hpp"
#include "PolyBasis.hpp"
#include "DivisorLookup.hpp"
@@ -27,18 +27,18 @@ PolyBasis::~PolyBasis() {
}
}
-std::unique_ptr<Ideal> PolyBasis::initialIdeal() const {
- std::unique_ptr<Ideal> ideal(new Ideal(mRing));
- size_t const idealSize = size();
- for (size_t gen = 0; gen != idealSize; ++gen) {
+std::unique_ptr<Basis> PolyBasis::initialIdeal() const {
+ std::unique_ptr<Basis> basis(new Basis(mRing));
+ size_t const basisSize = size();
+ for (size_t gen = 0; gen != basisSize; ++gen) {
if (!retired(gen) && leadMinimal(gen)) {
std::unique_ptr<Poly> p(new Poly(mRing));
p->appendTerm(1, leadMonomial(gen));
- ideal->insert(std::move(p));
+ basis->insert(std::move(p));
}
}
- ideal->sort(mOrder);
- return ideal;
+ basis->sort(mOrder);
+ return basis;
}
void PolyBasis::insert(std::unique_ptr<Poly> poly) {
@@ -95,12 +95,12 @@ std::unique_ptr<Poly> PolyBasis::retire(size_t index) {
return poly;
}
-std::unique_ptr<Ideal> PolyBasis::toIdealAndRetireAll() {
- auto ideal = make_unique<Ideal>(ring());
+std::unique_ptr<Basis> PolyBasis::toBasisAndRetireAll() {
+ auto basis = make_unique<Basis>(ring());
for (size_t i = 0; i < size(); ++i)
if (!retired(i))
- ideal->insert(retire(i));
- return ideal;
+ basis->insert(retire(i));
+ return basis;
}
size_t PolyBasis::divisor(const_monomial mon) const {
diff --git a/src/mathicgb/PolyBasis.hpp b/src/mathicgb/PolyBasis.hpp
index b805591..faaf360 100755
--- a/src/mathicgb/PolyBasis.hpp
+++ b/src/mathicgb/PolyBasis.hpp
@@ -7,7 +7,7 @@
#include <memory>
class PolyRing;
-class Ideal;
+class Basis;
class FreeModuleOrder;
class PolyBasis {
@@ -22,8 +22,8 @@ public:
// Deletes the Poly's stored in the basis.
~PolyBasis();
- // Returns the initial monomial ideal of the basis (not the ideal).
- std::unique_ptr<Ideal> initialIdeal() const;
+ // Returns the initial monomial basis of the basis (not the basis).
+ std::unique_ptr<Basis> initialIdeal() const;
// Inserts a polynomial into the basis at index size().
// Lead monomials must be unique among basis elements.
@@ -78,10 +78,10 @@ public:
// to it, including the basis element polynomial, and marks it as retired.
std::unique_ptr<Poly> retire(size_t index);
- /// Returns an ideal containing all non-retired basis elements and
+ /// Returns an basis containing all non-retired basis elements and
/// retires all those basis elements. The point of the simultaneous
/// retirement is that this way no polynomials need be copied.
- std::unique_ptr<Ideal> toIdealAndRetireAll();
+ std::unique_ptr<Basis> toBasisAndRetireAll();
// Returns true of the basis element at index has been retired.
bool retired(size_t index) const {
diff --git a/src/mathicgb/SignatureGB.cpp b/src/mathicgb/SignatureGB.cpp
index b0dd13c..e8ecdec 100755
--- a/src/mathicgb/SignatureGB.cpp
+++ b/src/mathicgb/SignatureGB.cpp
@@ -3,7 +3,7 @@
#include "SignatureGB.hpp"
#include "FreeModuleOrder.hpp"
-#include "Ideal.hpp"
+#include "Basis.hpp"
#include "DivisorLookup.hpp"
#include "SigSPairs.hpp"
#include "PolyHeap.hpp"
@@ -13,7 +13,7 @@
int tracingLevel = 0;
SignatureGB::SignatureGB(
- Ideal&& ideal,
+ Basis&& basis,
FreeModuleOrderType typ,
Reducer::ReducerType reductiontyp,
int divlookup_type,
@@ -26,8 +26,8 @@ SignatureGB::SignatureGB(
):
mBreakAfter(0),
mPrintInterval(0),
- R(ideal.getPolyRing()),
- F(FreeModuleOrder::makeOrder(typ, *ideal.getPolyRing())),
+ R(basis.getPolyRing()),
+ F(FreeModuleOrder::makeOrder(typ, *basis.getPolyRing())),
mPostponeKoszul(postponeKoszul),
mUseBaseDivisors(useBaseDivisors),
stats_sPairSignaturesDone(0),
@@ -39,29 +39,29 @@ SignatureGB::SignatureGB(
stats_nsecs(0.0),
GB(make_unique<GroebnerBasis>(R, F.get(), divlookup_type, montable_type, preferSparseReducers)),
mKoszuls(make_unique<KoszulQueue>(F.get(), *R)),
- Hsyz(MonomialTableArray::make(R, montable_type, ideal.size(), !mPostponeKoszul)),
- Hsyz2(MonomialTableArray::make(R, montable_type, ideal.size(), !mPostponeKoszul)),
+ Hsyz(MonomialTableArray::make(R, montable_type, basis.size(), !mPostponeKoszul)),
+ Hsyz2(MonomialTableArray::make(R, montable_type, basis.size(), !mPostponeKoszul)),
reducer(Reducer::makeReducer(reductiontyp, *R)),
SP(make_unique<SigSPairs>(R, F.get(), GB.get(), Hsyz.get(), reducer.get(), mPostponeKoszul, mUseBaseDivisors, useSingularCriterionEarly, queueType))
{
MonoVector schreyer(monoid());
if (typ == 5 || typ == 4 || typ == 3 || typ == 2 || typ == 6 || typ == 7)
- for (size_t gen = 0; gen < ideal.size(); ++gen)
- schreyer.push_back(ideal.getPoly(gen)->getLeadMonomial());
+ for (size_t gen = 0; gen < basis.size(); ++gen)
+ schreyer.push_back(basis.getPoly(gen)->getLeadMonomial());
mProcessor = make_unique<MonoProcessor<Monoid>>(
typ == 2 || typ == 4 || typ == 6,
- ideal.size(),
+ basis.size(),
monoid(),
std::move(schreyer)
);
// Populate GB
- for (size_t j = 0; j < ideal.size(); j++)
+ for (size_t j = 0; j < basis.size(); j++)
GB->addComponent();
- for (size_t i = 0; i < ideal.size(); i++) {
+ for (size_t i = 0; i < basis.size(); i++) {
Poly *g = new Poly(*R);
- ideal.getPoly(i)->copy(*g);
+ basis.getPoly(i)->copy(*g);
g->makeMonic();
monomial sig = 0;
@@ -75,7 +75,7 @@ SignatureGB::SignatureGB(
}
// Populate SP
- for (size_t i = 0; i < ideal.size(); i++)
+ for (size_t i = 0; i < basis.size(); i++)
SP->newPairs(i);
if (tracingLevel >= 2) {
diff --git a/src/mathicgb/SignatureGB.hpp b/src/mathicgb/SignatureGB.hpp
index f7e95c3..84995c0 100755
--- a/src/mathicgb/SignatureGB.hpp
+++ b/src/mathicgb/SignatureGB.hpp
@@ -3,10 +3,6 @@
#ifndef _sig_gb_h_
#define _sig_gb_h_
-#ifdef Win32
-#include "StdAfx.h"
-#endif
-
#include "PolyRing.hpp"
#include "MTArray.hpp"
#include "GroebnerBasis.hpp"
@@ -27,7 +23,7 @@ public:
typedef Monoid::MonoVector MonoVector;
SignatureGB(
- Ideal&& ideal,
+ Basis&& basis,
FreeModuleOrderType typ,
Reducer::ReducerType reductiontyp,
int divlookup_type,
diff --git a/src/mathicgb/io-util.cpp b/src/mathicgb/io-util.cpp
index 514ed1c..4cbe770 100755
--- a/src/mathicgb/io-util.cpp
+++ b/src/mathicgb/io-util.cpp
@@ -15,7 +15,7 @@
#include "SignatureGB.hpp"
#include "MTArray.hpp"
-#include "Ideal.hpp"
+#include "Basis.hpp"
#include "PolyBasis.hpp"
std::unique_ptr<Poly> polyParseFromString(const PolyRing *R, const std::string &s)
@@ -33,10 +33,10 @@ std::string toString(const Poly *g)
return o.str();
}
-std::unique_ptr<Ideal> idealParseFromString(std::string str)
+std::unique_ptr<Basis> basisParseFromString(std::string str)
{
std::istringstream i(str);
- return std::unique_ptr<Ideal>(Ideal::parse(i));
+ return std::unique_ptr<Basis>(Basis::parse(i));
}
std::unique_ptr<PolyRing> ringFromString(std::string ringinfo)
@@ -103,7 +103,7 @@ std::string toString(MonomialTableArray* H)
return o.str();
}
-std::string toString(Ideal *I)
+std::string toString(Basis *I)
{
std::ostringstream o;
for (size_t i=0; i<I->size(); i++)
diff --git a/src/mathicgb/io-util.hpp b/src/mathicgb/io-util.hpp
index ce8b857..d4368c2 100755
--- a/src/mathicgb/io-util.hpp
+++ b/src/mathicgb/io-util.hpp
@@ -9,7 +9,7 @@ class Poly;
class GroebnerBasis;
class MonomialTableArray;
class PolyBasis;
-class Ideal;
+class Basis;
std::unique_ptr<PolyRing> ringFromString(std::string ringinfo);
monomial monomialFromString(const PolyRing *R, std::string mon);
@@ -23,10 +23,10 @@ std::string monomialToString(const PolyRing *R, const Monomial& mon);
std::string toString(GroebnerBasis *);
std::string toString(MonomialTableArray *);
std::string toString(GroebnerBasis *, int unused); // also displays signature
-std::string toString(Ideal *);
+std::string toString(Basis *);
std::string toString(const Poly *);
-std::unique_ptr<Ideal> idealParseFromString(std::string str);
+std::unique_ptr<Basis> basisParseFromString(std::string str);
std::unique_ptr<Poly> polyParseFromString(const PolyRing *R, const std::string &s);
void output(std::ostream &o, const PolyBasis &I);
diff --git a/src/test/F4MatrixBuilder.cpp b/src/test/F4MatrixBuilder.cpp
index 5cff0b4..93d62fc 100755
--- a/src/test/F4MatrixBuilder.cpp
+++ b/src/test/F4MatrixBuilder.cpp
@@ -4,7 +4,7 @@
#include "mathicgb/PolyRing.hpp"
#include "mathicgb/F4MatrixBuilder.hpp"
#include "mathicgb/FreeModuleOrder.hpp"
-#include "mathicgb/Ideal.hpp"
+#include "mathicgb/Basis.hpp"
#include "mathicgb/PolyBasis.hpp"
#include "mathicgb/io-util.hpp"
#include "mathicgb/mtbb.hpp"
@@ -44,7 +44,7 @@ namespace {
private:
std::unique_ptr<PolyRing> mRing;
- Ideal mIdeal;
+ Basis mIdeal;
std::unique_ptr<FreeModuleOrder> mOrder;
PolyBasis mBasis;
std::unique_ptr<F4MatrixBuilder> mBuilder;
diff --git a/src/test/FreeModuleOrderTest.cpp b/src/test/FreeModuleOrderTest.cpp
index 997c88b..0ec45c2 100755
--- a/src/test/FreeModuleOrderTest.cpp
+++ b/src/test/FreeModuleOrderTest.cpp
@@ -1,22 +1,22 @@
#include "mathicgb/stdinc.h"
#include "mathicgb/PolyRing.hpp"
-#include "mathicgb/Ideal.hpp"
+#include "mathicgb/Basis.hpp"
#include "mathicgb/FreeModuleOrder.hpp"
#include "mathicgb/io-util.hpp"
#include <gtest/gtest.h>
#include <algorithm>
void runTest(
- const char* idealStr,
+ const char* basisStr,
const char* signatureStr,
const char* correctStr,
int orderType
) {
std::string line;
- std::unique_ptr<Ideal> ideal = idealParseFromString(idealStr);
- const PolyRing* ring = ideal->getPolyRing();
+ std::unique_ptr<Basis> basis = basisParseFromString(basisStr);
+ const PolyRing* ring = basis->getPolyRing();
std::vector<monomial> sigs;
std::vector<PreSPair> pairs;
@@ -44,7 +44,7 @@ void runTest(
MATHICGB_ASSERT(sigs.size() == pairs.size());
std::unique_ptr<FreeModuleOrder> order
- (FreeModuleOrder::makeOrder(orderType, *ideal->getPolyRing()));
+ (FreeModuleOrder::makeOrder(orderType, *basis->getPolyRing()));
order->sortSignatures(pairs);
for (size_t i = 0; i < pairs.size(); ++i) {
ring->freeMonomial(pairs[i].signature);
@@ -69,7 +69,7 @@ void runTest(
}
TEST(FreeModuleOrder, One) {
- const char* ideal =
+ const char* basis =
"32003 3 "
"1 1 1 1 "
"3 "
@@ -86,11 +86,11 @@ TEST(FreeModuleOrder, One) {
"bc<1>\n" // 6
"ab2c<2>\n"; // 7
- runTest(ideal, sigs, "0 1 6 4 5 3 7 2", 1);
- //runTest(ideal, sigs, "0 6 5 1 4 3 7 2", 2);
- //runTest(ideal, sigs, "0 6 5 1 7 4 3 2", 3);
- //runTest(ideal, sigs, "0 6 5 1 4 3 7 2", 4);
- //runTest(ideal, sigs, "0 6 5 1 4 7 3 2", 5);
- //runTest(ideal, sigs, "1 4 3 2 0 6 5 7", 6);
- //runTest(ideal, sigs, "7 0 6 5 1 4 3 2", 7);
+ runTest(basis, sigs, "0 1 6 4 5 3 7 2", 1);
+ //runTest(basis, sigs, "0 6 5 1 4 3 7 2", 2);
+ //runTest(basis, sigs, "0 6 5 1 7 4 3 2", 3);
+ //runTest(basis, sigs, "0 6 5 1 4 3 7 2", 4);
+ //runTest(basis, sigs, "0 6 5 1 4 7 3 2", 5);
+ //runTest(basis, sigs, "1 4 3 2 0 6 5 7", 6);
+ //runTest(basis, sigs, "7 0 6 5 1 4 3 2", 7);
}
diff --git a/src/test/QuadMatrixBuilder.cpp b/src/test/QuadMatrixBuilder.cpp
index 82cff74..816117b 100755
--- a/src/test/QuadMatrixBuilder.cpp
+++ b/src/test/QuadMatrixBuilder.cpp
@@ -5,7 +5,7 @@
#include "mathicgb/QuadMatrixBuilder.hpp"
#include "mathicgb/io-util.hpp"
#include "mathicgb/FreeModuleOrder.hpp"
-#include "mathicgb/Ideal.hpp"
+#include "mathicgb/Basis.hpp"
#include "mathicgb/QuadMatrix.hpp"
#include <gtest/gtest.h>
@@ -148,8 +148,8 @@ TEST(QuadMatrixBuilder, ColumnQuery) {
TEST(QuadMatrixBuilder, SortColumns) {
// construct builder and reverse lex order
std::unique_ptr<PolyRing> ring(ringFromString("32003 6 1\n1 1 1 1 1 1"));
- Ideal ideal(*ring);
- std::unique_ptr<FreeModuleOrder> order(FreeModuleOrder::makeOrder(1, *ideal.getPolyRing()));
+ Basis basis(*ring);
+ std::unique_ptr<FreeModuleOrder> order(FreeModuleOrder::makeOrder(1, *basis.getPolyRing()));
// one row top, no rows bottom, no columns
{
diff --git a/src/test/gb-test.cpp b/src/test/gb-test.cpp
index 6eca92b..6a6e9b0 100755
--- a/src/test/gb-test.cpp
+++ b/src/test/gb-test.cpp
@@ -3,7 +3,7 @@
#include "mathicgb/stdinc.h"
#include "mathicgb/Poly.hpp"
-#include "mathicgb/Ideal.hpp"
+#include "mathicgb/Basis.hpp"
#include "mathicgb/MTArray.hpp"
#include "mathicgb/MonTableNaive.hpp"
#include "mathicgb/io-util.hpp"
@@ -31,7 +31,7 @@ TEST(IO, ideal) {
-bc2+a2e \
";
- std::unique_ptr<Ideal> I = idealParseFromString(idealA_fromStr_format);
+ std::unique_ptr<Basis> I = basisParseFromString(idealA_fromStr_format);
EXPECT_EQ(" -bc+ad\n -b2+af\n -bc2+a2e\n", toString(I.get()));
}
@@ -286,7 +286,7 @@ spairQueue reducerType divLookup monTable buchberger postponeKoszul useBaseDivis
// check that we have a valid reducer type
Reducer::ReducerType red = Reducer::ReducerType(reducerType);
MATHICGB_ASSERT(static_cast<int>(red) == reducerType);
- std::unique_ptr<Ideal> I(idealParseFromString(idealStr));
+ std::unique_ptr<Basis> I(basisParseFromString(idealStr));
MATHICGB_ASSERT
(Reducer::makeReducerNullOnUnknown(red, I->ring()).get() != 0);
@@ -301,7 +301,7 @@ spairQueue reducerType divLookup monTable buchberger postponeKoszul useBaseDivis
alg.setUseAutoTailReduction(autoTailReduce);
alg.setSPairGroupSize(sPairGroupSize);
alg.computeGrobnerBasis();
- std::unique_ptr<Ideal> initialIdeal =
+ std::unique_ptr<Basis> initialIdeal =
alg.basis().initialIdeal();
EXPECT_EQ(initialIdealStr, toString(initialIdeal.get()))
<< reducerType << ' ' << divLookup << ' '
diff --git a/src/test/poly-test.cpp b/src/test/poly-test.cpp
index 5c12e15..928d505 100755
--- a/src/test/poly-test.cpp
+++ b/src/test/poly-test.cpp
@@ -7,7 +7,7 @@
#include <sstream>
#include "mathicgb/Poly.hpp"
-#include "mathicgb/Ideal.hpp"
+#include "mathicgb/Basis.hpp"
#include "mathicgb/MonTableNaive.hpp"
#include "mathicgb/MonTableKDTree.hpp"
#include "mathicgb/MonTableDivList.hpp"
@@ -659,7 +659,7 @@ TEST(OldMonomial, findSignatures) {
TEST(Ideal,readwrite) {
// This also tests Poly::iterator
- std::unique_ptr<Ideal> I = idealParseFromString(ideal1);
+ std::unique_ptr<Basis> I = basisParseFromString(ideal1);
size_t ngens = I->viewGenerators().size();
EXPECT_TRUE(2 == ngens);
@@ -678,7 +678,7 @@ TEST(Ideal,readwrite) {
TEST(Poly,lead) {
// This also tests Poly::iterator, Poly::read, Poly::write
- std::unique_ptr<Ideal> I = idealParseFromString(ideal1);
+ std::unique_ptr<Basis> I = basisParseFromString(ideal1);
std::unique_ptr<const PolyRing> R(I->getPolyRing());
monomial lm = stringToMonomial(R.get(), "ab");
EXPECT_TRUE(R->monomialEQ(lm, I->getPoly(0)->getLeadMonomial()));
@@ -691,9 +691,9 @@ TEST(Poly,lead) {
// Test reducer code /////////
//////////////////////////////
-std::unique_ptr<Poly> multIdealByPolyReducer(int typ, const Ideal& ideal, const Poly& g)
+std::unique_ptr<Poly> multIdealByPolyReducer(int typ, const Basis& basis, const Poly& g)
{
- const PolyRing& R = ideal.ring();
+ const PolyRing& R = basis.ring();
auto poly = make_unique<Poly>(R);
std::unique_ptr<Reducer> H = Reducer::makeReducer(static_cast<Reducer::ReducerType>(typ), R);
for (Poly::const_iterator i = g.begin(); i != g.end(); ++i) {
@@ -701,7 +701,7 @@ std::unique_ptr<Poly> multIdealByPolyReducer(int typ, const Ideal& ideal, const
R.monomialCopy(i.getMonomial(), mon);
int x = R.monomialGetComponent(mon);
R.monomialChangeComponent(mon, 0);
- std::unique_ptr<Poly> h(ideal.getPoly(x)->copy());
+ std::unique_ptr<Poly> h(basis.getPoly(x)->copy());
h->multByTerm(i.getCoefficient(), mon);
R.monomialSetIdentity(mon);
@@ -715,13 +715,13 @@ std::unique_ptr<Poly> multIdealByPolyReducer(int typ, const Ideal& ideal, const
void testPolyReducer(
Reducer::ReducerType reducerType,
- const Ideal& ideal,
+ const Basis& basis,
const std::string& f,
const std::string& ans
) {
- const PolyRing& ring = *ideal.getPolyRing();
+ const PolyRing& ring = *basis.getPolyRing();
std::unique_ptr<Poly> g = polyParseFromString(&ring, f);
- std::unique_ptr<Poly> h = multIdealByPolyReducer(reducerType, ideal, *g);
+ std::unique_ptr<Poly> h = multIdealByPolyReducer(reducerType, basis, *g);
if (!h->isZero()) {
Poly::iterator prev = h->begin();
Poly::iterator it = prev;
@@ -740,7 +740,7 @@ TEST(Reducer, insert) {
// use this last poly to determine what to add to the heap
// at the end, take the value of the heap, compare to answer
- std::unique_ptr<Ideal> I = idealParseFromString(ideal2); // charac is 32003
+ std::unique_ptr<Basis> I = basisParseFromString(ideal2); // charac is 32003
for (int typ = 0; typ <= 30; ++typ) {
Reducer::ReducerType red = Reducer::ReducerType(typ);
if (static_cast<int>(red) != typ ||
--
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