| C__gnu_cxx::_Hashtable_const_iterator< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc > | |
| C__gnu_cxx::_Hashtable_iterator< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc > | |
| C__gnu_cxx::_Hashtable_node< _Val > | |
| ►CAction | |
| CAlexanderDualAction | |
| CAnalyzeAction | |
| CAssociatedPrimesAction | |
| CDimensionAction | Implements the command line interface action dimension |
| CDynamicFrobeniusAction | |
| CEulerAction | Implements the command line interface action euler |
| CFrobeniusAction | |
| CGenerateFrobeniusAction | |
| CGenerateIdealAction | |
| CHelpAction | |
| CHilbertAction | |
| CIntersectionAction | |
| CIrreducibleDecomAction | |
| CLatticeAnalyzeAction | |
| CLatticeFormatAction | |
| CMaximalStandardAction | |
| COptimizeAction | |
| CPolyTransformAction | |
| CPrimaryDecomAction | |
| CTestAction | |
| CTransformAction | |
| CActionPrinter | |
| CArena | This is an arena allocator |
| CBigattiBaseCase | This class handles the base cases for the Hilbert-Poincare series by Bigatti et.al |
| CBigattiHilbertAlgorithm | |
| CBigattiPivotStrategy | A BigattiPivotStrategy is an implementation of a pivot selection strategy for the Hilbert series algorithm by Bigatti et.al |
| CBigPolynomial::BigCoefTerm | |
| CBigIdeal | |
| CBigIdealComparator | |
| CBigIntVector | |
| CBigPolynomial | |
| CArena::Block | |
| CChunkPool | |
| CCliParams | |
| CPolynomial::CoefTerm | |
| ►CCoefTermConsumer | |
| CCanonicalCoefTermConsumer | |
| ►CCoefBigTermConsumer | |
| CCoefBigTermRecorder | |
| CExternalPolynomialConsumerWrapper | |
| ►CIO::PolyWriter | |
| CIO::CoCoA4PolyWriter | |
| CIO::Fourti2PolyWriter | |
| CIO::M2PolyWriter | |
| CIO::SingularPolyWriter | |
| CNullCoefTermConsumer | This follows the null object pattern |
| CPolynomialConsolidator | |
| CTranslatingCoefTermConsumer | |
| CHilbertIndependenceConsumer | |
| CHilbertIndependenceConsumer::RightConsumer | |
| CTotalDegreeCoefTermConsumer | |
| CUndeformConsumer | |
| CColumnPrinter::Col | |
| CColumnPrinter | |
| ►CCommonParams | |
| CScarfParams | |
| ►CSliceLikeParams | |
| CBigattiParams | |
| CSliceParams | |
| CCommonParamsHelper | Utility class for dealing with the contents of CommonParams |
| CRawSquareFreeIdeal::const_iterator | Const_iterator doesn't have all it needs to be a proper STL iterator |
| ►CConsumerWrapper | |
| CExternalIdealConsumerWrapper | |
| CExternalPolynomialConsumerWrapper | |
| CDataType | The intention of this class is to describe the different kinds of mathematical structures that Frobby supports, such as a monomial ideal or a polynomial |
| CDeformer | Objects of this class encapsulate the process of applying a generic deformation to a monomial ideal |
| CDoubleLcmPredicate | |
| CElementDeleter< Container > | |
| CElementDeleter< list< BigIdeal * > > | |
| CElementDeleter< std::list< InputConsumer::Entry * > > | |
| CElementDeleter< vector< ColumnPrinter::Col * > > | |
| CElementDeleter< vector< HilbertIndependenceConsumer * > > | |
| CElementDeleter< vector< Ideal * > > | |
| CElementDeleter< vector< Parameter * > > | |
| CElementDeleter< vector< T * > > | |
| CHilbertBasecase::Entry | |
| CInputConsumer::Entry | |
| CEulerState | |
| CIdeal::ExponentAllocator | |
| ►CFacade | This is the super class of all facades |
| CBigattiFacade | A facade for computing Hilbert series of monomial ideals using the divide-and-conquer algorithm by Bigatti et.al |
| CDynamicFrobeniusFacade | A facade for using the dynamic programming Frobenius problem algorithm |
| CGenerateDataFacade | A facade for random and other kinds of data |
| CIOFacade | A facade for input and output of mathematical objects |
| CIdealFacade | A facade for performing operations on BigIdeal |
| CIntersectFacade | A facade for intersecting monomial ideals |
| CLatticeFacade | A facade for operations on lattices |
| CPolynomialFacade | A facade for operations on polynomials |
| CScarfFacade | |
| CSliceFacade | A facade for operations on monomial ideals using the Slice Algorithm |
| CFrobbyHash< Key > | |
| CFrobbyHash< mpz_class > | This template specialization makes the hash code of an mpz_clas available to the implementation of HashMap |
| CFrobbyHash< Term > | This template specialization makes the hash code of a term available to the implementation of HashMap |
| CFrobbyImpl::FrobbyIdealHelper | |
| CFrobbyStringStream | A replacement for stringstream |
| CGrobLat | A lattice with associated Grobner basis/neighbors |
| C__gnu_cxx::hash< _Key > | |
| C__gnu_cxx::hash< char * > | |
| C__gnu_cxx::hash< char > | |
| C__gnu_cxx::hash< const char * > | |
| C__gnu_cxx::hash< int > | |
| C__gnu_cxx::hash< long > | |
| C__gnu_cxx::hash< short > | |
| C__gnu_cxx::hash< signed char > | |
| C__gnu_cxx::hash< string > | |
| C__gnu_cxx::hash< unsigned char > | |
| C__gnu_cxx::hash< unsigned int > | |
| C__gnu_cxx::hash< unsigned long > | |
| C__gnu_cxx::hash< unsigned short > | |
| CHashPolynomial | A sparse multivariate polynomial represented by a hash table mapping terms to coefficients |
| C__gnu_cxx::hashtable< _Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc > | |
| CHilbertBasecase | |
| CFrobby::Ideal | |
| CIdeal | Represents a monomial ideal with int exponents |
| CIdealComparator | |
| ►CFrobby::IdealConsumer | This class provides a way to get monomial ideals as output from Frobby one generator at a time |
| CIrreducibleIdealDecoder | |
| CLibIdealConsumer | Records library interface output into a BigIdeal |
| CLibIdealsConsumer | Records library interface output into a vector of BigIdeals |
| CIdealFactory | This class has static methods that return various ideals |
| CIdealOrderer | |
| CIdealTree | Objects of this class represents a monomial ideal |
| CIndependenceSplitter | |
| CInputConsumer | |
| ►CIOHandler | An IOHandler implements input and output for some format in such a way that client code does not need to know which format is being used |
| ►CIO::IOHandlerImpl | This class contains a minimum level of functionality that makes it more convenient to derive from than IOHandler |
| CIO::CountingIOHandler | This class displays the total number of things written to output, without actually displaying those things |
| CIO::Fourti2IOHandler | |
| ►CIO::IOHandlerCommon | This class contains further functionality that makes it more convenient to derive from than IOHandlerImpl in most but not all cases |
| CIO::CoCoA4IOHandler | |
| CIO::Macaulay2IOHandler | |
| CIO::MonosIOHandler | |
| CIO::SingularIOHandler | |
| CIO::NewMonosIOHandler | |
| CIO::NullIOHandler | This class ignores the input and discards all output |
| CRawSquareFreeIdeal::iterator | Iterator doesn't have all it needs to be a proper STL iterator |
| CLocalArray< T, ArenaSource > | Emulates stack allocation of an array using an Arena |
| ►Clogic_error | |
| CAssertException | |
| ►Cstd::logic_error | |
| CInternalFrobbyException | This exception signals that a bug in Frobby has been detected |
| ►Cstd::map | |
| CHashMap< mpz_class, mpz_class > | |
| CHashMap< Term, mpz_class > | |
| CHashMap< Key, Value > | |
| CMatrix | |
| CMinimizer | |
| CMlfb | |
| CNameFactory< AbstractProduct > | A NameFactory takes a name and then creates an instance of a class that has been previously registered under that name |
| CNeighbor | |
| CIdealTree::Node | |
| CObjectCache< T > | An ObjectCache keeps a cache of previously-used objects to cut down on the number of allocations |
| CObjectCache< BigattiState > | |
| COffsetTermCompare | |
| ►CParameter | |
| CBoolParameter | |
| CIntegerParameter | |
| CStringParameter | |
| ►CParameterGroup | |
| CIOParameters | |
| CSliceParameters | This class represents the parameters associated to the Slice Algorithm and the similar Bigatti et.al |
| CPartition | |
| CPivotEulerAlg | |
| ►CPivotStrategy | A pivot selection strategy for the Euler algorithm |
| CDebugStrategy | A wrapper for a SliceStrategy that prints out what is going out for debugging purposes, while delegating everything to the strategy being wrapped |
| CStatisticsStrategy | A wrapper for a SliceStrategy that collects statistics on what is going on, while delegating everything to the strategy being wrapped |
| CPlane | |
| CPolynomial | |
| ►CFrobby::PolynomialConsumer | This class provides a way to get polynomials as output from Frobby one term at a time |
| CLibPolynomialConsumer | Records library interface output into a BigPolynomial |
| CPolynomialFactory | This class has static methods that return various polynomials |
| CProjection | |
| CRawSquareFreeIdeal | A bit packed square free ideal placed in a pre-allocated buffer |
| ►Cruntime_error | |
| CFrobbyStringStream::NotAnIntegerException | |
| ►Cstd::runtime_error | |
| CFrobbyException | This is the base of the Frobby exception hierarchy for exceptions that can occur due to expected error conditions |
| ►CSatBinomConsumer | |
| CSatBinomRecorder | SatBinomRecorder records all consumed saturated binomials into a passed-in ideal |
| CSatBinomIdeal | Represents a saturated binomial ideal |
| CScanner | This class offers an input interface which is more convenient and for some purposes more efficient than dealing with a FILE* directly |
| CScarfHilbertAlgorithm | |
| CSeqPos | |
| CSizeMaxIndepSetAlg | Encapsulates an algorithm for computing size-maximal independent sets of a hypergraph |
| ►CSliceStrategy | This class describes the interface of a strategy object for the Slice Algorithm |
| CDebugStrategy | A wrapper for a SliceStrategy that prints out what is going out for debugging purposes, while delegating everything to the strategy being wrapped |
| ►CSliceStrategyCommon | This class adds code to the SliceStrategy base class that is useful for derived classes |
| CHilbertStrategy | |
| ►CMsmStrategy | |
| COptimizeStrategy | OptimizeStrategy optimizes a function on the maximal standard monomials of a monomial ideal using branch-and-bound |
| CStatisticsStrategy | A wrapper for a SliceStrategy that collects statistics on what is going on, while delegating everything to the strategy being wrapped |
| ►CSplitStrategy | A SplitStrategy is an implementation of a split selection strategy for the Slice Algorithm |
| ►CSplitStrategyCommon | This common base class provides code that is useful for writing pivot split strategies |
| ►CLabelSplit | |
| CMaxLabelSplit | |
| CMinLabelSplit | |
| CVarLabelSplit | |
| ►CPivotSplit | |
| ►CDegreeSplit | |
| CDeprecatedFrobeniusSplit | This class is deprecated and is only here to create the alias "frob" for the degree split |
| CGcdSplit | |
| CMaximumSplit | |
| ►CMedianSplit | |
| CIndependencePivotSplit | |
| CMinGenSplit | |
| CMinimumSplit | |
| CSquareFreeIdeal | |
| CBigattiBaseCase::State | Used in enumerateScarfComplex and necessary to have here to define _states |
| CScarfHilbertAlgorithm::State | |
| CStatisticsStrategy::StatTracker | Tracks statistics on slices |
| CTestInternal::StdData | |
| CStlTermPredicate | Adapter for TermPredicate which allows it to be used as a predicate in STL |
| CStrictMultiplePredicate | |
| ►CTask | A Task object represents a unit of work that is performed when the method run() is called |
| CBigattiState | |
| CHilbertIndependenceConsumer | |
| CMsmIndependenceSplit | |
| ►CSlice | This class represents a slice, which is the central data structure of the Slice Algorithm |
| CHilbertSlice | |
| CMsmSlice | Invariant: either the slice is a trivial base case, or removeDoubleLcm returns false |
| CTaskEngine | TaskEngine handles a list of tasks that are to be carried out |
| CTerm | Term represents a product of variables which does not include a coefficient |
| ►CTermConsumer | This class is used to transfer terms one at a time from one part of the program to another, and possibly to perform computations on those terms |
| ►CBigTermConsumer | |
| CAnalyzeConsumer | |
| CBigTermRecorder | BigTermRecorder records all the terms it consumes into an ideal |
| CExternalIdealConsumerWrapper | |
| ►CIO::IdealWriter | |
| CIO::CoCoA4IdealWriter | |
| CIO::Fourti2IdealWriter | |
| CIO::M2IdealWriter | |
| CIO::MonosIdealWriter | |
| CIO::NewMonosIdealWriter | |
| CIO::SingularIdealWriter | |
| CIdealConsolidator | |
| CIrreducibleIdealSplitter | |
| CNullTermConsumer | This follows the null object pattern |
| CTranslatingTermConsumer | |
| CCanonicalTermConsumer | Passes consumed items on in a canonical order |
| CDecomRecorder | |
| CMsmIndependenceSplit | |
| CMsmIndependenceSplit::RightConsumer | |
| COptimizeStrategy | OptimizeStrategy optimizes a function on the maximal standard monomials of a monomial ideal using branch-and-bound |
| CTermIgnorer | |
| CTermGrader | A TermGrader assigns a value, the degree, to each monomial |
| ►CTermPredicate | |
| CEqualsPredicate | A predicate that compares for equality |
| CLexComparator | A predicate that sorts terms according to lexicographic order |
| CReverseLexComparator | A predicate that sorts according to reverse lexicographic order |
| CReverseSingleDegreeComparator | A predicate that sorts terms in weakly descending order according to degree of the specified variable |
| CSingleDegreeComparator | A predicate that sorts terms in weakly ascending order according to degree of the specified variable |
| CTermTranslator | TermTranslator handles translation between terms whose exponents are infinite precision integers and terms whose exponents are 32 bit integers |
| ►CTest | This class represents a test or a suite of tests according to the Composite Pattern |
| CTestCase | Represents a test case, which is usually created through a macro that defines a subclass |
| CTestSuite | Represents a collection of tests, be they individual tests or yet other collections of tests |
| ►CTestVisitor | This class is a visitor for classes derived from Test according to the Visitor Pattern |
| ►CTestQualifier | Visits a tree of Test while keeping track of the path taken from the root to the current node as a dot-separated string |
| CTestRunner | Runs every test in forward order |
| CTestSorter | Sorts tests to avoid using the order imposed by the order of construction of global objects, since this is inconsistent across compilers and platforms |
| CTimer | Measures spans of CPU time |
| CTranslatedIdealComparator | |
| CTranslatedReverseLexComparator | A predicate that sorts according to reverse lexicographic order on the translated values of a term |
| CTreeNode | |
| CTri | |
| CTriPlane | |
| CUniHashPolynomial | A sparse univariate polynomial represented by a hash table mapping terms to coefficients |
| CVarNames | Defines the variables of a polynomial ring and facilities IO involving them |
| CVarSorter | |
| CVarSorterCompare | |
