Loading...
Searching...
No Matches
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 123]
| NBIBasis | |
| Nexc | |
| NM2 | |
| Nmpfr | |
| Nnewf4 | |
| NSchreyerFrameTypes | |
| Nstd | STL namespace |
| CAllocLogger | Process-wide allocation counter used by StatsAllocator for debugging and benchmarking |
| CARing | |
| CARingElement | |
| CARingElementGenerator | |
| CAssociatedPrimes | |
| Cauto_reduce_node | |
| CBASECLASS | Synthetic documentation entry for the BASECLASS preprocessor macro (no real struct of this name exists) |
| CBasicPoly | Standalone, self-contained polynomial representation independent of any engine Ring — coefficients are bare mpz_class (GMP integers) |
| CBasicPolyListStreamCollector | Streaming consumer that builds a BasicPolyList from per-term callbacks, matching the mathicgb / mgb stream interface |
| CBettiDisplay | Engine-side Betti table: a (degree, homological level) rectangle of integers |
| CBettiHashAndEq | Combined hash + equality functor for (int*, int) pairs, used by the resolution code to key an unordered_set on (monomial, component) |
| Cbinomial | |
| Cbinomial_gb_elem | |
| Cbinomial_ring | |
| Cbinomial_s_pair | |
| Cbinomial_s_pair_set | |
| CbinomialGB | |
| CbinomialGB_comp | Non-functional |
| CBRP | Boolean (F_2-coefficient) polynomial stored as an ordered list of square-free monomials |
| Cbuffer | |
| Ccc_doubles_struct | |
| CCC_struct | Immutable view of a complex number as a pair of mpfr_srcptr real and imaginary parts |
| Ccc_struct | |
| CCCi_struct | Immutable view of a complex interval as a pair of mpfi_srcptr real and imaginary parts |
| Ccci_struct | |
| CCCimutable_struct | Mutable view of a complex interval as a pair of mpfi_ptr real and imaginary parts |
| CCCmutable_struct | Mutable view of a complex number as a pair of mpfr_ptr real and imaginary parts |
| CChineseRemainder | |
| Ccoefficient_matrix | |
| CCoefficientRingR | Generic CoefficientRing adapter that wraps an arbitrary const Ring* and forwards every operation to it |
| CCoefficientRingType | Default CoefficientRingType parameter for Polynomial<...>: a thin trait whose ElementType is just ring_elem |
| CCoefficientRingZZp | Discrete-log Z/p adapter that represents non-zero residues by their exponent index relative to a generator |
| Ccolumn_elem | |
| CColumnsSorter | Comparator that orders Macaulay-matrix column indices by the monomial each column represents, using the ambient MonomialInfo |
| Ccomplex | |
| CComplexField | Field-traits tag used as the template parameter of SLP<Field> to pick the complex element type |
| CComputation | Abstract base for long-running, resumable engine computations (GBComputation, ResolutionComputation, MutableComplex, GBKernelComputation, ...) |
| CConcreteVectorArithmetic | |
| CConstZipIterator | |
| CDegreeZeroMapGenerator | View of one cell of a SchreyerFrame as the degree-zero (scalar) part of the differential between two homological levels |
| CDetComputation | Computation of minors of a matrix |
| CDMat | |
| CDMat< M2::ARingGFFlint > | Specialisation of DMat for ARingGFFlint matrices, backed by FLINT's fq_zech_mat (Zech-log) routines |
| CDMat< M2::ARingGFFlintBig > | Specialisation of DMat for ARingGFFlintBig matrices, backed by FLINT's fq_nmod_mat_t |
| CDMat< M2::ARingQQFlint > | Specialisation of DMat for ARingQQFlint matrices, backed by FLINT's fmpq_mat_t |
| CDMat< M2::ARingZZ > | Specialisation of DMat for ARingZZ matrices, backed by FLINT's fmpz_mat_t |
| CDMat< M2::ARingZZpFlint > | Specialisation of DMat for ARingZZpFlint matrices, backed by FLINT's nmod_mat_t |
| CDMatLinAlg | |
| CDMatLinAlg< M2::ARingQQ > | Specialisation of DMatLinAlg for ARingQQ dense matrices, routing every linear-algebra query (rank, determinant, kernel, inverse, solve) through FLINT's fmpq_mat_* routines |
| CDMatLinAlg< M2::ARingZZpFFPACK > | Specialisation of DMatLinAlg for ARingZZpFFPACK dense matrices, delegating rank / determinant / kernel / solve / inverse to the FFPACK library's tuned Z/p routines |
| CDMatLinAlg< M2::ARingZZpFlint > | Specialisation of DMatLinAlg for ARingZZpFlint dense matrices, routing rank / determinant / kernel / solve / inverse calls to FLINT's nmod_mat_* routines |
| CDMatLUinPlace | |
| Cdoubling_stash | |
| CDPoly | Arithmetic engine for tower-polynomial rings: (Z/p)[x_0][x_1]...[x_{nvars-1}] modulo a chain of extensions |
| CDPolyTraverser | Visitor base class that walks every term of a TowerPolynomial, calling viewTerm(coeff, exponents) once per leaf |
| CDRing | Single-level view of a tower-polynomial ring: a DPoly plus a fixed working level and a Tower-flavoured ring_type typedef |
| CEigenTypes | |
| CEigenTypes< M2::ARingCC > | EigenTypes specialisation for double-precision complex matrices |
| CEigenTypes< M2::ARingCCC > | EigenTypes specialisation for arbitrary-precision complex (MPC) matrices |
| CEigenTypes< M2::ARingRR > | EigenTypes specialisation for double-precision real matrices |
| CEigenTypes< M2::ARingRRR > | EigenTypes specialisation for arbitrary-precision real (MPFR) matrices |
| CElementArray | Type-erased owning handle to a dense coefficient vector held by a ConcreteVectorArithmetic<Ring> |
| Cengine_RawMatrixArray | |
| Cengine_RawMonomialArray | |
| Cengine_RawMonomialOrderingArray | |
| Cengine_RawMutableMatrixArray | |
| Cengine_RawRingElementArray | |
| Cengine_RawRingElementArrayArray | |
| CEngineMonomial | Engine-side immutable monomial value type wrapping a varpower- encoded exponent vector |
| CEngineObject | Base class for engine objects that are immutable once their hash has been pinned (typically once they cross over to the front end) |
| Center_factory | |
| CEntryConfig | Comparator (and trivial hash) functor wired into the std::priority_queue inside PriorityQueuePolynomialHeap |
| Cexponent_table | |
| CExponentList | |
| CExponentListIterator | |
| CExponentVector | |
| CF4Computation | GBComputation subclass that drives an F4GB engine instance from the engine-side computation API |
| CF4GB | Commutative F4 Groebner-basis driver: degree-by-degree Macaulay matrix construction plus row-reduction over a coefficient ring |
| CF4MemoryBlock | |
| CF4MonomialLookupTableT | |
| CF4Res | F4-style engine that computes one (level, degree) slice of a free resolution into the host SchreyerFrame |
| CF4ResComputation | ResolutionComputation subclass that drives the F4 resolution engine (SchreyerFrame + F4Res) from the engine-side API |
| CF4SPairSet | S-pair scheduling queue used by F4GB: collects pairs, deduplicates them, and hands out the next degree's worth on demand |
| CF4toM2Interface | Static-method namespace for translating between engine Matrix / vec polynomials and the F4-internal GBF4Polynomial form |
| CFF_LUComputation | LU decomposition over a domain using fraction-free Gaussian elimination |
| CFixedPrecisionHomotopyAlgorithm | Tag type selecting the fixed-precision homotopy algorithm |
| CFlintQQMat | RAII wrapper around FLINT's fmpq_mat_t for translating dense QQ-coefficient matrices between the engine and FLINT |
| CFlintZZMat | RAII wrapper around FLINT's fmpz_mat_t for translating dense ZZ-coefficient matrices between the engine and FLINT |
| Cfrac_elem | |
| CFractionField | Engine-side fraction field of a polynomial domain R_ |
| CFreeAlgebra | Free associative algebra over a coefficient ring: the non-commutative analogue of PolynomialRing |
| CFreeAlgebraElement | Owned Poly value paired with its FreeAlgebra*, providing natural operator-overloaded arithmetic |
| CFreeAlgebraHeap | Geobucket-style accumulator for many Poly summands in the free associative algebra |
| CFreeAlgebraQuotient | Quotient of a FreeAlgebra by a Groebner basis up to a fixed degree bound |
| CFreeAlgebraQuotientElement | Owned Poly value paired with its FreeAlgebraQuotient*, providing operator-overloaded arithmetic for debugging / scripting |
| CFreeModule | Engine-side free module R^n over a Ring |
| CFreeModule_symm | Helper functor that builds the n-th symmetric power of a FreeModule by recursively walking multi-indices |
| CFreeMonoid | The free non-commutative monoid on a set of named variables, with monomial ordering and degree / weight machinery |
| CFreeMonoidLogger | Static counter for non-commutative monomial comparisons |
| CFunctionPair | Materialised (f, g) pair of BRP polynomials referenced by a Pair index record |
| CGaussElimComputation | Gaussian elimination class. To be rewritten |
| Cgb2_comp | |
| CGB_comp | A Groebner basis computation class for homogeneous input modules |
| Cgb_elem | |
| Cgb_emitter | |
| Cgb_node | |
| CgbA | The default Groebner basis computation class |
| CGBComputation | Base class for Groebner basis computations |
| CGBDeclared | Declared Groebner bases |
| Cgbelem | |
| CGBF4Polynomial | Compact polynomial layout used inside the F4 GB engine |
| CGBinhom_comp | A Groebner basis computation class for inhomogeneous input modules |
| CGBKernelComputation | Computes the kernel of a Schreyer-encoded GBMatrix and returns the syzygies in a Schreyer-compatible free module |
| CGBMatrix | gbvector-side matrix: a target FreeModule plus a list of gbvector* columns living in it |
| CGBProxy | Handle to a GB. Should be expunged, as full functionality isn't used |
| Cgbres_comp | One of the Resolution computations, based on computing step by step |
| CGBRing | Polynomial-ring view tuned for the inner loop of classical Buchberger Groebner-basis computations |
| CGBRingPoly | GBRing specialisation for ordinary commutative polynomial rings |
| CGBRingSkew | GBRing specialisation for skew-commutative (exterior-like) polynomial rings |
| CGBRingSolvable | GBRing specialisation for solvable polynomial algebras (PBW-style non-commutative rings whose relations have the form x_j * x_i = c_ij * x_i * x_j + lower-order terms) |
| CGBRingWeyl | GBRing specialisation for Weyl algebras over a field |
| CGBRingWeylZZ | GBRingWeyl specialisation for Weyl algebras over ZZ |
| CGBSorter | Comparator that orders indices into the current GB array (gb_array) by each gbelem's leading monomial, in increasing order |
| Cgbvector | |
| CgbvectorHeap | |
| CGBWalker | The generic Groebner walk algorithm. Not yet working? |
| CGBWeight | Heuristic-weight evaluator for gbvectors, used during Groebner basis computation to drive the S-pair sugar strategy |
| Cgeobucket | |
| CGF | Engine-side finite field GF(p^n) built on top of (Z/p)[t] / f(t) for a primitive element of the resulting field |
| Cgm_elem | |
| Cgmp_arrayZZ | |
| CHermiteComputation | Slow Hermite normal form computation over ZZ. Replace |
| Chilb_comp | Computation of Hilbert functions |
| Chilb_step | |
| CHilbertController | Hilbert-function-driven early termination helper used by F4GB to skip degrees the user-supplied Hilbert series predicts hold no new basis elements |
| Chm_elem | |
| CHomotopy | Abstract base for the predictor-corrector path-tracker hierarchy |
| CHomotopyAlgorithm | Traits class mapping a coefficient ring RT to its preferred homotopy algorithm tag |
| CHomotopyAlgorithm< M2::ARingCC > | Selects FixedPrecisionHomotopyAlgorithm for the double-precision complex ring M2::ARingCC |
| CHomotopyAlgorithm< M2::ARingCCC > | Selects FixedPrecisionHomotopyAlgorithm for the arbitrary-precision complex ring M2::ARingCCC |
| CHomotopyConcrete | |
| CHomotopyConcrete< RT, FixedPrecisionHomotopyAlgorithm > | |
| CIdentifierHash | IdentifierHash: used to facilitate parsing of polynomials from strings and files |
| Cindent | |
| Cint_bag | |
| CInterreducer | Interreduces a list of gbvector*s in place so that no element's leading term divides any other element's terms |
| CIntsSet | |
| CKBasis | Enumerates a k-basis (degree-graded monomial basis) of a module, a finite module's entire basis, or the basis of a map between modules |
| CLapack | Static-method namespace bridging the engine's RR / CC / RRR / CCC dense matrices and LAPACK / BLAS routines |
| Clex | |
| CLLLoperations | Static-method namespace for the LLL lattice-basis reduction algorithm operating on a MutableMatrix |
| Clocal_elem | |
| CLocalRing | Engine-side localisation of a polynomial ring at a prime ideal |
| CLUUtil | |
| CM2_arrayint | Length-prefixed int array, the integer counterpart of M2_string |
| CM2_ArrayString | Length-prefixed array of M2_string pointers |
| CM2_string | Length-prefixed byte string passed between the M2 front end and the engine |
| CM2FreeAlgebra | Concrete Ring wrapper around an owned FreeAlgebra (no quotient) |
| CM2FreeAlgebraOrQuotient | Abstract Ring subclass that lifts either a FreeAlgebra or a FreeAlgebraQuotient into the engine's Ring hierarchy |
| CM2FreeAlgebraQuotient | Concrete Ring wrapper around an owned FreeAlgebraQuotient (the quotient counterpart of M2FreeAlgebra) |
| CM2Homotopy | MutableEngineObject wrapper that owns a Homotopy via unique_ptr |
| CM2PointArray | MutableEngineObject wrapper that owns a PointArray via unique_ptr |
| CM2SLEvaluator | MutableEngineObject wrapper holding a raw SLEvaluator* |
| CM2SLProgram | MutableEngineObject wrapper that owns an SLProgram via unique_ptr |
| CMapPolynomialHeap | PolynomialHeap backed by a std::map<Monom, ring_elem, MonomEq>, deduplicating on insert via the map's lookup |
| CMarkedGB | Computation of a reduced GB w.r.t. a marked ordering |
| CMarkedGB_sorter | Index comparator for sorting a MarkedGB's gb array by the lead-term ordering induced by the user-supplied marking |
| CMatElementaryOps | |
| CMatElementaryOps< DMat< RT > > | |
| CMatElementaryOps< SMat< RT > > | |
| CMatrix | Engine-side matrix: a map between two free modules, stored as a column-vector list |
| CMatrixConstructor | Mutable builder used to assemble an immutable Matrix one column (or one term) at a time |
| CMatrixSorter | Helper that computes a column permutation for an engine Matrix by degree-then-monomial-order sort |
| CMatrixStream | Streaming consumer that builds an engine Matrix from the mathicgb-style stream callbacks (idealBegin / appendPolynomialBegin / appendTermBegin / appendExponent / appendTermDone / appendPolynomialDone / idealDone) |
| CMatrixWindow | Half-open rectangular submatrix descriptor: [begin_row, end_row) x [begin_column, end_column) |
| CMemoryBlock | Thin RAII wrapper around memtailor::Arena providing bump-pointer array allocation with optional mutex protection |
| CMGBCallback | Mathicgb (mgb) callback that polls the engine's interrupt flag during a long-running GB computation |
| CMinimalPrimes | |
| Cmo_block | |
| CModuleMonom | Monom extended with a module component, a stored index, and a memoised hash — the value type of IntsSet and friends |
| CModuleMonomDefaultConfig | Current IntsSet configuration: exposes Hash and Eq as discrete member functors so the unordered_set can use them directly |
| CModuleMonomDefaultConfigOrig | Legacy IntsSet configuration that bundles hashing, equality, and a display helper into one functor object |
| CModuleMonomEq | Equality functor on ModuleMonom, forwarding to operator== |
| CModuleMonomHash | Hash functor on ModuleMonom, forwarding to ModuleMonom::hash |
| CModuleMonomLessThan | Strict-weak-order comparator on ModuleMonom, used by IntsSet::sort to reorder the insertion-ordered mElements list |
| Cmon_part | |
| Cmonideal_pair | |
| CMonoid | Engine-side commutative monomial monoid: variable names, ordering, multidegree machinery, and monomial encoding/decoding |
| CMonom | Non-owning view onto a [length, degree, v1, v2, ..., vn] packed monomial in some externally managed buffer |
| Cmonom_int_list | |
| CMonomEq | Strict comparator on Monoms under a FreeMonoid order: returns true exactly when the first monomial is greater than the second |
| CMonomHash | Hash functor on Monom (or Word) suitable for std::unordered_map / std::unordered_set |
| CMonomHashEqual | Equality functor on Monom (or Word), the KeyEqual companion of MonomHash for std::unordered_map<Monom, ...> |
| CMonomialCollectionFixedSize | Interning collection that pairs a MonomialSetFixedSize with its own MonomialMemorySpace to own monomial storage |
| CMonomialCollectionVarSize | Variable-size counterpart of MonomialCollectionFixedSize: pairs a MonomialSetVarSize with its own MonomialMemorySpace |
| CMonomialHashAndEqFixedSize | Combined hash + equality functor for fixed-size monomials, plugged into the std::unordered_set inside MonomialSetFixedSize |
| CMonomialHashAndEqVarSize | Combined hash + equality functor for variable-size monomials, plugged into the std::unordered_set inside MonomialSetVarSize |
| CMonomialHashTable | |
| CMonomialIdeal | Engine-side monomial ideal: a decision tree of Nmi_nodes storing the (typically minimal) generators by variable / exponent path |
| CMonomialInfo | Per-ring monomial layout / encoding helper used by F4GB |
| CMonomialMemorySpace | Bump-pointer arena for monomial storage, backed by a memt::Arena |
| CMonomialOrder | Internal compiled form of a monomial ordering, derived from a front-end MonomialOrdering by monomialOrderMake |
| CMonomialOrdering | Front-end-side description of a monomial ordering as a list of mon_part blocks |
| CMonomialOrderings | Static-method namespace of constructors for the front-end MonomialOrdering value type |
| CMonomialOrderMatrix | Matrix-form encoding of a MonomialOrdering used by the Groebner walk algorithm |
| CMonomialSetFixedSize | |
| CMonomialSetVarSize | Hash set of interned variable-size monomials — the variable-length counterpart of MonomialSetFixedSize |
| CMonomialsIgnoringComponent | MonHashTable trait for packed_monomials that fold all components together (used when only the underlying monomial matters) |
| CMonomialSorterObject | Strict-weak comparator on integer indices into a std::vector<int*> of monomials, used by the resolution code to sort columns |
| CMonomialsWithComponent | MonHashTable trait for packed_monomials that include the component coordinate in equality |
| CMonomialTable | Indexed table of monomials with fast "find a divisor" lookup, keyed by a free integer val per entry |
| CMonomialTableZZ | MonomialTable analogue for monomials carrying a ZZ coefficient |
| CMonomSort | |
| Cmontable_sorter_ZZ | |
| CMutableComplex | Sequence of MutableMatrix differentials representing an in-progress chain complex, used for engine-side minimisation / pruning |
| CMutableEngineObject | Base class for engine objects that may mutate, so their hash must be identity-based rather than content-based |
| CMutableMat | |
| CMutableMatrix | Abstract base class for mutable matrices over an arbitrary engine Ring, the in-place counterpart of the immutable Matrix |
| CMyIdealConsumer | Frobby::IdealConsumer adapter that collects Frobby's output monomials into an engine MonomialIdeal |
| CNaiveDedupPolynomialHeap | |
| CNaiveDedupQueueConfiguration | Variant of NaiveQueueConfiguration with deduplication enabled: deduplicate(a, b) sums the coefficients of two equal monomials |
| CNaivePolynomialHeap | |
| CNaiveQueueConfiguration | mathic::Geobucket configuration whose Entry is a (Monom, ring_elem) pair compared by the FreeMonoid order on the monomial component |
| CNCBasis | Non-commutative analogue of KBasis: enumerates basis monomials of a FreeAlgebra quotient up to a degree / length bound |
| CNCF4 | Non-commutative F4 Groebner-basis driver: builds a per-degree Macaulay matrix from overlaps and reduces it in bulk |
| CNCGroebner | One-overlap-at-a-time Groebner basis driver for the free associative algebra (the "Naive" companion to the F4-style NCF4) |
| CNCResComputation | ResolutionComputation subclass that builds a free resolution over a FreeAlgebraQuotient (non-commutative) |
| CNmi_node | Internal tree node of the MonomialIdeal decision tree |
| CNterm | Singly linked-list node carrying one term of a polynomial-ring element |
| Cour_gc_cleanup | |
| Cour_new_delete | |
| COurNode | Scratch task descriptor used by the standalone TBB dependency-graph example |
| COurQueueConfiguration | Experimental mathic::Geobucket configuration whose Entry is an int — a placeholder used by makeQueue() to exercise the geobucket machinery without involving real monomials |
| COurQueueConfiguration1 | Variant of OurQueueConfiguration with deduplication enabled, used by makeQueue1() |
| COverlapTable | Per-degree FIFO queue of pending overlaps for the NC Groebner basis driver to process |
| CPair | S-pair record for the Franzi boolean Groebner basis algorithm |
| CPairRange | |
| Cparsing_error | |
| Cpart_elem | |
| Cpartition_table | |
| CPathTracker | Numerical homotopy-continuation path tracker for systems of polynomial equations |
| CPfaffianComputation | Computation of pfaffians of a skew symmetric matrix |
| CPointArray | Container of numerical points equipped with an  |
| CPointsComputation | |
| CPOLY | Pairs a gbvector with its evolving syzygy gbvector |
| Cpolyheap | |
| CPolynomial | |
| CPolynomialHeap | Abstract interface for accumulating a polynomial as a sum of (coeff, left * poly * right) contributions in the free algebra |
| CPolynomialRing | Abstract base for the engine's polynomial-ring hierarchy |
| CPolyRing | Concrete PolyRingFlat subclass implementing ordinary commutative polynomial rings K[x_1, ..., x_n] with a generic coefficient ring K and monoid M |
| CPolyRingFlat | PolynomialRing subclass whose elements are represented as a single flat Nterm* linked list (no fraction / quotient wrapper) |
| CPolyRingQuotient | PolyRingFlat subclass for quotients R / I of a polynomial ring by an ideal |
| Cpre_spair | |
| CPreSPairSorter | Comparator that orders pre_spair* pointers by the quot varpower monomial of each pre-S-pair |
| CPriorityQueuePolynomialHeap | PolynomialHeap backed by a std::priority_queue of (Monom, ring_elem) entries, with deduplication done lazily on lead-term extraction |
| CQRingInfo | Bookkeeping helper holding the defining ideal of a polynomial-ring quotient R / I in the two representations the engine reduces against |
| CQRingInfo_field | QRingInfo partial specialisation that adds the field-coefficient reduction tables: a MonomialIdeal for divisibility queries and a MonomialTable indexed by quotient_ideal slot |
| CQRingInfo_field_basic | QRingInfo_field specialisation for basic-field coefficients (everything except QQ) |
| CQRingInfo_field_QQ | QRingInfo_field specialisation for QQ coefficients, which need denominator tracking through reductions |
| CQRingInfo_ZZ | QRingInfo specialisation for quotients of polynomial rings over ZZ |
| CQuickSorter | |
| CRange | |
| CReducedGB | Base class for reduced Groebner basis computation |
| CReducedGB_Field | Computation of a reduced GB w.r.t. a term order, over a field |
| CReducedGB_Field_Local | Computation of a reduced GB w.r.t. a local order, over a field |
| CReducedGB_Field_Local_sorter | Index comparator used to permute ReducedGB_Field_Local's gb array into canonical reduced-GB order for the local-ring path |
| CReducedGB_Field_sorter | Index comparator used to permute ReducedGB_Field's gb array into canonical reduced-GB order over a field |
| CReducedGB_ZZ | Computation of a reduced GB w.r.t. a term order, over ZZ |
| CReducedGB_ZZ_sorter | Index comparator used to permute ReducedGB_ZZ's gb array into canonical reduced-GB order over ZZ |
| CRElement | |
| Cres2_comp | One of the Resolution computations, based on Schreyer and Lascala |
| Cres2_level | |
| Cres2_pair | |
| Cres2_poly | |
| Cres2term | |
| Cres_comp | One of the Resolution computations, based on Schreyer and Lascala |
| Cres_degree | |
| Cres_level | |
| Cres_pair | |
| Cres_poly | |
| CResF4MonomialLookupTableT | |
| CResF4toM2Interface | Static-method namespace bridging engine Matrix / vec values and the resolution engine's ResPolynomial representation |
| CResMemoryBlock | |
| CResMonoidDense | Dense-format ResMonoid implementation: monomials laid out as fixed-width exponent vectors |
| CResMonoidSparse | Sparse / varpower-format ResMonoid implementation: monomials laid out as length-prefixed lists of (variable, exponent) pairs |
| CResMonomialsIgnoringComponent | MonHashTable trait for res_packed_monomials with the component coordinate folded out |
| CResMonomialSorter | Sorter that orders res_packed_monomials by their total (Schreyer) monomial, with a stable tiebreaker derived from input order |
| CResMonomialsWithComponent | MonHashTable trait for the resolution engine's res_packed_monomials, with components included |
| CResolutionComputation | Base class for free resolution computation classes |
| CResPolynomial | Polynomial type used by the F4 resolution engine: parallel coefficient vector and concatenated monomial buffer |
| CResPolynomialConstructor | Builder that accumulates terms into a ResPolynomial and finalises the layout in one shot via setPoly |
| CResPolynomialIterator | Forward iterator over the terms of a ResPolynomial |
| CResPolyRing | The polynomial-ring view the F4 resolution engine reduces against: coefficient arithmetic plus the engine-specific ResMonoid |
| CResSchreyerOrder | Per-level Schreyer-order data attached to a SchreyerFrame::Level |
| Cresterm | |
| CRing | Xxx xxx xxx |
| Cring_elem | |
| CRingElement | Front-end-visible "ring element" value: an engine ring_elem paired with the Ring* that gives it meaning |
| CRingElementGenerator | |
| CRingMap | Engine-side ring homomorphism: stores, for each source-ring variable, the target-ring element it maps to |
| CRingZZ | Engine-side ring of integers, backed by GMP mpz_ptr elements |
| Crow_elem | |
| Cs_pair | |
| Cs_pair_heap | |
| Csagbi | Helper routines for computing Sagbi bases. Not currently functional? |
| CSchreyerFrame | State container for the in-progress free resolution built by the F4 resolution engine |
| CSchreyerOrder | Per-component tie-breaker data for a Schreyer monomial order on a FreeModule |
| CSchreyerOrder_symm | Helper functor that builds the n-th symmetric power of a SchreyerOrder by walking multi-indices |
| Cschur_poly | |
| Cschur_poly_heap | |
| Cschur_poly_iterator | |
| CSchurRing | PolyRing subclass implementing the Schur (symmetric-function) ring whose monomials are partitions and whose multiplication is the Littlewood-Richardson rule |
| CSchurRing2 | Refactored Schur (symmetric-function) ring whose elements are schur_poly sums of partitions over a configurable coefficient ring |
| CSchurSnRing | SchurRing2 subclass implementing the symmetric-group character ring (the "Schur ring of `S_n`"), with multiplication given by inner-product convolution rather than Littlewood-Richardson |
| CSkewMultiplication | Sign-rule helper used by every ring that has a skew-commutative subset of variables (exterior factor, full skew ring, ...) |
| CSkewPolynomialRing | PolyRing subclass for skew-commutative (exterior-style) polynomial rings: the listed skewvars anticommute among themselves and square to zero |
| Cslab | |
| CSLEvaluator | Abstract base for the SLP evaluator hierarchy |
| CSLEvaluatorConcrete | |
| CSLP | |
| CSLProgram | A straight-line program: a directed acyclic graph of arithmetic gates over a fixed list of inputs and constants |
| CSMat | |
| CSolution | One numerical solution produced by a PathTracker run, with the full per-path diagnostic record |
| CSolvableAlgebra | PolyRing subclass for solvable polynomial algebras (PBW-type non-commutative rings where each pair of non-commuting variables satisfies a relation of the form x_j x_i = c_ij x_i x_j + lower) |
| Csorter | |
| Cspair | |
| CSPairCompare | Comparator on indices into an spair table, ordering by sugar degree then by the larger of the two parent indices |
| Csparse_row | |
| CSPolySorter | Comparator on gbA::spair* used by the default Groebner basis driver to order its S-pair queue |
| Cstash | |
| CStatsAllocator | |
| CStopConditions | Bundle of optional early-termination knobs the front end can attach to a long-running Computation |
| CStraightLineProgram | |
| CSubMatrix | |
| CSubsets | Bijective integer encoding of q-subsets of {0, ..., n-1} via binomial(a_0, 1) + binomial(a_1, 2) + ... + binomial(a_{q-1}, q) |
| CSuffixTree | Generalised suffix tree alternative to WordTable for indexing non-commutative monomials |
| CSuffixTreeNode | One node of a generalised suffix tree built over the inserted non-commutative monomial patterns |
| CSumCollector | Abstract incremental accumulator that builds a ring_elem from many add(f) calls |
| CSumCollectorDefault | Generic SumCollector that accumulates into a single ring_elem via repeated Ring::add_to |
| CSumCollectorFreeAlgebraHeap | SumCollector adapter that funnels engine-side ring_elem adds into a FreeAlgebraHeap |
| CSumCollectorPolyHeap | SumCollector implementation that funnels engine-side ring_elem additions through a polyheap (geobucket) |
| CSymmMatrix | Helper that builds the p-th symmetric power of a 1-by-n matrix |
| CT | Classic separate-chaining hash table used by the engine's low-level C code paths |
| Ctableau | |
| Ctableau2 | |
| CTermIterator | |
| CTower | Ring subclass for tower polynomial rings (Z/p)[x_0][x_1]...[x_{n-1}] modulo a chain of algebraic extensions |
| CTowerEvaluator | DPolyTraverser subclass that evaluates a tower polynomial under a RingMap |
| CTowerPolynomial | Heap-allocated node of a tower polynomial: a dense degree-indexed coefficient array that recurses through levels |
| CTrivialHomotopyAlgorithm | Tag type selecting the no-op homotopy algorithm |
| CTrivialPolynomialHeap | Baseline PolynomialHeap implementation that simply accumulates the pending sum in a single Poly and walks it with an iterator |
| CVariablePrecisionHomotopyAlgorithm | Tag type selecting the variable-precision homotopy algorithm |
| Cvec | |
| CvecHeap | |
| CVectorArithmetic | Runtime dispatcher that hides the concrete coefficient ring behind a std::variant of ConcreteVectorArithmetic<Ring>* pointers |
| CVectorArithmeticStats | Lightweight counter attached to a ConcreteVectorArithmetic<Ring> for tracking how many coefficient additions a reduction performed |
| CWeylAlgebra | PolyRing subclass for Weyl algebras: polynomial rings with the [d_i, x_i] = 1 derivative-variable commutation relations |
| CWord | Non-owning view of a non-commutative word: [begin, end) of int variable indices |
| CWordTable | Index of Words (non-commutative monomials) with subword, prefix/suffix, and overlap lookup used by the NC Groebner code |
| CWordWithData | Word plus its ecart degree and heft degree — the value type WordWithDataTable stores |
| CWordWithDataTable | Variant of WordTable where each stored monomial carries an additional ecart-degree datum that gates subword matches |
| CZ_mod | Engine-side Z/p ring for small primes (p < 32767), using a discrete-log (Zech) representation |
| CZipIterator |
