| ABA_ABACUSROOT | Base class of all other classes of ABACUS |
| ABA_ACTIVE< BaseType, CoType > | Template class implements the sets of act ive constraints and variables which are associated w ith each subproblem |
| ABA_ARRAY< Type > | It is a template for arrays. It can be used like a ``normal'' C-style array |
| ABA_BHEAP< Type, Key > | This template class implements a heap with a fixed maximal size, however a reallocation can be performed if required |
| ABA_BOUNDBRANCHRULE | Class implements a branching rule for modifying the lower and the upper bound of a variable |
| ABA_BPRIOQUEUE< Type, Key > | Since the priority queue is implemented by a heap (class ABA_BHEAP) the insertion of a new element and the deletion of the minimal element require  time if  elements are stored in the priority queue |
| ABA_BRANCHRULE | Class is an abstract base class for all branching rules within this framework |
| ABA_BSTACK< Type > | Set of elements, following the last-in first-out (LIFO) principle the access to or the deletion of an element is restricted to the most recently inserted element |
| ABA_BUFFER< Type > | Class implements a buffer by an array and storing the number of already buffered elements |
| ABA_COLUMN | Class ABA_COLUMN refines ABA_SPARVEC for the representation of variables in column format |
| ABA_COLVAR | Some optimization problems, in particular column generation problems, are better described from a variable point of view instead of a constraint point of view. For such context we provide the class ABA_COLVAR |
| ABA_CONBRANCHRULE | Class implements the branching by adding a constraint to the set of active constraints |
| ABA_CONCLASS | A rather rudimentary classification for the generation of knapsack cuts is implemented in the class ABA_CONCLASS |
| ABA_CONSTRAINT | Class forms the virtual base class for all possible constraints given in pool format and is derived from the common base class ABA_CONVAR of all constraints and variables |
| ABA_CONVAR | ABA_CONVAR is the common base class for constraints and variables, which are implemented in the derived classes ABA_CONSTRAINT and ABA_VARIABLE, respectively |
| ABA_COWTIMER | Class derived from ABA_TIMER implements a timer measuring the elpased time (clock-of-the-wall time) of parts of the program |
| ABA_CPUTIMER | This class derived from ABA_TIMER implements a timer measuring the cpu time of parts of a program |
| ABA_CSENSE | We implement the sense of optimization as a class since we require it both in the classes ABA_CONSTRAINT and ABA_ROW |
| ABA_CUTBUFFER< BaseType, CoType > | Template class implements a buffer for constraints and variables which are generated during the cutting plane or column generation phase |
| ABA_DICTIONARY< KeyType, ItemType > | Data structure dictionary is a collection of items with keys. It provides the operations to insert pairs of keys and items and to look up an item given some key |
| ABA_DLIST< Type > | Class ABA_DLIST implements a doubly linked linear list. The list is implemented by a doubly linked list of ABA_DLISTITEMs |
| ABA_DLISTITEM< Type > | A ABA_DLISTITEM stores a copy of the inserted element and has pointers to its predecessor and its successor |
| ABA_DUALBOUND | Class ABA_DUALBOUND implements the abstract datatype for holding up to dual bounds  . A dual bound  can be inserted or removed |
| ABA_FASTSET | Class is derived from the class ABA_SET and holds for each set a rank which approximates the logarithm of the tree size representing the set and is also an upper bound for the height of this tree |
| ABA_FIXCAND | Candidates for fixing |
| ABA_FSVARSTAT | Status of fixed and set variables |
| ABA_GLOBAL | Class stores global data (e.g., a zero tolerance, an output stream, a table with system parameters) und functions operating with this data |
| ABA_HASH< KeyType, ItemType > | Data structure stores a set of items and provides as central functions the insertion of a new item, the search for an item, and the deletion of an item |
| ABA_HASHITEM< KeyType, ItemType > | See also class ABA_HASH |
| ABA_HISTORY | Class implements the storage of the solution history |
| ABA_ID | Instance of the class ABA_ID is used for identification of the same object stored multiple times on different processors |
| ABA_IDMAP< Type > | Class ABA_IDMAP<Type> implements a map between elements of ABA_ID and pointers to objects of the class Type |
| ABA_INFEASCON | If a constraint is transformed from its pool to the row format it may turn out that the constraint is infeasible since variables are fixed or set such that all nonzero coefficients of the left hand side are eliminated and the right hand side has to be updated |
| ABA_INTSET | Class ABA_INTSET implements the abstract datatype for storing a subset of the set  |
| ABA_LIST< Type > | Class ABA_LIST |
| ABA_LISTITEM< Type > | We call the basic building block of a linked list an { item\/} that is implemented by the class ABA_LISTITEM |
| ABA_LP | Section provides a generic interface class to linear programs, from which we will derive further classes both for the solution of LP-relaxations (ABA_LPSUB) with a \ algorithm and for interfaces to LP-solvers (ABA_OSIIF) |
| ABA_LPMASTER | The class ABA_LPMASTER is an abstract base class. A LP solver specific master class has to be derived from this class |
| ABA_LPMASTEROSI | |
| ABA_LPSOLUTION< BaseType, CoType > | Template class implements an LP solution. This class is necessary when using the class ABA_SEPARATOR for separation |
| ABA_LPSUB | Class is derived from the class LP to implement the linear programming relaxations of a subproblem. We require this class as the ABA_CONSTRAINT/ABA_VARIABLE format of the constraints/variables has to be transformed to the ABA_ROW/ABA_COLUMN format required by the class LP |
| ABA_LPSUBOSI | |
| ABA_LPVARSTAT | After the solution of a linear program by the simplex method each variable receives a status indicating if the variable is contained in the basis of the optimal solution, or is nonbasic and has a value equal to its lower or upper bound, or is a free variable not contained in the basis |
| ABA_MASTER | Class ABA_MASTER is the central object of the framework. The most important tasks of the class ABA_MASTER is the management of the implicit enumeration. Moreover, it provides already default implementations for constraints, cutting planes, and variables pools |
| ABA_MESSAGE | ABA_MESSAGE class implements a message buffer for sending arbitrary objects over a communication stream. It fully encapsulates the underlaying XDR stream which provides machine independant data representation |
| ABA_MTSERVER | Class ABA_MTSERVER is an abstract base class of a multithreaded server, which listens on a port for messages of type ABA_MESSAGE. The pure virtual function svcMessage must be defined in a subclass |
| ABA_NONDUPLPOOL< BaseType, CoType > | Class ABA_NONDUPLPOOL provides an ABA_STANDARDPOOL with the additional feature that the same constraint is at most stored once in the pool. For constraints and variables inserted in this pool the virtual member functions name(), hashKey(), and equal() of the base class ABA_CONVAR have to be defined |
| ABA_NUMCON | Like the class ABA_NUMVAR for variables we provide the class ABA_NUMCON for constraints which are uniquely defined by an integer number |
| ABA_NUMVAR | Class is derived from the class ABA_VARIABLE and implements a variable which is uniquely defined by a number |
| ABA_OPENSUB | New subproblems are inserted in this set after a branching step, or when a subproblem becomes dormant. A subproblem is extracted from this list if it becomes the active subproblem which is optimized |
| ABA_OPTSENSE | We can either minimize or maximize the objective function. We encapsulate this information in a class since it is required in various classes |
| ABA_OSIIF | |
| ABA_OSTREAM | Class implements an output stream which can be turned on and off at run time, i.e., if the output stream is turned off, then no messages written by the operator << reach the associated ``real'' output stream |
| ABA_OSTREAM_MANIP_INT | Manipulator class for manipulators with one argument |
| ABA_PARMASTER | Class ABA_PARMASTER contains all data and operations specific to the parallel ABACUS |
| ABA_POOL< BaseType, CoType > | The public enumerations of ABA_POOL |
| ABA_POOLSLOT< BaseType, CoType > | Constraints or variables are not directly stored in a pool. But are stored in a pool slot |
| ABA_POOLSLOTREF< BaseType, CoType > | We do not refer directly to constraints/variables but store a pointer to a pool slot and memorize the version number of the slot at initialization time of the class ABA_POOLSLOTREF |
| ABA_RING< Type > | Template ABA_RING implements a bounded circular list with the property that if the list is full and an element is inserted the oldest element of the ring is removed |
| ABA_ROW | Class refines its base class ABA_SPARVEC for the representation of constraints in the row format |
| ABA_ROWCON | Class ABA_ROWCON implements constraints stored in the class ABA_ROW |
| ABA_SEPARATOR< BaseType, CoType > | Abstract template class can be used to implement a separation routine |
| ABA_SET | Class implements a data structure for collections of dynamic disjoint sets of integers |
| ABA_SETBRANCHRULE | The data members of the class ABA_SETBRANCHRULE |
| ABA_SLACKSTAT | As for the structural variables the simplex method also assigns a unique status to each slack variable. A slack variable can be a basic or a nonbasic variable |
| ABA_SORTER< ItemType, KeyType > | This class implements several functions for sorting arrays according to increasing keys |
| ABA_SPARVEC | Since other classes, e.g., the class ABA_RO are derived from this class, all data members are protected in order to provide efficient access also in these derived classes |
| ABA_SROWCON | The member functions genRow() and slack() of the class ABA_ROWCON can be significantly improved if the variable set is static, i.e., no variables are added or removed during the optimization |
| ABA_STANDARDPOOL< BaseType, CoType > | Class provides a very simple implementation of a pool which is sufficient for a large class of applications. pool slots stored in array, set of free slots is managed by a linear list |
| ABA_STRING | Class ABA_STRING implements are very simple class for the representation of character strings |
| ABA_SUB | Class implements an abstract base class for a subproblem of the enumeration, i.e., a node of the \ tree |
| ABA_SUBSERVER | Class ABA_SUBSERVER is a multithreaded server for solving subproblems |
| ABA_TAILOFF | This class stores the history of the values of the last LP-solutions and implements all functions to control tailing-off effect |
| ABA_TIMER | Class implements a base class for timers measuring the CPU time and the wall-clock time |
| ABA_VALBRANCHRULE | Class implements a branching rule for setting a variable to a certain value |
| ABA_VARIABLE | Class forms the virtual base class for all possible variables given in pool format |
| ABA_VARTYPE | Variables can be of three different types: Continuous, Integer or Binary. We distinguish Integer and Binary variables since some operations are performed differently (e.g., branching) |
1.5.1