Directories
	bibasis
	f4
	gb-f4
	interface
	NCAlgebras
	NCResolutions
	schreyer-resolution
	unit-tests

Files
	aring-CC.cpp
	aring-CC.hpp
	M2::ARingCC — machine-precision complex numbers (pair of doubles).
	aring-CCC.cpp
	aring-CCC.hpp
	M2::ARingCCC — arbitrary-precision complex numbers (pair of MPFR floats).
	aring-CCi.cpp
	aring-CCi.hpp
	M2::ARingCCi — certified complex intervals as Cartesian rectangles of MPFI intervals.
	aring-gf-flint-big.cpp
	aring-gf-flint-big.hpp
	M2::ARingGFFlintBig — arbitrary-degree GF(p^k) via FLINT fq_nmod.
	aring-gf-flint.cpp
	aring-gf-flint.hpp
	M2::ARingGFFlint — small GF(p^k) via FLINT Zech-logarithm tables.
	aring-glue.hpp
	ConcreteRing<RingType> — the templated bridge between aring and the legacy Ring API.
	aring-m2-gf.cpp
	aring-m2-gf.hpp
	M2::ARingGFM2 — native engine Galois field, no FLINT dependency.
	aring-qq-flint.cpp
	aring-qq-flint.hpp
	M2::ARingQQFlint — rationals backed by FLINT's fmpq with small-value inlining.
	aring-qq-gmp.cpp
	aring-qq-gmp.hpp
	M2::ARingQQGMP — arbitrary-precision rationals backed straight by GMP mpq_t.
	aring-qq.hpp
	Tiny dispatcher header that picks the default ARingQQ from among the QQ aring implementations.
	aring-RR.cpp
	aring-RR.hpp
	M2::ARingRR — machine-precision real numbers (IEEE 754 double).
	aring-RRi.cpp
	aring-RRi.hpp
	M2::ARingRRi — certified real intervals [a, b] with MPFR endpoints, MPFI arithmetic.
	aring-RRR.cpp
	aring-RRR.hpp
	M2::ARingRRR — arbitrary-precision real numbers backed by MPFR.
	aring-tower.cpp
	aring-tower.hpp
	M2::ARingTower — iterated finite-field extension tower for very large GF(p^k).
	aring-translate.hpp
	Cross-ring coercion templates: mypromote / mylift between two aring rings, and get_from_* from an external M2 numeric type into an aring.
	aring-wrap.cpp
	aring-wrap.hpp
	RElementWrap<RingType> and AConcreteRing<RingType> — abandoned scaffolding for an abstract ARing / RElement base.
	aring-zz-flint.cpp
	aring-zz-flint.hpp
	M2::ARingZZ — FLINT-backed arbitrary-precision integers with small-value inlining.
	aring-zz-gmp.cpp
	aring-zz-gmp.hpp
	M2::ARingZZGMP — aring integer ring backed straight by GMP mpz_t.
	aring-zzp-ffpack.cpp
	aring-zzp-ffpack.hpp
	M2::ARingZZpFFPACK — Z/p via FFLAS-FFPACK's Givaro::Modular<double> field.
	aring-zzp-flint.cpp
	aring-zzp-flint.hpp
	M2::ARingZZpFlint — Z/p via FLINT's nmod_t precomputed-reciprocal reduction.
	aring-zzp.cpp
	aring-zzp.hpp
	M2::ARingZZp — portable Z/p for small primes via log / exp tables.
	aring.cpp
	aring.hpp
	Shared base of the aring framework (namespace M2) that unifies the engine's coefficient rings.
	assprime.cpp
	assprime.hpp
	AssociatedPrimes — codimension and minimal-codimension associated primes of a monomial ideal.
	BasicPoly.cpp
	BasicPoly.hpp
	Minimal, portable polynomial value type used where heavier engine types would be overkill.
	BasicPolyList.cpp
	BasicPolyList.hpp
	Ring-agnostic polynomial-list transport type plus its streaming collector and emitter.
	BasicPolyListParser.cpp
	BasicPolyListParser.hpp
	Parsers from text (string or file) into a BasicPolyList, including the Msolve input format.
	betti.cpp
	betti.hpp
	BettiDisplay — engine-side container and renderer for the Betti table of a free resolution.
	buffer.cpp
	buffer.hpp
	Append-only GC-backed byte buffer used throughout the engine for text output.
	coeffrings.cpp
	coeffrings.hpp
	Two SimpleARing-style coefficient adapters: CoefficientRingZZp and CoefficientRingR.
	comb.cpp
	comb.hpp
	Subsets — combinatorial-number-system encoding of p-subsets of {0,...,n-1}.
	comp-gb-declared.cpp
	comp-gb-declared.hpp
	GBDeclared — a user-asserted Groebner basis the engine accepts without computing.
	comp-gb-proxy.cpp
	comp-gb-proxy.hpp
	GBProxy — legacy indirection wrapper around another GBComputation (deprecated).
	comp-gb.cpp
	comp-gb.hpp
	GBComputation — abstract base of every Groebner-basis algorithm in the engine.
	comp-res.cpp
	comp-res.hpp
	ResolutionComputation — abstract base for every free-resolution algorithm in the engine.
	comp.cpp
	comp.hpp
	Abstract Computation base class — stop-condition machinery for incremental engine work.
	complex.c
	complex.h
	gmp_CC C primitives: arithmetic on arbitrary-precision complex values (pair of MPFR reals).
	cra.cpp
	cra.hpp
	ChineseRemainder — CRT lifting and rational reconstruction primitives.
	debug.cpp
	debug.hpp
	Debugger-callable d* helpers that pretty-print engine values to stderr.
	defgroups.h
	Pure Doxygen scaffolding — the \mainpage text and every \defgroup used in engine docs.
	det.cpp
	det.hpp
	Determinants and minors of Matrix values via Bareiss, cofactor, or dynamic-programming strategies.
	dmat-ffpack.cpp
	Legacy FFLAS-FFPACK dispatcher for DMat<R> — entirely #if 0'd out, retained as a history marker.
	dmat-gf-flint-big.hpp
	DMat<M2::ARingGFFlintBig> — dense GF matrices stored in a FLINT fq_nmod_mat_t.
	dmat-gf-flint.hpp
	DMat<M2::ARingGFFlint> — dense GF matrices stored in a FLINT fq_zech_mat_t.
	dmat-lu-inplace.hpp
	DMatLUinPlace<RT> — the LU worker that DMatLinAlg<RT> delegates to, with RR / CC / GF specialisations.
	dmat-lu-qq.hpp
	DMatLinAlg<M2::ARingQQ> — rational dense LU routed through FLINT fmpq_mat / fmpz_mat.
	dmat-lu-zzp-ffpack.hpp
	DMatLinAlg<ARingZZpFFPACK> and the ffpackInterface namespace — FFLAS-FFPACK-backed Z/p linear algebra.
	dmat-lu-zzp-flint.hpp
	DMatLinAlg<M2::ARingZZpFlint> — dense Z/p linear algebra routed through FLINT nmod_mat_*.
	dmat-lu.hpp
	Umbrella header for DMat<R> LU — declares DMatLinAlg<RingType> and pulls in every back-end variant.
	dmat-qq-flint.hpp
	DMat<M2::ARingQQFlint> — dense rational matrices stored in a FLINT fmpq_mat_t.
	dmat-qq-interface-flint.hpp
	Translation bridge that lets GMP-backed DMat<ARingQQ> borrow FLINT matrix arithmetic.
	dmat-zz-flint.hpp
	DMat<M2::ARingZZ> — dense integer matrices stored in a FLINT fmpz_mat_t.
	dmat-zzp-flint.hpp
	DMat<M2::ARingZZpFlint> — dense Z/p matrices stored in a FLINT nmod_mat_t.
	dmat.cpp
	dmat.hpp
	DMat<ACoeffRing> — dense-matrix template plus the umbrella that wires in every per-ring specialisation.
	dpoly.cpp
	dpoly.hpp
	Native univariate polynomial arithmetic over QQ extensions and finite fields.
	eigen.cpp
	eigen.hpp
	EigenM2 namespace — Eigen3-backed SVD / eigenvalues / eigenvectors / least-squares for DMat<R> over RR, CC, RRR, CCC.
	engine-includes.hpp
	Engine-wide include prelude — a single point of truth for portability shims.
	engine.cpp
	Tiny translation unit that holds the engine's process-global singletons and the IM2_initialize boot hook.
	engine.h
	Legacy umbrella header that re-exports the per-area interface headers and carries the still-unmigrated entry points.
	error.c
	error.h
	Engine error-reporting primitives: ERROR, INTERNAL_ERROR, error, error_message.
	Eschreyer.cpp
	Implementation of GBMatrix and GBKernelComputation — the polynomial-at-a-time syzygy engine.
	Eschreyer.hpp
	Older Schreyer-style kernel computation, predecessor of schreyer-resolution/.
	exceptions.hpp
	namespace exc — internal C++ exception types and the TRY / CATCH macro pair.
	ExponentList.cpp
	ExponentList.hpp
	Variable-length sparse (variable, exponent) encoding of monomials.
	ExponentVector.hpp
	Dense exponent-vector template [e_0, ..., e_{nvars-1}] for monomial operations.
	exptable.c
	exptable.h
	Hash table specialisation for (exponent vector, unsigned long) pairs.
	finalize.cpp
	finalize.hpp
	intern_* helpers that register long-lived engine objects with bdwgc finalisers.
	fplll-interface.cpp
	fplll-interface.hpp
	Engine-side wrapper around the external fplll lattice-reduction library.
	frac.cpp
	frac.hpp
	FractionField — field of fractions of an integral domain, with on-the-fly normalisation.
	fractionfreeLU.cpp
	fractionfreeLU.hpp
	FF_LUComputation — Bareiss-style fraction-free LU over an integral domain.
	franzi-brp-test.cpp
	franzi-brp.cpp
	franzi-brp.hpp
	brMonomial — bit-packed Boolean-ring monomials for the Hinkelmann GB engine.
	franzi-gb.cpp
	franzi-interface.cpp
	freemod.cpp
	freemod.hpp
	FreeModule — finite-rank free module R^n, the type-level anchor for every Matrix.
	gauss.cpp
	gauss.hpp
	GaussElimComputation — Gaussian elimination GB / submodule strategy over a field.
	gb-default.cpp
	gb-default.hpp
	gbA — the engine's default Buchberger-style Groebner-basis algorithm.
	gb-homog2.cpp
	gb-homog2.hpp
	GB_comp — Buchberger GB specialised to homogeneous input.
	gb-sugarless.cpp
	gb-sugarless.hpp
	GBinhom_comp — Buchberger GB without the sugar heuristic, primarily for inhomogeneous input.
	gb-toric.cpp
	gb-toric.hpp
	binomialGB_comp — Buchberger GB specialised to binomial / toric ideals.
	gb-walk.cpp
	gb-walk.hpp
	GBWalker — generic Groebner-walk strategy that transports a basis between term orders.
	gbring.cpp
	gbring.hpp
	GBRing and gbvector — the GB-tuned polynomial-ring view used by classical Buchberger code.
	gbweight.cpp
	gbweight.hpp
	GBWeight — packed-weight evaluator that drives S-pair selection.
	geobucket.hpp
	geobucket<FREEMODULETYPE, VECTYPE> — size-quadrupling bucket accumulator for fast polynomial sums.
	geopoly.hpp
	polyheap — polynomial-specialised geometric heap for reduction accumulators.
	geovec.hpp
	vecHeap — geometric heap specialised for accumulating vec values.
	GF.cpp
	GF.hpp
	Legacy Ring-based Galois field with explicit Zech-style lookup tables.
	godboltTest.cpp
	Standalone log / exp / Zech-table scratch file for Z/p at p = 101, not part of the build.
	hash.hpp
	EngineObject / MutableEngineObject — shared bases that supply the hash an M2 interpreter object expects.
	hermite.cpp
	hermite.hpp
	HermiteComputation — Hermite normal form over ZZ, the ZZ-analogue of GaussElimComputation.
	hilb.cpp
	hilb.hpp
	Hilbert-series numerator via the Bigatti-Caboara-Robbiano recursion.
	imonorder.cpp
	imonorder.hpp
	Internal (runtime) form of a monomial ordering.
	int-bag.cpp
	int-bag.hpp
	int_bag / Bag — minimal (payload, varpower monomial) carrier shared by monomial-ideal code.
	interreduce.cpp
	interreduce.hpp
	Interreducer — skeleton class for inter-reducing a list of gbvector* elements (currently unused).
	interrupted.cpp
	interrupted.hpp
	system_interrupted() — thread-safe polling predicate for Ctrl+C handling.
	lapack.cpp
	lapack.hpp
	Engine bridge into LAPACK for RR / CC dense linear algebra.
	LLL.cpp
	LLL.hpp
	Lenstra-Lenstra-Lovász integer lattice basis reduction, in place on a MutableMatrix.
	localring.cpp
	localring.hpp
	LocalRing — localisation of a polynomial ring at a prime ideal P.
	M2FreeAlgebra.cpp
	M2FreeAlgebra.hpp
	Ring-shaped wrapper that exposes a non-commutative FreeAlgebra to the rest of the engine.
	M2FreeAlgebraQuotient.cpp
	M2FreeAlgebraQuotient.hpp
	Ring-shaped façade around a non-commutative quotient algebra.
	m2tbb.hpp
	Engine TBB shim — single point of inclusion for every parallel primitive.
	mat-arith.hpp
	Templated matrix arithmetic for DMat<R> / SMat<R> plus the MatrixWindow / SubMatrix view types.
	mat-elem-ops.hpp
	MatElementaryOps<MT> — row / column primitives templated over dense or sparse matrix storage.
	mat-linalg.hpp
	Templated DMat<R> linear algebra: LU, rank, determinant, solve, inverse, nullSpace.
	mat-util.hpp
	Generic helpers (displayMat, concatenateMatrices) for DMat / SMat matrices.
	mat.cpp
	mat.hpp
	MutableMatrix — abstract base of every mutable matrix the engine hands across the boundary.
	matrix-con.cpp
	matrix-con.hpp
	MatrixConstructor — the mutable builder that produces an immutable Matrix.
	matrix-kbasis.cpp
	KBasis — k-vector-space basis of a graded module restricted to chosen degrees.
	matrix-ncbasis.cpp
	matrix-ncbasis.hpp
	ncBasis — non-commutative analogue of basis(d, M) over NCAlgebras/FreeAlgebra.
	matrix-sort.cpp
	MatrixSorter — compute the column permutation that sorts a Matrix by degree / leading term.
	matrix-stream.cpp
	matrix-stream.hpp
	MatrixStream — term-by-term streaming construction of a Matrix.
	matrix-symm.cpp
	SymmMatrix — compute the p-th symmetric power of a one-row Matrix.
	matrix.cpp
	matrix.hpp
	Matrix — the engine's immutable homomorphism F -> G between free modules.
	mem.cpp
	mem.hpp
	stash and doubling_stash — legacy size-class allocator interfaces, now stubbed to plain GC allocation.
	memory-status.cpp
	memory-status.hpp
	Placeholder memory-statistics hooks: memorystat1 / memorystat2 / memorystat3.
	MemoryBlock.hpp
	Bump-pointer arena allocator for transient inner-loop allocations.
	monideal-minprimes.cpp
	monideal-minprimes.hpp
	MinimalPrimes — minimal primes of a MonomialIdeal via a two-phase state machine.
	monideal.cpp
	monideal.hpp
	MonomialIdeal — exponent-vector-only representation of an ideal generated by monomials.
	monoid.cpp
	monoid.hpp
	Monoid — variable count, naming, grading, and monomial order of a polynomial ring.
	monomial-collection.cpp
	monomial-collection.hpp
	IntsSet<Configuration> — set of monomials with insert / lookup / insertion-ordered iteration.
	monomial-sets.cpp
	monomial-sets.hpp
	MonomialSetFixedSize / MonomialSetVarSize / MonomialCollection* / MonomialMemorySpace — monomial-interning helpers.
	monomial.cpp
	monomial.hpp
	EngineMonomial — opaque single-monomial value type used at the engine boundary.
	monordering.hpp
	MonomialOrderings — C++ factories for the declarative MonomialOrdering blocks.
	monsort.cpp
	monsort.hpp
	QuickSorter<Sorter> — ring-agnostic in-place sort over a duck-typed adapter.
	montable.cpp
	montable.hpp
	MonomialTable — leading-monomial divisor index used by the GB reducer.
	montableZZ.cpp
	montableZZ.hpp
	MonomialTableZZ — coefficient-aware leading-monomial index for ZZ-coefficient Groebner bases.
	mpreal.h
	Vendored Holoborodko mpfr::mpreal C++ wrapper over MPFR.
	mutablecomplex.cpp
	mutablecomplex.hpp
	MutableComplex — in-place chain complex of MutableMatrix differentials.
	mutablemat-defs.hpp
	MutableMat<Mat> — the templated bridge from DMat / SMat to the abstract MutableMatrix.
	mutablemat-imp.hpp
	Template implementations of MutableMat<Mat> — linear-algebra methods plus the SLP-evaluator bridge.
	mutablemat.hpp
	Umbrella header that ties together MutableMat declarations, implementations, and the SLP variant.
	myalloc.cpp
	myalloc.hpp
	AllocLogger / StatsAllocator — single-threaded debug/benchmark instrumentation.
	NAG.cpp
	NAG.hpp
	Numerical Algebraic Geometry: homotopy continuation PathTracker and supporting numeric types.
	newdelete.hpp
	our_new_delete — per-class opt-in routing of new / delete through bdwgc.
	ntl-debugio.cpp
	Debugger-callable dntl_* printers for NTL mat_ZZ and ZZ values.
	ntl-interface.cpp
	ntl-interface.hpp
	Engine bridge into NTL — type conversions and the NTL-backed LLL entry point.
	ntl-internal.cpp
	overflow-test.cpp
	Standalone microbenchmark and overflow-trip harness for the safe:: primitives in overflow.hpp.
	overflow.cpp
	overflow.hpp
	Overflow-checked integer arithmetic for monomial exponents and degree sums.
	pfaff.cpp
	pfaff.hpp
	PfaffianComputation — Pfaffians of skew-symmetric matrices via row expansion.
	points.cpp
	points.hpp
	PointsComputation<CoeffRing>::points — ideal and standard-monomial basis of a finite point set.
	poly.cpp
	poly.hpp
	Concrete commutative PolyRing — standard polynomial ring inheriting from PolyRingFlat.
	Polynomial.cpp
	Polynomial.hpp
	Modern Monom / Polynomial value types shared by NC algebras and the refactored F4.
	PolynomialStream.hpp
	Type aliases and the (currently disabled) C++20 concept that streaming polynomial consumers implement.
	polyquotient.cpp
	polyquotient.hpp
	PolyRingQuotient — polynomial ring modulo an ideal whose Groebner basis is known.
	polyring.cpp
	polyring.hpp
	PolynomialRing — abstract polynomial-ring base, the engine's most-reused class.
	qring.cpp
	qring.hpp
	QRingInfo family — bookkeeping plus normal-form machinery attached to a PolyRingQuotient for R / I reductions.
	reader.cpp
	reader.hpp
	M2::Reader<RingType> — parse a single ring element from a std::istream.
	reducedgb-field-local.cpp
	reducedgb-field-local.hpp
	reducedgb-field.cpp
	reducedgb-field.hpp
	reducedgb-marked.cpp
	reducedgb-marked.hpp
	reducedgb-ZZ.cpp
	reducedgb-ZZ.hpp
	reducedgb.cpp
	reducedgb.hpp
	ReducedGB — abstract base for the canonicalising reduction pass that follows GB computation.
	relem.cpp
	relem.hpp
	RingElement — tagged (Ring*, ring_elem) pair, the engine's universal element type.
	res-a0-pair.hpp
	res-a0-poly.cpp
	res-a0-poly.hpp
	res-a0.cpp
	res-a0.hpp
	res2_comp — original (1996) free-resolution engine using explicit pair processing.
	res-a1-poly.cpp
	res-a1-poly.hpp
	res-a1.cpp
	res-a1.hpp
	res-a2-gb.cpp
	res-a2.cpp
	res-a2.hpp
	ring-vecs.cpp
	Ring's vec-shaped operations — construction, traversal, arithmetic on sparse columns.
	ring.cpp
	ring.hpp
	Ring — the legacy abstract base class for every coefficient and polynomial ring.
	ringelem.cpp
	ringelem.hpp
	ring_elem — the universal value type carried by every Ring* in the engine.
	ringmap.cpp
	ringmap.hpp
	RingMap — engine representation of a ring homomorphism.
	sagbi.cpp
	sagbi.hpp
	sagbi — subduction helpers for canonical-subalgebra (SAGBI) bases.
	schorder.cpp
	schorder.hpp
	SchreyerOrder — per-basis-element data backing the Schreyer order on a free module.
	schur-poly-heap.hpp
	schur_poly_heap — geometric-bucket accumulator specialised for SchurRing2 polynomials.
	schur.cpp
	schur.hpp
	SchurRing — symmetric-function ring with Schur-basis multiplication via Littlewood-Richardson.
	schur2.cpp
	schur2.hpp
	SchurRing2 — refactored Schur ring with length-prefixed partitions and an explicit Ring base.
	schurSn.cpp
	schurSn.hpp
	SchurSnRing — SchurRing2 subclass intended for symmetric-group representation rings (Kronecker product is a stub).
	skew.cpp
	skew.hpp
	SkewMultiplication — configuration object naming the skew-commuting variables of a ring.
	skewpoly.cpp
	skewpoly.hpp
	SkewPolynomialRing — polynomial ring with a designated set of anticommuting variables.
	SLP-defs.hpp
	Type declarations for the SLP DAG, its evaluator hierarchy, and the homotopy abstraction.
	SLP-imp.hpp
	Templated SLEvaluatorConcrete<RT> — the per-ring SLP evaluator implementation.
	SLP.cpp
	SLP.hpp
	Public umbrella header for the templated straight-line-program evaluator (SLProgram / SLEvaluatorConcrete).
	smat.hpp
	SMat<ACoeffRing> — column-oriented sparse matrix template, dual of DMat<R>.
	solvable.cpp
	solvable.hpp
	SolvableAlgebra — scaffolding for a PBW algebra x_j x_i = x_i x_j + q_{ij} (multiplication unimplemented).
	spair.cpp
	spair.hpp
	gb_elem / s_pair / s_pair_heap — basis-element record, S-pair work unit, and S-pair priority queue for Buchberger-style GB.
	style.hpp
	Engine-wide stylistic constants: LT / EQ / GT codes, INTSIZE, GEOHEAP_SIZE.
	table.c
	table.h
	text-io.cpp
	text-io.hpp
	Text-formatting helpers layered on buffer: bignum print, line wrapping, M2_gbTrace-gated emit.
	timing.hpp
	Inline std::chrono::steady_clock wrappers and elapsed-time conversion helpers.
	tower.cpp
	tower.hpp
	Legacy Tower — Ring-derived iterated extension of Z/p (pre-aring).
	util.hpp
	Conversion helpers between M2 boundary types and standard C++ containers.
	VectorArithmetic.hpp
	Coefficient-ring-erased arithmetic dispatcher used by F4, GB, and resolution code.
	weylalg.cpp
	weylalg.hpp
	WeylAlgebra — ring of polynomial differential operators with [d_i, x_i] = 1.
	ZZ.cpp
	ZZ.hpp
	Legacy RingZZ — a Ring-derived integer ring backed by GMP mpz_t.
	ZZp.cpp
	ZZp.hpp
	Legacy Z_mod — a Ring-derived Z/p with log / exp tables.

