►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 |
►NMath | |
►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_separator | |
►CSeparatorDualHelper | Helper class for SeparatorDual and SeparatorDualFC |
CCycleData | Auxiliary lightweight data structure to represent cycles |
►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 |
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 | |
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 | |
CPlanarizerMixedInsertion | |
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 |
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 | |
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 | |
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 > | |