| ►Nabacus | |
| CAbaBHeap | Binary heaps |
| CAbacusGlobal | Global data and functions |
| CAbacusRoot | Base class of all other classes of ABACUS |
| CAbaHash | Hash tables |
| CAbaHashItem | Items in hash tables |
| CAbaPrioQueue | Bounded priority queues |
| CAbaRing | Bounded circular lists |
| CActive | Implements the sets of active constraints and variables which are associated with each subproblem |
| CBoundBranchRule | Implements a branching rule for modifying the lower and the upper bound of a variable |
| CBranchRule | Abstract base class for all branching rules |
| CColumn | Representation of variables in column format |
| CColVar | Some optimization problems, in particular column generation problems, are better described from a variable point of view instead of a constraint point of view |
| CConBranchRule | Implements the branching by adding a constraint to the set of active constraints |
| CConClass | Constraint classification |
| CConstraint | Forms the virtual base class for all possible constraints given in pool format |
| CConVar | Common base class for constraints (Constraint) and variables (Variable) |
| CCSense | Sense of constraints |
| CCutBuffer | Cut buffers |
| CFixCand | Candidates for fixing |
| CFSVarStat | Status of fixed and set variables |
| CHistory | Solution histories |
| CInfeasCon | Infeasible constraints |
| CLP | Linear programs |
| CLpMaster | The LP master |
| CLpMasterOsi | The OSI LP master |
| CLpSolution | LP solutions |
| CLpSub | The linear program of a subproblem |
| CLpSubOsi | |
| CLPVARSTAT | Status of variables |
| CMaster | The master of the optimization |
| CNonDuplPool | Standard pools without constraint duplication |
| CNumCon | Constraints defined by a number |
| CNumVar | Variables identified by a number |
| COpenSub | Maintains open subproblems |
| COptSense | Sense of optimization |
| COsiIF | |
| CPool | Base class for constraint/variabe pools |
| CPoolSlot | Stores constraints and variables |
| CPoolSlotRef | Stores a pointer to a pool slot with version number |
| CRow | Representation of constraints in the row format |
| CRowCon | Implements constraints stored in the class Row |
| CSeparator | Separators |
| CSetBranchRule | Implements a branching rule for setting a binary variable to its lower or upper bound |
| CSlackStat | Status of slack variables |
| CSparVec | Sparse vectors |
| CSRowCon | Constraints using row with static variable set |
| CStandardPool | Standard pools |
| CSub | The subproblem |
| CTailOff | Tailing off manager |
| CValBranchRule | Implements a branching rule for setting a variable to a certain value |
| CVariable | Forms the virtual base class for all possible variables given in pool format |
| CVarType | Variable types |
| ►Nbackward | |
| ►Ndetails | |
| Cdefault_delete | |
| Cdeleter | |
| Cdemangler | |
| Cdemangler_impl | |
| Chandle | |
| Chashtable | |
| Crm_ptr | |
| Crm_ptr< const T * > | |
| Crm_ptr< T * > | |
| CColorize | |
| CPrinter | |
| ►CResolvedTrace | |
| CSourceLoc | |
| CSignalHandling | |
| CSnippetFactory | |
| ►CSourceFile | |
| Cnot_isempty | |
| Cnot_isspace | |
| CStackTrace | |
| CStackTraceImpl | |
| CTrace | |
| CTraceResolver | |
| CTraceResolverImpl | |
| CTraceResolverImpl< system_tag::unknown_tag > | |
| ►Nmapbox | ISC License |
| ►Ndetail | |
| ►CEarcut | |
| CNode | |
| CObjectPool | |
| ►Nutil | |
| Cnth | |
| ►NMinisat | |
| ►NInternal | |
| CBoolOption | |
| CClause | |
| CClauseAllocator | |
| ►CCMap | |
| CCRefHash | |
| CDeepEqual | |
| CDeepHash | |
| CDoubleOption | |
| CDoubleRange | |
| CEqual | |
| CHash | |
| CHeap | |
| CIntOption | |
| CIntRange | |
| Clbool | |
| CLessThan_default | |
| CLit | |
| ►CMap | |
| CPair | |
| COccLists | |
| COutOfMemoryException | |
| CQueue | |
| CRegionAllocator | |
| ►CSimpSolver | |
| CClauseDeleted | |
| CElimLt | |
| ►CSolver | |
| CSolverStatus | |
| CVarData | |
| CVarOrderLt | |
| CWatcher | |
| CWatcherDeleted | |
| Cvec | |
| CClause | Represents a simple class for clause storage |
| CFormula | The Formula class |
| CModel | Represents a simple class for model storage |
| ►Nogdf | The namespace for all OGDF objects |
| ►Nbooth_lueker | |
| CEmbedIndicator | |
| CEmbedPQTree | |
| CIndInfo | |
| CPlanarLeafKey | |
| CPlanarPQTree | |
| ►Nboyer_myrvold | |
| CBoyerMyrvoldInit | This class is used in the Boyer-Myrvold planarity test for preprocessing purposes |
| ►Ncluster_planarity | |
| CBaseConstraint | Basic constraint type |
| CChunkConnection | |
| CClusterKuratowskiConstraint | |
| CClusterPQContainer | |
| CCP_MasterBase | |
| CCPlanarEdgeVar | |
| CCPlanarityMaster | |
| ►CCPlanaritySub | |
| CKuraSize | |
| CCPlanarSubClusteredST | Constructs a c-planar subclustered spanning tree of the input by setting edgearray values |
| CCutConstraint | |
| CedgeValue | Struct for attaching the current lp-value to the corresponding edge. Used in the primal heuristic |
| CEdgeVar | |
| CMaxCPlanarMaster | |
| CMaxCPlanarSub | |
| CMaxPlanarEdgesConstraint | |
| CMinimalClusterConnection | |
| ►Ndavidson_harel | |
| CAttraction | Energy function for attraction between two adjacent vertices |
| CEnergyFunction | The interface for energy functions for the Davidson Harel graph drawing method |
| CNodePairEnergy | |
| COverlap | |
| ►CPlanarity | |
| CChangedCrossing | |
| CPlanarityGrid | |
| CRepulsion | |
| CUniformGrid | |
| ►Ndisjoint_sets | |
| CAnyOption | |
| CCompressionOption | |
| CInterleavingOption | |
| CLinkOption | |
| ►Ndot | |
| ►CAst | DOT format abstract syntax tree class, based on official documentation |
| CAList | |
| CAsgnStmt | |
| CAttrList | |
| CAttrStmt | |
| CCompassPt | |
| CEdgeLhs | |
| CEdgeRhs | |
| CEdgeStmt | |
| CGraph | |
| CNodeId | |
| CNodeStmt | |
| CPort | |
| CStmt | |
| CStmtList | |
| CSubgraph | |
| CLexer | Lexical analysis tool |
| CParser | DOT format parser class |
| CSubgraphData | A helper structure containing information for recursive graph reading |
| CToken | Just a simple token struct representing a DOT file fragment |
| ►Nedge_router | |
| CNodeInfo | |
| ►Nembedder | |
| CConnectedSubgraph | |
| CCrossingStructure | |
| CEmbedderBCTreeBase | Common base for embedder algorithms based on BC trees |
| CLayersBlockEmbedder | Common functionality for layer-based embedding algorithms |
| CMDMFLengthAttribute | Auxiliary length attribute |
| ►Nembedding_inserter | |
| CCrossingsBucket | Bucket function for sorting edges by decreasing number of crossings |
| ►Nenergybased | |
| ►Ndtree | |
| ►CDTree | Implentation of the reduced quadtree for Dim dimensions |
| CMortonEntry | The entry in the sorted order for a point |
| CNode | The node class |
| CPoint | The point class with integer coords |
| ►CDTreeEmbedder | |
| CNodeInfo | Node state |
| ►CDTreeForce | |
| CNodeData | Node data |
| CPointData | Point data |
| ►CDTreeWSPD | |
| CNodeData | Geometry for the quadtree nodes |
| CPointData | World coordinates of the points |
| CDTreeWSPDCallback | |
| CGalaxyLevel | Simple implementation of the slightly modified version of Hachul by Gronemann |
| CIWSPD | |
| ►Nfmmm | |
| CEdge | Helping data structure for deleting parallel edges in class FMMMLayout and Multilevel (needed for the bucket sort algorithm) |
| CEdgeAttributes | Helping data structure that stores the graphical attributes of an edge that are needed for the force-directed algorithms |
| CEdgeMaxBucketFunc | |
| CEdgeMinBucketFunc | |
| CFruchtermanReingold | |
| CMAARPacking | Data structure for packing rectangles within an area of a desired aspect ratio without overlappings; optimization goal: to minimize the used aspect ratio area |
| CMultilevel | |
| CNewMultipoleMethod | |
| CNode | Data structure for representing nodes and an int value (needed for class ogdf/list) to perform bucket sort |
| CNodeAttributes | Helping data structure that stores the graphical attributes of a node that are needed for the force-directed algorithms |
| Cnumexcept | This class is developed for exceptions that might occure, when nodes are placed at the same position and a new random position has to be found, or when the calculated forces are near the machine accuracy, where no reasonable numeric and logic calculations are possible any more |
| CPackingRowInfo | Helping data structure for MAARPacking |
| CParticleInfo | Helping data structure for building up the reduced quad tree by NMM |
| CQuadTreeNM | Helping data structure that stores the information needed to represent the modified quadtree in the New Multipole Method (NMM) |
| CQuadTreeNodeNM | Helping data structure that stores the information needed to represent a node of the reduced quad tree in the New Multipole Method (NMM) |
| CRectangle | Helping data structure for packing rectangles; The width, height and the position of the down left corner of the tight surroundig rectangle is represented for each connected component of the graph |
| CSet | Helping data structure that holds set S_node of nodes in the range [0, G.number_of_nodes()-1] (needed for class Multilevel) for randomly choosing nodes (with uniform or weighted probability!) |
| ►Nfast_multipole_embedder | |
| CArrayGraph | |
| CArrayPartition | |
| CBinCoeff | Binomial coeffs from Hachuls FMMM |
| CCollectForceFunctor | |
| Ccomposition_functor | Functor for composing two other functors |
| Cconst_condition | Condition functor for returning a constant boolean value |
| CD2DFunctor | Calculates the repulsive forces acting between all nodes of the direct interacting cells of the i-th node |
| Cdo_nothing | Useless do nothing function |
| CEdgeAdjInfo | Information about an edge (16 bytes) |
| CEdgeForceFunctor | |
| CEmptyArgType | |
| CFMEBasicKernel | |
| CFMEFuncInvokerTask | Class used to invoke a functor or function inside a thread |
| CFMEGlobalContext | Global Context |
| CFMEGlobalOptions | Main global options for a run |
| CFMEKernel | |
| CFMELocalContext | Local thread Context |
| CFMEMultipoleKernel | |
| CFMENodeChainPartition | |
| CFMESingleKernel | |
| CFMETask | The thread task class used only as an interface |
| CFMEThread | The fast multipole embedder work thread class |
| CFMEThreadPool | |
| CFMETreePartition | Struct for distributing subtrees to the threads |
| CFuncInvoker | |
| CFuncInvoker< FunctionType, ArgType1, ArgType2, ArgType3, ArgType4, ArgType5, ArgType6, ArgType7, EmptyArgType > | |
| CFuncInvoker< FunctionType, ArgType1, ArgType2, ArgType3, ArgType4, ArgType5, ArgType6, EmptyArgType, EmptyArgType > | |
| CFuncInvoker< FunctionType, ArgType1, ArgType2, ArgType3, ArgType4, ArgType5, EmptyArgType, EmptyArgType, EmptyArgType > | |
| CFuncInvoker< FunctionType, ArgType1, ArgType2, ArgType3, ArgType4, EmptyArgType, EmptyArgType, EmptyArgType, EmptyArgType > | |
| CFuncInvoker< FunctionType, ArgType1, ArgType2, ArgType3, EmptyArgType, EmptyArgType, EmptyArgType, EmptyArgType, EmptyArgType > | |
| CFuncInvoker< FunctionType, ArgType1, ArgType2, EmptyArgType, EmptyArgType, EmptyArgType, EmptyArgType, EmptyArgType, EmptyArgType > | |
| CFuncInvoker< FunctionType, ArgType1, EmptyArgType, EmptyArgType, EmptyArgType, EmptyArgType, EmptyArgType, EmptyArgType, EmptyArgType > | |
| CFuncInvoker< FunctionType, EmptyArgType, EmptyArgType, EmptyArgType, EmptyArgType, EmptyArgType, EmptyArgType, EmptyArgType, EmptyArgType > | |
| ►CGalaxyMultilevel | |
| CLevelEdgeInfo | |
| CLevelNodeInfo | |
| ►CGalaxyMultilevelBuilder | |
| CLevelNodeState | |
| CNodeOrderInfo | |
| Cif_then_else_functor | Functor for conditional usage of a functor |
| Cl2l_functor | Local-to-Local functor |
| Cl2p_functor | Local-to-Point functor |
| ►CLinearQuadtree | |
| Cbottom_up_traversal_functor | Bottom up traversal of the subtree of a given node |
| Cforall_children_functor | Simple functor for iterating over all children of a node |
| Cforall_ordered_pairs_of_children_functor | Functor for iterating over all ordered pairs of children of a node |
| Cforall_points_functor | Simple functor for iterating over all points of a node |
| Cforall_tree_nodes_functor | Simple functor for iterating over all nodes |
| Cis_fence_condition_functor | |
| Cis_leaf_condition_functor | |
| CLQNode | |
| CLQPoint | |
| CLQWSPair | |
| CStoreDirectNodeFunctor | |
| CStoreDirectPairFunctor | |
| CStoreWSPairFunctor | |
| Ctop_down_traversal_functor | Top down traversal of the subtree of a given node |
| Cwspd_functor | |
| CLinearQuadtreeBuilder | Builder for the LinearQuadtree |
| CLinearQuadtreeExpansion | |
| CLQCoordsFunctor | Computes the coords and size of the i-th node in the LinearQuadtree |
| CLQMortonFunctor | |
| CLQPartitioner | The partitioner which partitions the quadtree into subtrees and partitions the sequence of inner nodes and leaves |
| CLQPointUpdateFunctor | |
| Cm2l_functor | Multipole-to-Local functor |
| CM2LFunctor | Converts the multipole expansion coefficients from all nodes which are well separated from the i-th node to local expansion coefficients and adds them to the local expansion coefficients of the i-th node |
| Cm2m_functor | Multipole-to-Multipole functor |
| Cmin_max_functor | Generic min max functor for an array |
| CNDFunctor | Calculates the repulsive forces acting between all nodes inside the cell of the i-th LinearQuadtree node |
| CNodeAdjInfo | Information about incident edges (16 bytes) |
| CNodeMassComparer | |
| CNodeMoveFunctor | |
| Cnot_condition_functor | Functor for negating a condition |
| Cp2m_functor | Point-to-Multipole functor |
| Cp2p_functor | Local-to-Point functor |
| Cpair_call_functor | Helper functor to generate a pair as parameters |
| Cpair_vice_versa_functor | Functor for invoking a functor for a pair(u,v) and then (v,u) |
| CRandomNodeSet | Utility class to select multiple nodes randomly |
| CWSPD | Class for the Well-Separated-Pairs-Decomposition (WSPD) |
| ►Ngdf | |
| CParser | |
| ►Ngexf | |
| CParser | |
| ►Ngml | |
| CObject | Represents node in GML parse tree |
| CParser | Reads GML file and constructs GML parse tree |
| ►Ninternal | |
| ►Ngcm | |
| ►Ndatastructure | |
| CEdgeVector | |
| CFilterIterator | |
| CIteratorRange | |
| CNodeVector | |
| CTimestampFlags | |
| CUnionFind | Implements the Union Find Datastructure to maintain disjoint sets efficiently |
| ►Ngraph | |
| CAdjacentNodeIterator | |
| CDijkstra | |
| CDrawing | |
| CEntryIterator | |
| CIncidentEdgeIterator | Iterate over incident edges |
| COGDFEntryIterator | Iterate over entries of an ogdf graph |
| CEdgeArrayBase1 | RegisteredArray for edges of a graph |
| CEdgeArrayBase2 | RegisteredArray for edges of a graph, specialized for EdgeArray<edge> |
| CEdgeArrayBase2< edge, WithDefault > | |
| CFaceAdjContainer | Container for the adjacency entries in a face |
| CFaceAdjIterator | Forward iterator for adjacency entries in a face |
| CGraphArrayIteratorBase | |
| CGraphElement | The base class for objects used by (hyper)graphs |
| CGraphIteratorBase | |
| CGraphList | Lists of graph objects (like nodes, edges, etc.) |
| CGraphListBase | Base class for GraphElement lists |
| CGraphObjectContainer | Public read-only interface for lists of graph objects |
| CGraphRegisteredArray | RegisteredArray for nodes, edges and adjEntries of a graph |
| CGraphRegistry | Registry for nodes, edges and adjEntries of a graph |
| Cis_iterator | |
| Cis_iterator< T, std::void_t< typename std::iterator_traits< T >::iterator_category > > | |
| CRegisteredArrayBase | Abstract base class for registered arrays |
| CRegisteredArrayWithDefault | Registered arrays with default values |
| CRegisteredArrayWithoutDefaultOrIndexAccess | Registered arrays without default values or by-index access to values |
| CRegisteredArrayWithoutDefaultWithIndexAccess | RegisteredArrayWithoutDefaultOrIndexAccess that also allows accessing its values directly by their index |
| CSimpleRange | |
| ►Nmatching_blossom | |
| CAlternatingTree | |
| CAuxEdge | |
| CAuxGraph | |
| CAuxNode | |
| CBaseIteratorContainer | Dummy class for scoped iteration of a std::unordered_map |
| CBlossomHelper | Helper class for the blossom matching algorithms |
| CBlossomPQ | A custom priority queue for the blossom algorithm, based on the PrioritizedMapQueue. It uses a std::unordered_map to store the handles, handles merge operations correctly, can iterate over its elements and offers a remove() function |
| CBlossomVHelper | Helper class for the blossom matching algorithms |
| CCycle | |
| CMapKeyIterator | Iterator to access the keys of a std::unordered_map |
| CMapValueIterator | Iterator to access the values of a std::unordered_map |
| ►CPseudonode | Helper class representing a pseudonode in the Blossom algorithm |
| CReferenceEdges | Helper class to store reference edges for all self loops |
| ►Npc_tree | |
| CFilteringPCTreeWalk | A DFS or BFS through a PCTree |
| CGraphNotPlanarException | |
| ►CIntrusiveList | |
| Citerator | |
| Cnode | |
| CNodePCRotation | This class represents the embedding tree of a single node in a biconnected component |
| ►CPCNode | A node in a PC-tree that is either a P-node, C-node or leaf |
| CTempInfo | Temporary information used during each step of the PCTree::makeConsecutive() update operation |
| CPCNodeChildrenIterable | |
| CPCNodeIterator | |
| CPCNodeNeighborsIterable | |
| ►CPCTree | A PC-tree represents a set of cyclic orders of its leaves by labeling its inner nodes as either P- or C-node and allowing arbitrary permutations of the neighbors of P-nodes while only allowing flips of C-nodes |
| CLoggingObserver | |
| CNextFullLeaf | |
| CObserver | Interface for Observers that can be notified of all changes made to the tree during an update |
| CPCTreeForest | Multiple PCTrees can be created within the same PCTreeForest, which allows merging the trees later on by making one a child of another |
| CPCTreeRegistry | A registry that allows labelling the nodes of a PC-tree |
| ►Nplanar_separators | |
| CArrayBFSTree | Abstract BFSTree that is realized via NodeArrays |
| CBFSTree | Abstract description of a Breadth First Search tree |
| CBFSTreeClassical | BFS tree used by both classical algorithms (LT and Dual) |
| CBFSTreeFC | Custom BFS Tree |
| CBFSTreeHP | Specialised tree representation for Har-Peled |
| ►CCycle | Auxiliary data structure to represent Cycles in planar graphs |
| CIterator | Special iterator to walk over the inward-pointing edges of the cycle |
| CDMDecomposer | Dulmage-Mendelsohn-Decomposition |
| CNodeExpulsor | NodeExpulsor: Remove all nodes that are not connected to both halves of the separation |
| CPostprocessor | Abstract description of postprocessors |
| CRing | A closed ring of nodes |
| ►CSeparatorDualHelper | Helper class for SeparatorDual and SeparatorDualFC |
| CCycleData | Auxiliary lightweight data structure to represent cycles |
| CTriangulatingBFSTree | Triangulating BFS tree that operates on a non-triangulated graph and constructs the triangulation together with the BFS, which should lead to broader trees |
| ►Nplanarization_layout | |
| CCliqueReplacer | |
| ►Npq_internal | This namespace contains helper classes to keep the code dry |
| CCompare | Used to compare elements with assigned priorities |
| CPairTemplate | Pair for storing an element and a priority |
| CPrioritizedArrayQueueBase | |
| CPrioritizedQueue | Defines a queue for handling prioritized elements |
| ►Nspring_embedder | |
| CCommonForceModelBase | |
| CMasterBase | Base class for ogdf::SpringEmbedderGridVariant::Master |
| CSpringEmbedderBase | Common base class for ogdf::SpringEmbedderBase and ogdf::SpringEmbedderGridVariant |
| CWorkerBase | Base class for ogdf::SpringEmbedderGridVariant::Worker |
| ►Nsse | |
| CComplexDouble | Class to generate instrinsics for complex number arithmetic functions |
| ►Nsteiner_tree | |
| ►Ngoemans | |
| ►CApproximation | The actual 1.39-approximation algorithm by Goemans et al. with a set of terminalized nodes as result |
| CTemporaryEdges | Add edges into a blowup graph and delete them on destruction |
| CBlowupComponents | Obtain and provides information about components in a given blowup graph |
| CBlowupGraph | A special-purpose blowup graph for gammoid computation: directed, with special source and target, with core edges (implemented as nodes) |
| CCoreEdgeModule | Interface for core edge finder algorithms |
| CCoreEdgeRandomSpanningTree | Computes a random set of core edges |
| CFull2ComponentGenerator | Trivial full 2-component generation by lookups of shortest paths between terminal pairs |
| CFull3ComponentGeneratorEnumeration | Full 3-component generation using enumeration |
| CFull3ComponentGeneratorModule | Interface for full 3-component generation including auxiliary functions |
| CFull3ComponentGeneratorVoronoi | Full 3-component generation using Voronoi regions |
| CFullComponentDecisions | Contains rules of thumb to decide which (sub-)algorithms to use for the generation of full components |
| CFullComponentGeneratorCaller | |
| ►CFullComponentGeneratorDreyfusWagner | A generator for restricted full components (for Steiner tree approximations) based on the Dreyfus-Wagner algorithm |
| CDWMData | Subgraphs (given by other subgraphs and additional node pairs) and their cost for a partial solution |
| CDWMSplit | A collection of two subgraphs and their total cost |
| CSortedNodeListHashFunc | |
| ►CFullComponentGeneratorDreyfusWagnerWithoutMatrix | A generator for restricted full components (for Steiner tree approximations) based on the Dreyfus-Wagner algorithm that does not need a precomputed all-pair-shortest-paths matrix because single-source-shortest-path are used within |
| CAuxiliaryGraph | Necessary because ogdf::EdgeWeightedGraphCopy<T> is rubbish |
| CDWMData | Subgraphs (given by other subgraphs and additional edges) and their cost for a partial solution |
| CDWMSplit | A collection of two subgraphs and their total cost |
| CSortedNodeListHashFunc | |
| ►CFullComponentStore | A data structure to store full components |
| CMetadata | |
| CMetadata< Y, typename std::enable_if<!std::is_void< Y >::value >::type > | |
| CFullComponentWithExtraStore | A data structure to store full components with extra data for each component |
| CFullComponentWithLossStore | A data structure to store full components with additional "loss" functionality |
| CHeavyPathDecomposition | An implementation of the heavy path decomposition on trees |
| CLossMetadata | |
| ►CLowerBoundDualAscent | Computes lower bounds for minimum Steiner tree instances |
| CTerminalData | |
| CTerminalDataReference | |
| CLPRelaxationSER | Class managing the component-based subtour elimination LP relaxation for the Steiner tree problem and its solving |
| CSave | This class serves as an interface for different approaches concerning the calculation of save edges |
| CSaveDynamic | Dynamically updatable weighted Tree for determining save edges via LCA computation |
| CSaveEnum | This class computes save edges recursively and stores for every node pair their save edge in a HashArray |
| CSaveStatic | This class behaves basically the same as SaveDynamic except that the update of the weighted graph is not done dynamically here |
| CTriple | This class represents a triple used by various contraction-based minimum Steiner tree approximations |
| CUnorderedNodePairEquality | A class used by the unordered_maps inside the reductions |
| CUnorderedNodePairHasher | A class used by the unordered_maps inside the reductions |
| ►Nsync_plan | |
| ►Ninternal | All operators will only be found when using sync_plan::internal, so no namespace pollution |
| CBlockEmbedding | Internal class used to embed a biconnected component with Q-vertices |
| CEncapsulatedBlock | Information on a single block adjacent to a cut-vertex that is about to be encapsulated |
| CFrozenSimplifyMapping | |
| CSimplifyMapping | |
| CUndoSimplify | |
| CBiconnectedIsolation | Hides all (edges leading to) adjacent biconnected components without changing the current embedding |
| CDoublePipeQueue | Base class for PipeQueues providing a "priority lane" for some pipes and sorting with different functions in both lanes/queues |
| ►CNodeSPQRRotation | Derive embedding trees from an DynamicSPQRForest. Warning: breaks on certain parallel edge configurations! |
| CRigidEmbedding | |
| CNodeSSPQRRotation | Derive embedding trees from Triconnectivity information |
| CPipe | A pair of matched vertices of the same degree, whose rotation shall be synchronized |
| CPipeCmpPtr | A null-safe and priority aware comparator (wrapper) for pipes |
| CPipeQueue | A queue of all pipes, ordered by an arbitrary comparator function |
| CPipeQueueByDegree | PipeQueue yielding pipes in order of descending or ascending degree |
| CPipeQueueByDegreePreferContract | PipeQueue yielding contractable pipes first (or last), in order of descending (or ascending) degree |
| CPipeQueueRandom | PipeQueue yielding pipes in some random (but stable and deterministic) order |
| CPMatching | Manages the matching of P-nodes via pipes in an instance of SyncPlan |
| CQPartitioning | Manages the partitioning of Q-nodes in an instance of SyncPlan |
| CSimplePipeQueue | PipeQueue CRTP base class for ordering pipes by some simple comparator function |
| CSimpleSPQRTree | Wrapper class around Triconnectivity information |
| ►CSyncPlan | A class for modelling and solving Synchronized Planarity instances |
| CResetIndices | |
| CUndoOperation | The information needed for undoing the changes a specific operation made to the graph while maintaining its embedding |
| CVerifyPipeBijections | |
| CSyncPlanComponents | (Bi)Connected components information maintained during the SyncPlan algorithm |
| CSyncPlanConsistency | Consistency checks for debugging the SyncPlan algorithm |
| CSyncPlanDrawer | Utilities by dumping a drawing of the current state of a SyncPlan instance |
| ►Ntlp | |
| CLexer | |
| CParser | |
| CToken | |
| ►Ntopology_module | |
| CEdgeLeg | Helper class for the computation of crossings |
| CAcyclicSubgraphModule | Base class of algorithms for computing a maximal acyclic subgraph |
| CAdjacencyOracle | Tells you in constant time if two nodes are adjacent |
| CAdjElement | Class for adjacency list elements |
| CAdjEntrySet | AdjEntry sets |
| CAdjHypergraphElement | Class for adjacency list elements |
| CAlgorithmFailureException | Exception thrown when an algorithm realizes an internal bug that prevents it from continuing |
| CArray | The parameterized class Array implements dynamic arrays of type E |
| CArray2D | The parameterized class Array2D implements dynamic two-dimensional arrays |
| CArrayBuffer | An array that keeps track of the number of inserted elements; also usable as an efficient stack |
| CArrayLevel | The simple implementation of LevelBase interface |
| CArrayReverseIteratorBase | Random-access reverse iterator based on a pointer to an array element |
| CAStarSearch | A-Star informed search algorithm |
| CAugmentationModule | The base class for graph augmentation algorithms |
| CBalloonLayout | |
| CBarrier | Representation of a barrier |
| CBarycenterHeuristic | The barycenter heuristic for 2-layer crossing minimization |
| CBarycenterPlacer | The barycenter placer for multilevel layout |
| CBasicPageRank | Basic page rank calculation |
| CBCTree | Static BC-trees |
| CBendString | Represents the bends on an edge e consisting of vertical and horizontal segments |
| ►CBertaultLayout | |
| CBertaultSections | The sections associated with each node |
| CCCElement | Objects of this class are members of the containment heirarchy made in preprocessing stage of ImPrEd |
| Cproj | Structure which stores the projection of a node on an edge |
| CBiconnectedShellingOrder | Computation of the shelling order for biconnected graphs |
| ►CBinaryHeap | Heap realized by a data array |
| CHeapEntry | |
| CBinaryHeapSimple | Dynamically growing binary heap tuned for efficiency on a small interface (compared to BinaryHeap) |
| CBinomialHeap | Binomial heap implementation |
| CBinomialHeapNode | Binomial heap node |
| CBitonicOrdering | |
| CBlock | Class representing idea of Blocks used in GlobalSifting and GridSifting algorithms |
| CBlockOrder | Hierarchical graph representation used by GlobalSifting and GridSifting algorithms |
| CBoothLueker | Booth-Lueker planarity test |
| CBoundedQueue | The parameterized class BoundedQueue implements queues with bounded size |
| CBoyerMyrvold | Wrapper class used for preprocessing and valid invocation of the planarity test |
| CBoyerMyrvoldPlanar | This class implements the extended BoyerMyrvold planarity embedding algorithm |
| CBucketEdgeArray | Bucket function for edges |
| CBucketFunc | Abstract base class for bucket functions |
| CBucketSourceIndex | Bucket function using the index of an edge's source node as bucket |
| CBucketTargetIndex | Bucket function using the index of an edge's target node as bucket |
| CCCLayoutPackModule | Base class of algorithms that arrange/pack layouts of connected components |
| CCconnectClusterPlanar | C-planarity test by Cohen, Feng and Eades |
| CCconnectClusterPlanarEmbed | C-planarity test and embedding by Cohen, Feng and Eades |
| CCconnectClusterPlanarityModule | |
| CCirclePlacer | The circle placer for multilevel layout |
| CCircularLayout | The circular layout algorithm |
| CCliqueFinderHeuristic | Finds cliques and dense subgraphs using a heuristic |
| CCliqueFinderModule | Finds cliques |
| CCliqueFinderSPQR | Finds cliques using SPQR trees |
| CClusterAnalysis | |
| CClusterArrayBase | RegisteredArray for labeling the clusters of a ClusterGraph |
| CClusterElement | Representation of clusters in a clustered graph |
| CClusterer | Clustering is determined based on the threshold values (connectivity thresholds determine edges to be deleted) and stopped if average clustering index drops below m_stopIndex |
| CClustererModule | Interface for algorithms that compute a clustering for a given graph |
| CClusterGraph | Representation of clustered graphs |
| CClusterGraphAttributes | Stores additional attributes of a clustered graph (like layout information) |
| CClusterGraphCopy | |
| CClusterGraphCopyAttributes | Manages access on copy of an attributed clustered graph |
| CClusterGraphObserver | Abstract base class for cluster graph observers |
| CClusterOrthoLayout | Represents a planar orthogonal drawing algorithm for c-planar, c-connected clustered graphs |
| CClusterOrthoShaper | Computes the orthogonal representation of a clustered graph |
| CClusterPlanarityModule | |
| ►CClusterPlanarizationLayout | The cluster planarization layout algorithm |
| CClusterPosition | |
| CClusterPlanRep | Planarized representations for clustered graphs |
| CClusterSet | Cluster sets |
| ►CCoffmanGrahamRanking | The coffman graham ranking algorithm |
| C_int_set | |
| CCoinManager | If you use COIN-OR, you should use this class |
| CColor | Colors represented as RGBA values |
| CCombinatorialEmbedding | Combinatorial embeddings of planar graphs with modification functionality |
| CCommonCompactionConstraintGraphBase | Base class for ogdf::CompactionConstraintGraphBase |
| ►CCompactionConstraintGraph | Represents a constraint graph used for compaction |
| CInterval | Represents an interval on the sweep line |
| CSegmentComparer | Comparer class used for sorting segments by increasing position (given by segPos) such that two overlapping segments come in the order imposed by the embedding (given by secSort: segment which comes first has secSort = 0, the other has 1) |
| CCompactionConstraintGraphBase | Class implementing template-parameter-independent behaviour of ogdf::CompactionConstraintGraph |
| CComponentSplitterLayout | |
| CConfiguration | Provides information about how OGDF has been configured |
| CConnectivityTester | Naive implementation for testing the connectivity of a graph |
| CConstCombinatorialEmbedding | Combinatorial embeddings of planar graphs |
| CConvexHull | Computes the convex hull of a set of points or a layout |
| CCPlanarEdgeInserter | Edge insertion algorithm for clustered graphs |
| CCPlanarSubClusteredGraph | Constructs a c-planar subclustered graph of the input based on a spanning tree |
| CCPlanarSubgraphModule | Interface of algorithms for the computation of c-planar subgraphs |
| CCrossingMinimalPosition | Compute a crossing minimal position for a vertex |
| CCrossingMinimalPositionApx | |
| CCrossingMinimalPositionApxWeighted | |
| CCrossingMinimizationModule | Base class for crossing minimization algorithms |
| CCrossingsMatrix | Implements crossings matrix which is used by some TwoLayerCrossingMinimization heuristics (e.g. split) |
| CCrossingVertexOrder | |
| CDavidsonHarel | The Davidson-Harel approach for drawing graphs |
| CDavidsonHarelLayout | The Davidson-Harel layout algorithm |
| CDefHashFunc | Default hash functions |
| CDefHashFunc< double > | Specialized default hash function for double |
| CDefHashFunc< IPoint > | |
| CDefHashFunc< string > | Specialized default hash function for string |
| CDefHashFunc< void * > | Specialized default hash function for pointer types |
| CDeletingTop10Heap | A variant of Top10Heap which deletes the elements that get rejected from the heap |
| CDfsAcyclicSubgraph | DFS-based algorithm for computing a maximal acyclic subgraph |
| CDfsMakeBiconnected | Implementation of a DFS-based algorithm for biconnectivity augmentation |
| CDijkstra | Dijkstra's single source shortest path algorithm |
| CDIntersectableRect | Rectangles with real coordinates |
| CDisjointSets | A Union/Find data structure for maintaining disjoint sets |
| CDLParser | |
| CDominanceLayout | |
| CDPolygon | Polygons with real coordinates |
| CDRect | Rectangles with real coordinates |
| ►CDTreeMultilevelEmbedder | |
| CNodeCoords | |
| CDTreeMultilevelEmbedder2D | |
| CDTreeMultilevelEmbedder3D | |
| CDualGraphBase | A dual graph including its combinatorial embedding of an embedded graph |
| CDynamicBCTree | Dynamic BC-trees |
| CDynamicCastFailedException | Exception thrown when result of cast is 0 |
| CDynamicPlanarSPQRTree | SPQR-trees of planar graphs |
| CDynamicSkeleton | Skeleton graphs of nodes in a dynamic SPQR-tree |
| CDynamicSPQRForest | Dynamic SPQR-forest |
| CDynamicSPQRTree | Linear-time implementation of dynamic SPQR-trees |
| CEdgeComparer | Compares adjacency entries based on the position of the nodes given by GraphAttribute layout information |
| CEdgeComparerSimple | Compares incident edges of a node based on the position of the last bend point or the position of the adjacent node given by the layout information of the graph |
| CEdgeCoverMerger | The edge cover merger for multilevel layout |
| CEdgeElement | Class for the representation of edges |
| CEdgeIndependentSpanningTrees | Calculates k edge-independent spanning trees of a graph |
| CEdgeInsertionModule | Interface for edge insertion algorithms |
| CEdgeLabel | |
| CEdgeOrderComparer | Orders edges such that they do not cross each other when embeddded as insertion paths |
| CEdgeRouter | Places node boxes in replacement areas of orthogonal drawing step and route edges to minimize bends |
| CEdgeSet | Edge sets |
| CEdgeStandardRep | Edge standard representation of hypergraphs |
| CEdgeWeightedGraph | |
| CEdgeWeightedGraphCopy | |
| CELabelInterface | |
| CELabelPosSimple | |
| CEmbedderMaxFace | Embedder that maximizes the external face |
| CEmbedderMaxFaceBiconnectedGraphs | Embedder that maximizing the external face |
| CEmbedderMaxFaceBiconnectedGraphsLayers | Embedder that maximizes the external face (plus layers approach) |
| CEmbedderMaxFaceLayers | Embedder that maximizes the external face and optimizes the position of blocks afterwards |
| CEmbedderMinDepth | Embedder that minimizes block-nesting depth |
| CEmbedderMinDepthMaxFace | Embedding that minimizes block-nesting depth and maximizes the external face |
| CEmbedderMinDepthMaxFaceLayers | Planar graph embedding that minimizes block-nesting depth and maximizes the external face and optimizes the position of blocks afterwards |
| CEmbedderMinDepthPiTa | Embedder that minimizes block-nesting depth for given embedded blocks |
| CEmbedderModule | Base class for embedder algorithms |
| CEmbedderOptimalFlexDraw | The algorithm computes a planar embedding with minimum cost |
| CENGLayer | Represents layer in an extended nesting graph |
| CEpsilonTest | |
| CException | Base class of all ogdf exceptions |
| CExpansionGraph | Represents expansion graph of each biconnected component of a given digraph, i.e., each vertex v with in- and outdegree greater than 1 is expanded into two vertices x and y connected by an edge x->y such that all incoming edges are moved from v to x and all outgoing edges from v to y |
| CExtendedNestingGraph | |
| CExternE | List of externally active nodes strictly between x and y for minortypes B and E |
| CExtractKuratowskis | Extracts multiple Kuratowski Subdivisions |
| CFaceArrayBase | RegisteredArray for labeling the faces of a CombinatorialEmbedding |
| CFaceElement | Faces in a combinatorial embedding |
| CFaceSet | Face sets |
| CFaceSinkGraph | |
| CFastHierarchyLayout | Coordinate assignment phase for the Sugiyama algorithm by Buchheim et al |
| CFastMultipoleEmbedder | The fast multipole embedder approach for force-directed layout |
| CFastMultipoleMultilevelEmbedder | The fast multipole multilevel embedder approach for force-directed multilevel layout |
| CFastSimpleHierarchyLayout | Coordinate assignment phase for the Sugiyama algorithm by Ulrik Brandes and Boris Köpf |
| CFibonacciHeap | Fibonacci heap implementation |
| CFibonacciHeapNode | Fibonacci heap node |
| CFill | Properties of fills |
| CFilteringBFS | An iterator-based BFS through a Graph |
| CFilteringBFSIterator | |
| CFindKuratowskis | This class collects information about Kuratowski Subdivisions which is used for extraction later |
| CFixedEmbeddingInserter | Inserts edges optimally into an embedding |
| CFixedEmbeddingInserterUML | Edge insertion module that inserts each edge optimally into a fixed embedding |
| CFixedEmbeddingUpwardEdgeInserter | Edge insertion module that inserts each edge optimally into a fixed embedding |
| CFixEdgeInserterCore | |
| CFixEdgeInserterUMLCore | |
| CFlowCompaction | Compaction algorithm using min-cost flow in the dual of the constraint graph |
| CFMMMLayout | The fast multipole multilevel layout algorithm |
| CFMMMOptions | |
| CForceLayoutModule | Interface of general layout algorithms |
| CFourBlockTree | A node in a 4-block tree |
| CFPPLayout | The class FPPLayout represents the layout algorithm by de Fraysseix, Pach, Pollack [DPP90] |
| CFUPSModule | Interface for feasible upward planar subgraph algorithms |
| CFUPSSimple | |
| CGEMLayout | The energy-based GEM layout algorithm |
| CGenericComparer | Compare elements based on a single comparable attribute |
| CGenericLine | Infinite lines |
| CGenericPoint | Parameterized base class for points |
| CGenericPolyline | Polylines with PointType points |
| CGenericSegment | Finite line segments |
| CGeometricEdgeInsertion | |
| CGeometricVertexInsertion | |
| ►CGF2Solver | |
| CChunk | |
| CChunk2 | |
| CChunkBase | |
| CEquation | |
| CMatrix | |
| CRow2 | |
| CGlobalSifting | The global sifting heuristic for crossing minimization |
| CGlueMap | This is a helper class to make the glueing of two edges simpler |
| ►CGraph | Data type for general directed graphs (adjacency list representation) |
| CCCsInfo | Info structure for maintaining connected components |
| CHiddenEdgeSet | Functionality for temporarily hiding edges in constant time |
| CGraphAdjIterator | Iterator for AdjEntries of a graph |
| CGraphAttributes | Stores additional attributes of a graph (like layout information) |
| CGraphCopy | Copies of graphs supporting edge splitting |
| CGraphCopyBase | |
| CGraphCopySimple | Copies of graphs with mapping between nodes and edges |
| ►CGraphIO | Utility class providing graph I/O in various exchange formats |
| CFileType | |
| CSVGSettings | Condensed settings for drawing SVGs |
| CGraphMLParser | |
| CGraphObserver | Abstract Base class for graph observers |
| CGraphReduction | Creates a reduced graph by removing leaves, self-loops, and reducing chains |
| CGreedyCycleRemoval | Greedy algorithm for computing a maximal acyclic subgraph |
| CGreedyInsertHeuristic | The greedy-insert heuristic for 2-layer crossing minimization |
| CGreedySwitchHeuristic | The greedy-switch heuristic for 2-layer crossing minimization |
| CGridLayout | Representation of a graph's grid layout |
| CGridLayoutMapped | Extends GridLayout by a grid mapping mechanism |
| CGridLayoutModule | Base class for grid layout algorithms |
| CGridLayoutPlanRepModule | Base class for grid layout algorithms operating on a PlanRep |
| CGridSifting | The grid sifting heuristic for crossing minimization |
| ►CHananiTutteCPlanarity | C-planarity testing via Hanani-Tutte approach |
| CHananiTutteSolver | |
| CStats | |
| CHashArray | Indexed arrays using hashing for element access |
| CHashArray2D | Indexed 2-dimensional arrays using hashing for element access |
| CHashConstIterator | Iterators for hash tables |
| CHashConstIterator2D | Const-iterator for 2D-hash arrays |
| CHashElement | Representation of elements in a hash table |
| CHashElementBase | Base class for elements within a hash table |
| CHashFuncTuple | |
| CHashing | Hashing with chaining and table doubling |
| CHashingBase | Base class for hashing with chaining and table doubling |
| CHeapBase | Common interface for all heap classes |
| CHierarchy | Representation of proper hierarchies used by Sugiyama-layout |
| CHierarchyClusterLayoutModule | Interface of hierarchy layout algorithms for cluster graphs |
| CHierarchyLayoutModule | Interface of hierarchy layout algorithms |
| CHierarchyLevels | Representation of proper hierarchies used by Sugiyama-layout |
| CHierarchyLevelsBase | |
| ►CHotQueue | Heap-on-Top queue implementation |
| CHeapComparator | Comparator used by underlying heap |
| CHotQueueHandle | Heap-on-Top handle to inserted items |
| CHotQueueNode | Heap-on-Top bucket element |
| CHyperedgeElement | Class for the representation of hyperedges |
| CHypergraph | |
| CHypergraphAttributes | Stores additional attributes of a hypergraph |
| CHypergraphAttributesES | Stores additional attributes of edge standard representation of a hypergraph |
| CHypergraphLayoutES | |
| CHypergraphLayoutModule | Interface of hypergraph layout algorithms |
| CHypergraphObserver | |
| CHypergraphRegisteredArray | RegisteredArray for nodes and edges of a hypergraph |
| CHypergraphRegistry | Registry for nodes and edges of a hypergraph |
| CHypernodeElement | Class for the representation of hypernodes |
| CILPClusterPlanarity | C-planarity testing via completely connected graph extension |
| CIncNodeInserter | |
| CIndependentSetMerger | The independent set merger for multilevel layout |
| CInitialization | The class Initialization is used for initializing global variables |
| CInitialPlacer | Base class for placer modules |
| CInOutPoint | Representation of an in- or outpoint |
| CInsufficientMemoryException | Exception thrown when not enough memory is available to execute an algorithm |
| CIOPoints | Representation of in- and outpoint lists |
| CKuratowskiStructure | A Kuratowski Structure is a special graph structure containing severals subdivisions |
| CKuratowskiSubdivision | |
| CKuratowskiWrapper | Wrapper-class for Kuratowski Subdivisions containing the minortype and edgelist |
| CLayerBasedUPRLayout | |
| CLayerByLayerSweep | Interface of two-layer crossing minimization algorithms |
| CLayeredCrossMinModule | Interface of crossing minimization algorithms for layered graphs |
| CLayout | Stores a layout of a graph (coordinates of nodes, bend points of edges) |
| CLayoutClusterPlanRepModule | Interface for planar cluster layout algorithms |
| CLayoutModule | Interface of general layout algorithms |
| CLayoutPlanRepModule | Interface for planar layout algorithms (used in the planarization approach) |
| CLayoutPlanRepUMLModule | Interface for planar UML layout algorithms |
| CLayoutStandards | Standard values for graphical attributes and layouts |
| CLayoutStatistics | Computes statistical information about a layout |
| CLCA | Implements the <O(n log n), O(1)>-time "sparse table" algorithm by Bender and Farach-Colton to compute lowest common ancestors (LCAs) in arborescences (not arbitrary directed acyclic graphs) |
| ►CLeftistOrdering | |
| CCandidate | |
| CPartitioning | |
| CLevel | Representation of levels in hierarchies |
| CLevelBase | Representation of levels in hierarchies |
| ►CLHTreeNode | |
| CAdjacency | |
| CClusterCrossing | |
| CLibraryNotSupportedException | Exception thrown when an external library shall be used which is not supported |
| CLinearLayout | Layout the graph with nodes next to each other with natural or custom order and draw the edges as semicircular bows above them |
| CList | Doubly linked lists (maintaining the length of the list) |
| CListContainer | |
| CListElement | Structure for elements of doubly linked lists |
| CListIteratorBase | Encapsulates a pointer to a list element |
| CListPure | Doubly linked lists |
| CLocalBiconnectedMerger | The local biconnected merger for multilevel layout |
| ►CLogger | Centralized global and local logging facility working on streams like std::cout |
| CIndent | |
| CLongestPathCompaction | Compaction algorithm using longest paths in the constraint graph |
| CLongestPathRanking | The longest-path ranking algorithm |
| CLPSolver | |
| ►CMallocMemoryAllocator | Implements a simple memory manager using malloc() and free() |
| CMemElem | |
| CMatchingBlossom | Implementation of the Blossom-I algorithm by Edmonds (1965) for Minimum Weight Perfect Matching |
| ►CMatchingBlossomV | Implementation of the Blossom-V algorithm by Kolmogorov (2009) for Minimum Weight Perfect Matching |
| Cstats | Structure to store statistics |
| CMatchingMerger | The matching merger for multilevel layout |
| CMatchingModule | |
| CMaxAdjOrdering | Calculate one or all Maximum Adjacency Ordering(s) of a given simple undirected graph |
| CMaxFlowEdmondsKarp | Computes a max flow via Edmonds-Karp |
| CMaxFlowGoldbergTarjan | Computes a max flow via Preflow-Push (global relabeling and gap relabeling heuristic) |
| CMaxFlowModule | |
| CMaxFlowSTPlanarDigraph | Computes a max flow in s-t-planar network via dual shortest paths |
| CMaxFlowSTPlanarItaiShiloach | Computes a max flow in s-t-planar network via uppermost paths |
| CMaximalFUPS | |
| CMaximalPlanarSubgraphSimple< TCost, typename std::enable_if< std::is_floating_point< TCost >::value >::type > | |
| CMaximalPlanarSubgraphSimple< TCost, typename std::enable_if< std::is_integral< TCost >::value >::type > | Naive maximal planar subgraph approach that extends a configurable non-maximal subgraph heuristic |
| CMaximumCPlanarSubgraph | Exact computation of a maximum c-planar subgraph |
| CMaximumPlanarSubgraph | Exact computation of a maximum planar subgraph |
| CMaxSequencePQTree | The class template MaxSequencePQTree is designed to compute a maximal consecutive sequence of pertinent leaves in a PQ-tree |
| CMedianHeuristic | The median heuristic for 2-layer crossing minimization |
| CMedianPlacer | The median placer for multilevel layout |
| CMinCostFlowModule | Interface for min-cost flow algorithms |
| ►CMinCostFlowReinelt | Computes a min-cost flow using a network simplex method |
| Carctype | |
| Cnodetype | |
| CMinimumCutModule | Serves as an interface for various methods to compute minimum cuts with or without edge weights |
| ►CMinimumCutNagamochiIbaraki | Calculate minimum cut value for a given Graph |
| CadjInfo | |
| CBoundedList | |
| Cclusterstruct | |
| CMinimumCutStoerWagner | Computes a minimum cut in a graph |
| ►CMinimumEdgeDistances | Maintains input sizes for improvement compaction (deltas and epsilons) |
| CInfoType | |
| CMinSTCutBFS | Min-st-cut algorithm, that calculates the cut by doing a depth first search over the dual graph of of an st-planar input graph |
| CMinSTCutDijkstra | Min-st-cut algorithm, that calculates the cut by calculating the shortest path between the faces adjacent to an edge between s and t, via the algorithm by Dijkstra on the dual graph |
| CMinSTCutMaxFlow | Min-st-cut algorithm, that calculates the cut via maxflow |
| CMinSTCutModule | |
| ►CMinSteinerTreeDirectedCut | This class implements the Directed Cut Integer Linear Program for the Steiner tree problem |
| CDegreeConstraint | Constraint for nodes, e.g., in/outdegree stuff |
| CDegreeEdgeConstraint | Constraint for relating the indegree and one outgoing edge of a node |
| CDirectedCutConstraint | Class for directed cuts (i.e., separated Steiner cuts) |
| CEdgeConstraint | Constraint for edges, e.g., subtour elimination constraints of size 2 ((G)SEC2) |
| CEdgeVariable | Variable for directed edges |
| CMaster | Master problem of Steiner tree branch&cut algorithm |
| CSub | Subproblem of Steiner tree algorithm |
| CMinSteinerTreeDualAscent | Dual ascent heuristic for the minimum Steiner tree problem |
| ►CMinSteinerTreeGoemans139 | This class implements the (1.39+epsilon)-approximation algorithm for the Steiner tree problem by Goemans et |
| CMain | Class managing LP-based approximation |
| CMinSteinerTreeKou | This class implements the Minimum Steiner Tree 2-approximation algorithm by Kou et al |
| ►CMinSteinerTreeMehlhorn | This class implements the Minimum Steiner Tree 2-approximation algorithm by Mehlhorn |
| CMehlhornTriple | Represents a triple as specified in the algorithms description (see paper) |
| CMehlhornTripleBucketMaxFunc | Helper class to sort MehlhornTriples lexicographically |
| CMehlhornTripleBucketMinFunc | Helper class to sort MehlhornTriples lexicographically |
| CMinSteinerTreeModule | Serves as an interface for various methods to compute or approximate minimum Steiner trees on undirected graphs with edge costs |
| CMinSteinerTreePrimalDual | Primal-Dual approximation algorithm for Steiner tree problems |
| ►CMinSteinerTreeRZLoss | This class implements the loss-contracting (1.55+epsilon)-approximation algorithm for the Steiner tree problem by Robins and Zelikovsky |
| CMain | |
| CMinSteinerTreeShore | Implementation of Shore, Foulds and Gibbons exact branch and bound algorithm for solving Steiner tree problems |
| CMinSteinerTreeTakahashi | This class implements the minimum Steiner tree 2-approximation algorithm by Takahashi and Matsuyama with improvements proposed by Poggi de Aragao et al |
| CMinSteinerTreeZelikovsky | This class implements the 11/6-approximation algorithm by Zelikovsky for the minimum Steiner tree problem along with variants and practical improvements |
| CMixedModelBase | |
| CMixedModelCrossingsBeautifierModule | The base class for Mixed-Model crossings beautifier algorithms |
| CMixedModelLayout | Implementation of the Mixed-Model layout algorithm |
| CMMCBBase | Common base class for MMCBDoubleGrid and MMCBLocalStretch |
| CMMCBDoubleGrid | Crossings beautifier using grid doubling |
| CMMCBLocalStretch | Crossings beautifier using a local stretch strategy |
| CMMCrossingMinimizationModule | Interface for minor-monotone crossing minimization algorithms |
| CMMDummyCrossingsBeautifier | Dummy implementation of Mixed-Model crossings beautifier |
| CMMEdgeInsertionModule | Interface for minor-monotone edge insertion algorithms |
| CMMFixedEmbeddingInserter | Minor-monotone edge insertion with fixed embedding |
| CMMOrder | |
| CMMSubgraphPlanarizer | Planarization approach for minor-monotone crossing minimization |
| ►CMMVariableEmbeddingInserter | Minor-monotone edge insertion with variable embedding |
| CAnchorNodeInfo | |
| CPaths | |
| CModifiedNibbleClusterer | The modified nibble clustering algorithm |
| CModularMultilevelMixer | Modular multilevel graph layout |
| CModule | Base class for modules |
| ►CMultiEdgeApproxInserter | Multi edge inserter with approximation guarantee |
| CVertexBlock | |
| CMultilevelBuilder | Base class for merger modules |
| CMultilevelGraph | |
| CMultilevelLayout | The multilevel drawing framework |
| CMultilevelLayoutModule | Interface of general layout algorithms that also allow a MultilevelGraph as call parameter, extending the interface of a simple LayoutModule |
| ►CNearestRectangleFinder | Finds in a given set of rectangles for each point in a given set of points the nearest rectangle |
| CPairRectDist | Represents a rectangle (given by its index) and a distance value |
| CRectRegion | Represents a rectangle given by center point, width and height |
| ►CNodeColoringBergerRompel | Approximation algorithms for the node coloring problem in graphs |
| CSearchWrapperBergerRompel | Wraps the parameterized Berger&Rompel algorithm |
| CNodeColoringBoppanaHalldorsson | Approximation algorithms for the node coloring problem in graphs |
| ►CNodeColoringHalldorsson | Approximation algorithms for the node coloring problem in graphs |
| CSearchWrapperHalldorsson | Wraps the recursive Halldórsson algorithm |
| CNodeColoringJohnson | Approximation algorithms for the node coloring problem in graphs |
| ►CNodeColoringModule | Approximation algorithms for the node coloring problem in graphs |
| CSearchWrapper | Wraps the search for the minimum parameter k so that the same code can be reused for all algorithms |
| CSubsetIterator | Struct to iterate over all node subsets of a given size |
| CNodeColoringRecursiveLargestFirst | A simple greedy node coloring heuristic in graphs |
| ►CNodeColoringSequential | Approximation algorithms for the node coloring problem in graphs |
| CNodeDegreeComparer | Class for comparing two nodes by the node degree |
| CNodeColoringSimple | Approximation algorithms for the node coloring problem in graphs |
| ►CNodeColoringWigderson | Approximation algorithms for the node coloring problem in graphs |
| CSearchWrapperWigderson | Wraps the Wigderson recursive algorithm |
| CNodeElement | Class for the representation of nodes |
| CNodeMerge | |
| CNodePair | |
| CNodeRespecterLayout | The NodeRespecterLayout layout algorithm |
| CNodeSet | Node sets |
| ►CNonPlanarCore | Non-planar core reduction |
| CCutEdge | Struct to represent an edge that needs to be crossed in order to cross an st-component |
| CNoStdComparerException | Exception thrown when a required standard comparer has not been specialized |
| CObservable | Base class for an observable object that can be tracked by multiple Observer objects |
| CObserver | Base class for an observer for a single Observable object |
| COGDFAllocator | Encapsulates OGDF_ALLOCATOR in a class that can be used as the Allocator for containers of the C++ standard library |
| COptimalHierarchyClusterLayout | The LP-based hierarchy cluster layout algorithm |
| COptimalHierarchyLayout | The LP-based hierarchy layout algorithm |
| COptimalRanking | The optimal ranking algorithm |
| COrderComparer | |
| COrthoLayout | The Orthogonal layout algorithm for planar graphs |
| COrthoLayoutUML | Represents planar orthogonal drawing algorithm for mixed-upward planar embedded graphs (UML-diagrams) |
| ►COrthoRep | Orthogonal representation of an embedded graph |
| CSideInfoUML | Information about a side of a vertex in UML diagrams |
| CVertexInfoUML | Further information about the cages of vertices in UML diagrams |
| COrthoShaper | |
| COverlappingGraphCopies | The manager class for multiple OverlappingGraphCopy instances of the same graph |
| COverlappingGraphCopy | Version of GraphCopySimple that may efficiently share some overlap with other instances of the same original Graph via its OverlappingGraphCopies manager |
| CPairingHeap | Pairing heap implementation |
| CPairingHeapNode | Pairing heap node |
| CPALabel | Auxiliary class for the planar augmentation algorithm |
| CPertinentGraph | Pertinent graphs of nodes in an SPQR-tree |
| CPivotMDS | The Pivot MDS (multi-dimensional scaling) layout algorithm |
| CPlanarAugmentation | The algorithm for planar biconnectivity augmentation (Mutzel, Fialko) |
| CPlanarAugmentationFix | The algorithm for biconnectivity augmentation with fixed combinatorial embedding |
| CPlanarDrawLayout | Implementation of the Planar-Draw layout algorithm |
| CPlanarGridLayoutModule | Base class for planar grid layout algorithms |
| CPlanarityModule | Module for planarity testing and planar embeddings |
| CPlanarizationGridLayout | The planarization grid layout algorithm |
| CPlanarizationLayout | The planarization approach for drawing graphs |
| CPlanarizationLayoutUML | The planarization layout algorithm |
| CPlanarizerChordlessCycle | Starts with a chordless cycle of the graph and then inserts each original node that is adjacent to already inserted ones via the StarInserter |
| CPlanarizerMixedInsertion | Computes a planar subgraph of the graph and then re-inserts each original node that is incident to at least one edge not in the subgraph via the StarInserter |
| CPlanarizerStarReinsertion | The star (re-)insertion approach for crossing minimization |
| CPlanarSeparatorModule | Abstract description of all planar separator algorithms |
| CPlanarSPQRTree | SPQR-trees of planar graphs |
| CPlanarStraightLayout | Implementation of the Planar-Straight layout algorithm |
| CPlanarSubgraphBoyerMyrvold | Maximum planar subgraph heuristic based on the Boyer-Myrvold planarity test |
| CPlanarSubgraphCactus | Maximum planar subgraph approximation algorithm by Calinescu et al |
| CPlanarSubgraphEmpty | Dummy implementation for maximum planar subgraph that returns an empty graph |
| ►CPlanarSubgraphFast | Computation of a planar subgraph using PQ-trees |
| CThreadMaster | |
| CWorker | |
| CPlanarSubgraphModule | Interface for planar subgraph algorithms |
| CPlanarSubgraphPQTree | |
| CPlanarSubgraphTree | Maximum planar subgraph heuristic that yields a spanning tree |
| CPlanarSubgraphTriangles | Maximum planar subgraph approximation algorithms by Chalermsook/Schmid and Calinescu et al |
| ►CPlanRep | Planarized representations (of a connected component) of a graph |
| CDeg1RestoreInfo | Information for restoring degree-1 nodes |
| ►CPlanRepExpansion | Planarized representations (of a connected component) of a graph |
| CCrossing | |
| CNodeSplit | Representation of a node split in a planarized expansion |
| CPlanRepInc | This class is only an adaption of PlanRep for the special incremental drawing case |
| CPlanRepLight | Light-weight version of a planarized representation, associated with a PlanRep |
| CPlanRepUML | Planarized representation (of a connected component) of a UMLGraph; allows special handling of hierarchies in the graph |
| ►CPoolMemoryAllocator | Allocates memory in large chunks for better runtime |
| CMemElem | Basic memory element used to realize a linked list of deallocated memory segments |
| CPQBasicKey | |
| CPQBasicKeyRoot | The class PQBasicKeyRoot is used as a base class of the class template basicKey |
| CPQInternalKey | The class template PQInternalKey is a derived class of class template PQBasicKey |
| CPQInternalNode | The class template PQInternalNode is used to present P-nodes and Q-nodes in the PQ-Tree |
| CPQLeaf | The datastructure PQ-tree was designed to present a set of permutations on an arbitrary set of elements |
| CPQLeafKey | The class template PQLeafKey is a derived class of class template PQBasicKey |
| CPQNode | The class template PQBasicKey is an abstract base class |
| CPQNodeKey | The class template PQNodeKey is a derived class of class template PQBasicKey |
| CPQNodeRoot | The class PQNodeRoot is used as a base class of the class PQNode |
| CPQTree | |
| ►CPreprocessorLayout | The PreprocessorLayout removes multi-edges and self-loops |
| CEdgeData | Deleted Edges are stored in EdgeData |
| CPrioritized | Augments any data elements of type X with keys of type Priority. This class is also its own Comparer |
| CPrioritizedMapQueue | Prioritized queue interface wrapper for heaps |
| CPrioritizedMapQueue< edge, P, C, Impl, HashFunc > | Specialization for edge elements |
| CPrioritizedMapQueue< node, P, C, Impl, HashFunc > | Specialization for node elements |
| CPriorityQueue | Priority queue interface wrapper for heaps |
| CProcrustesPointSet | |
| CProcrustesSubLayout | Simple procrustes analysis |
| CQueue | The parameterized class Queue<E> implements list-based queues |
| CQueueEntry | |
| CQueuePure | Implementation of list-based queues |
| CRadialTreeLayout | The radial tree layout algorithm |
| CRadixHeap | Radix heap data structure implementation |
| CRadixHeapNode | |
| CRandomClusterConfig | Parameters for the randomPlanarClustering() method |
| CRandomMerger | The random merger for multilevel layout |
| CRandomPlacer | The random placer for multilevel layout |
| CRandomVertexPosition | Interface for computing a good / optimal vertex position |
| CRange | Simple before-C++20 version for std::ranges::ref_view |
| CRankingModule | Interface of algorithms for computing a node ranking |
| CRCCrossings | |
| CRegisteredArray | Dynamic arrays indexed with arbitrary keys |
| CRegisteredArray< Registry, bool, WithDefault, Base > | Specialization to work around vector<bool> |
| CRegisteredArrayIterator | Iterator for registered arrays |
| CRegisteredMultiArray | Data structure for two-dimensional mappings that are sparse in the second dimension |
| CRegisteredObserver | Abstract Base class for registry observers |
| CRegisteredSet | Constant-time set operations |
| CRegistryBase | Abstract base class for registries |
| CReverse | A wrapper class to easily iterate through a container in reverse |
| CRMHeap | Randomized meldable heap implementation |
| CRMHeapNode | Randomized meldable heap node |
| ►CRoutingChannel | Maintains input sizes for constructive compaction (size of routing channels, separation, cOverhang) |
| CvInfo | |
| CScalingLayout | Scales a graph layout and calls a secondary layout algorithm |
| CSchnyderLayout | The class SchnyderLayout represents the layout algorithm by Schnyder [Sch90] |
| CSeparatorDual | Computes planar separators using the Dual of the graph |
| CSeparatorDualFC | Computes planar separators by applying the Fundamental Cycle Lemma directly, without trying tree levels first |
| CSeparatorHarPeled | Computes planar separators according to Har-Peled |
| CSeparatorLiptonTarjan | Computes planar separators according to Lipton and Tarjan 1979 |
| CSeparatorLiptonTarjanFC | Computes planar separators using Fundamental Cycles |
| CShellingOrder | The shelling order of a graph |
| CShellingOrderModule | Base class for modules that compute a shelling order of a graph |
| CShellingOrderSet | The node set in a shelling order of a graph |
| CShortestPathModule | |
| CShortestPathWithBFM | Computes single-source shortest-paths with Bellman-Ford-Moore's algorithm |
| CSiftingHeuristic | The sifting heuristic for 2-layer crossing minimization |
| CSimDraw | The Base class for simultaneous graph drawing |
| CSimDrawCaller | Calls modified algorithms for simdraw instances |
| ►CSimDrawColorizer | Adds color to a graph |
| CSimDrawColorScheme | Manages the various color schemes |
| CSimDrawCreator | Creates variety of possible SimDraw creations |
| CSimDrawCreatorSimple | Offers predefined SimDraw creations |
| CSimDrawManipulatorModule | Interface for simdraw manipulators |
| CSimpleCCPacker | Splits and packs the components of a Graph |
| CSimpleCluster | |
| CSimpleEmbedder | Embedder that chooses a largest face as the external one |
| CSimpleIncNodeInserter | |
| CSkeleton | Skeleton graphs of nodes in an SPQR-tree |
| ►CSkiplist | A randomized skiplist |
| CElement | Internal structure to hold the items and internal forward pointers of the skiplist |
| CSkiplistIterator | Forward-Iterator for Skiplists |
| CSList | Singly linked lists (maintaining the length of the list) |
| CSListElement | Structure for elements of singly linked lists |
| CSListIteratorBase | Encapsulates a pointer to an ogdf::SList element |
| CSListPure | Singly linked lists |
| ►CSolarMerger | The solar merger for multilevel layout |
| CPathData | |
| CSolarPlacer | The solar placer for multilevel layout |
| ►CSortedSequence | Maintains a sequence of (key,info) pairs sorted by key |
| CElement | Internal structure to hold the items and internal forward/backward pointers of the skiplist |
| CSortedSequenceIteratorBase | Iterators for sorted sequences |
| ►CSpannerBasicGreedy | Multiplicative spanner by greedily adding edges |
| CEdgeWeightComparator | |
| CSpannerBaswanaSen | Randomized multiplicative spanner calculation by forming clusters |
| CSpannerBaswanaSenIterated | Use the ogdf::SpannerIteratedWrapper to execute the ogdf::SpannerBaswanaSen algorithm up to 1000 times |
| CSpannerBerman | Approximation algorithm for calculating spanners |
| CSpannerBermanDisconnected | Wrapper around SpannerBerman: For each component of the graph, the algorithm will be called |
| ►CSpannerElkinNeiman | Randomized multiplicative spanner calculation by propagating random messages through the graph |
| CBfsNode | |
| CSpannerElkinNeimanIterated | Use the ogdf::SpannerIteratedWrapper to execute the ogdf::SpannerElkinNeiman algorithm up to 200 times |
| CSpannerIteratedWrapper | A implementation-independed wrapper class to execute a spanner algorithm multiple times |
| CSpannerKortsarzPeleg | Approximation multiplicative 2-spanner calculation |
| ►CSpannerModule | Interface for spanner algorithms |
| CTimeoutException | A simple exception used to exit from the execution, if the timelimit is reached |
| CSplitHeuristic | The split heuristic for 2-layer crossing minimization |
| CSPQRTree | Linear-time implementation of static SPQR-trees |
| ►CSpringEmbedderFRExact | Fruchterman-Reingold algorithm with (exact) layout |
| CArrayGraph | |
| ►CSpringEmbedderGridVariant | The spring-embedder layout algorithm with force approximation using hte grid variant approach |
| CForceModelBase | |
| CForceModelEades | |
| CForceModelFR | |
| CForceModelFRModAttr | |
| CForceModelFRModRep | |
| CForceModelGronemann | |
| CForceModelHachul | |
| CNodeInfo | |
| CSpringEmbedderKK | The spring-embedder layout algorithm by Kamada and Kawai |
| CStarInserter | Inserts a star (a vertex and its incident edges) optimally into an embedding |
| CStaticPlanarSPQRTree | SPQR-trees of planar graphs |
| CStaticSkeleton | Skeleton graphs of nodes in a static SPQR-tree |
| CStaticSPQRTree | Linear-time implementation of static SPQR-trees |
| CStdComparer | Standard comparer (valid as a static comparer) |
| CStdComparer< bool > | Generates a specialization of the standard static comparer for booleans |
| CStdComparer< Prioritized< X, Priority > > | |
| CSteinerTreeLowerBoundDualAscent | Implementation of a dual-ascent-based lower bound heuristic for Steiner tree problems |
| CSteinerTreePreprocessing | This class implements preprocessing strategies for the Steiner tree problem |
| CStlGreater | Template for converting any StdComparer into a STL compatible compare functor |
| CStlLess | Template for converting any StdComparer into a STL compatible compare functor |
| CStopwatch | Realizes a stopwatch for measuring elapsed time |
| CStopwatchCPU | Implements a stopwatch measuring CPU time |
| CStopwatchWallClock | Implements a stopwatch measuring wall-clock time |
| CStressMinimization | Energy-based layout using stress minimization |
| CStroke | Properties of strokes |
| CSubgraphPlanarizer | The planarization approach for crossing minimization |
| CSubgraphPlanarizerUML | The planarization approach for UML crossing minimization |
| CSubgraphUpwardPlanarizer | Takes an acyclic connected non-upward-planar graph and planarizes it, i.e., we obtain an upward-planar graph where crossings are represented via dummy vertices |
| CSubsetEnumerator | Enumerator for k-subsets of a given type |
| CSugiyamaLayout | Sugiyama's layout algorithm |
| CSvgPrinter | SVG Writer |
| CSyncPlanClusterPlanarityModule | ClusterPlanarity testing in quadratic time using the Synchronized Planarity approach |
| CSystem | System specific functionality |
| CTargetComparer | A static comparer which compares the target of pointers ("content"), instead of the pointer's adresses |
| CThread | Threads supporting OGDF's memory management |
| CTikzWriter | LaTeX+TikZ Writer |
| ►CTileToRowsCCPacker | The tile-to-rows algorithm for packing drawings of connected components |
| CRowInfo | |
| CTimeouter | Class for timeout funtionality |
| CTokenIgnorer | |
| CTop10Heap | A variant of BinaryHeapSimple which always holds only the 10 elements with the highest keys |
| CTopologyModule | Constructs embeddings from given layout |
| CTreeLayout | The tree layout algorithm |
| CTriconnectedShellingOrder | Computation of a shelling order for a triconnected and simple (no multi-edges, no self-loops) planar graph |
| ►CTriconnectivity | Realizes Hopcroft/Tarjan algorithm for finding the triconnected components of a biconnected multi-graph |
| CCompStruct | Representation of a component |
| CTsplibXmlParser | Parses tsplib files in xml format |
| CTuple2 | Tuples of two elements (2-tuples) |
| CTutteLayout | Tutte's layout algorithm |
| CTwoLayerCrossMinSimDraw | |
| CTwoSAT | A simple solver for TwoSAT instances, representing the instance as implication graph and solving it via its strongly-connected components |
| Ctwosat_var | In debug mode, twosat_var is a class instead of a simple int to prevent unintened use of the default 0-value instead of TwoSAT_Var_Undefined |
| CTypeNotSupportedException | Exception thrown when a data type is not supported by a generic function |
| CUMLCrossingMinimizationModule | Base class for UML crossing minimization algorithms |
| CUmlDiagramGraph | Contains the class UmlDiagramGraph which represents one particular diagram of the complete UML Model |
| CUMLEdgeInsertionModule | Interface for UML edge insertion algorithms |
| ►CUMLGraph | |
| CAssociationClass | Modelling of association classes |
| CUMLLayoutModule | Interface of UML layout algorithms |
| CUmlModelGraph | This class represents the complete UML Model in a graph-like data structure |
| CUPRLayoutModule | Interface of hierarchy layout algorithms |
| CUpSAT | |
| CUpwardEdgeInserterModule | |
| CUpwardPlanarity | Upward planarity testing and embedding |
| CUpwardPlanarityEmbeddedDigraph | |
| ►CUpwardPlanaritySingleSource | Performs upward planarity testing and embedding for single-source digraphs |
| CDegreeInfo | |
| CUpwardPlanarizationLayout | |
| CUpwardPlanarizerModule | Interface for upward planarization algorithms |
| CUpwardPlanarSubgraphModule | Interface for algorithms for computing an upward planar subgraph |
| CUpwardPlanarSubgraphSimple | A maximal planar subgraph algorithm using planarity testing |
| CUpwardPlanRep | Upward planarized representations (of a connected component) of a graph |
| CUsuallySmallMap | A wrapper around std::map that uses a constant-size array (or only a single value) plus linear search until the map grows too big |
| CVarEdgeInserterCore | |
| CVarEdgeInserterDynCore | |
| CVarEdgeInserterDynUMLCore | |
| CVarEdgeInserterUMLCore | |
| CVariableEmbeddingInserter | Optimal edge insertion module |
| CVariableEmbeddingInserterBase | Common parameter functionality for ogdf::VariableEmbeddingInserter and ogdf::VariableEmbeddingInserterDyn |
| CVariableEmbeddingInserterDyn | Optimal edge insertion module |
| CVariableEmbeddingInserterDynUML | Optimal edge insertion module |
| CVariableEmbeddingInserterUML | Optimal edge insertion module |
| CVComparer | Abstract base class for comparer classes |
| CVertexMovement | |
| CVertexPositionModule | Interface for computing a good / optimal vertex position |
| ►CVisibilityLayout | |
| CEdgeSegment | |
| CNodeSegment | |
| CVoronoi | Computes Voronoi regions in an edge-weighted graph |
| CWeightComparer | |
| CwhaInfo | |
| CWInfo | Saves information about a pertinent node w between two stopping vertices |
| CZeroPlacer | The zero placer for multilevel layout |
| CZipIterator | Simple before-C++20 version for std::ranges::zip_view |
| ►Npugi | |
| Cxml_attribute | |
| Cxml_attribute_iterator | |
| Cxml_document | |
| Cxml_named_node_iterator | |
| Cxml_node | |
| Cxml_node_iterator | |
| Cxml_object_range | |
| Cxml_parse_result | |
| Cxml_text | |
| Cxml_tree_walker | |
| Cxml_writer | |
| Cxml_writer_file | |
| Cxml_writer_stream | |
| Cxpath_node | |
| Cxpath_node_set | |
| Cxpath_parse_result | |
| Cxpath_query | |
| Cxpath_variable | |
| Cxpath_variable_set | |
| ►Nstd | |
| Chash< ogdf::gml::Key > | |