Detailed Description

Fall 2020 Work in Progress

Parallel directory structure in e, d, m2

Main header: e/engine.h
- should be short, mostly include other headers
- organize interface functions in e/interface; eg:
```
e/interface/matrix.h   // defining types currently in engine.h
e/interface/matrix.cpp // previously x-mat.cpp
```
- each should be self contained, include minimal dependencies (specifically, not engine.h)
- associated interpreter and top level code should be placed in appropriate files; eg:
```
d/matrix.dd
m2/matrix.m2
```

unit tests should be provided for all interface routines; eg:
```
  e/unit-test/matrix.cpp
```

Internal routines
- should be in respective directories, filename based on the classes; eg:
```
e/matrix/matrix.hpp
e/matrix/dense.hpp
```

GC barrier between engine and front end

issue: ringelem, our_new_delete vs our_new_gc
goal: ability to hotswap the GC backend by editing only one file
benefit: allow easy comparison and benchmarking

Computations to be written or rewritten

e.g. gb, smith normal form, etc.

Engine

engine.h and x-*
newdelete hash
Arithmetic
- Flint
- GMP
- MPFR
- Arb, etc.
Monoids
Rings
RingElements
RingMaps
Matrices
FreeModules
Computations
- LLL
- GB
- Resolution
- Hilbert*
NAG
Util
Interface

– 12/26/2011 MES Cleaning up code todo:

get gtest working i.e. a make file target
create a gtest file linking test file
DONE tabs --> spaces DONE put in tab-mode-null into each file change copyrights
remove as many includes as possible
maybe make a set of subdirectories of 'e': rings matrices computations util commands tests (gtest stuff)
buffer --> use ostringstream?
text-io --> maybe keep these except for bignum_text_out?
DONE at some point, merge back in the stuff with Jakob, preferably soon 9.

these files really use overflow facilities:

gbring.o
imonorder.o
matrix-kbasis.o
matrix.o
monoid.o
monorder.o
overflow.o
polyring.o
varpower.o

these files depends on overflow.hpp

CC.o
CCC.o
Eschreyer.o
GF.o
QQ.o
RR.o
RRR.o
ZZ.o
ZZp.o
comp-gb-declared.o
comp-gb.o
comp-res.o
debug.o
frac.o
freemod.o
gb-default.o
gb-homog2.o
gb-sugarless.o
gb-toric.o
gbring.o
gbweight.o
imonorder.o
matrix-kbasis.o
matrix.o
monoid.o
monorder.o
montable.o
ntuple.o
overflow.o
polyring.o
qring.o
reducedgb-ZZ.o
reducedgb-field-local.o
reducedgb-field.o
reducedgb.o
res-a2-gb.o
res-a2.o
schorder.o
skewpoly.o
solvable.o
spair.o
varpower.o
weylalg.o
x-gb.o
x-mat.o
x-relem.o

Directories

Files

Detailed Description

Fall 2020 Work in Progress

Engine