All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages

Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

Aux | |

Checkers | This namespace provides some Types with a static member-function `void enforce(bool)` that may check wether the argument is true and create some kind of failure otherwise |

Asserter | Checks the bool via assert |

Enforcer | Checks to bool via enforce |

Terminator | Calls std::terminate if the bool is false |

Ignorer | Won't look at the bool (not even in debug-mode, which is how this differs from Asserter) |

Impl | |

PrintableCategoryTag | |

IsIteratableHelper | |

IsPairHelper | |

IsPairHelper< std::pair< T1, T2 > > | |

IsTupleHelper | |

IsTupleHelper< std::tuple< T...> > | |

IsStreamableHelper | |

printTupleHelper | |

printTupleHelper< Tuple, I, I > | |

Log | |

Impl | |

Settings | |

Location | |

MissingMath | Math functions not provided by the standard library |

NumericTools | Tools to deal with limited precision in numeric computations |

Parallel | |

Parsing | |

Impl | |

IntegerTag | |

RealTag | |

Random | Provides several functions for random-numbers |

SignalHandling | |

InterruptException | Special Exception to indicate, that a SIGINT has been received |

StringTools | Missing string functions |

BloomFilter | Bloom filter for fast set membership queries for type index with one-sided error (false positives) |

BucketPQ | Addressable priority queue for values in the range [0,n) and integer keys (= priorities) in the range [minPrio, maxPrio] |

FunctionTraits | |

arg | |

FunctionTraits< R(*)(Args...)> | |

FunctionTraits< R(Args...)> | |

arg | |

FunctionTraits< R(C::*)(Args...)> | |

FunctionTraits< R(C::*)(Args...) const > | |

FunctionTraits< R(C::*)> | |

FunctionTraits< F & > | |

FunctionTraits< F && > | |

PrioQueue | Priority queue with extract-min and decrease-key |

PrioQueueForInts | Addressable priority queue for elements in the range [0,n) and integer priorities in the range [0, maxPrio] |

SetIntersector | Provides set intersection for sets with entries from 0 to an upper bound (exclusive) |

SignalHandler | |

Timer | A timer for running time measurements |

GraphBLAS | Implements the GraphBLAS interface |

MatrixTools | |

NetworKit | |

GraphClusteringTools | |

GraphTools | |

LinkThresholder | Filters given predictions based on some criterion and returns a vector of node-pairs that fulfill the given criterion |

RandomLinkSampler | Provides methods to randomly sample a number of edges from a given graph |

Triplet | Represents a matrix entry s.t |

AlgebraicBellmanFord | Implementation of the Bellman-Ford algorithm using the GraphBLAS interface |

AlgebraicBFS | Implementation of Breadth-First-Search using the GraphBLAS interface |

AlgebraicMatchingCoarsening | Implements an algebraic version of the MatchingCoarsening algorithm by computing a projection matrix from fine to coarse |

AlgebraicPageRank | Implementation of PageRank using the GraphBLAS interface |

AlgebraicSpanningEdgeCentrality | Implementation of Spanning edge centrality with algebraic notation |

AlgebraicTriangleCounting | Implements a triangle counting algorithm for nodes based on algebraic methods |

CSRMatrix | Sparse matrix stored in CSR-Format (i.e |

DenseMatrix | Represents a dense matrix |

DynamicMatrix | Matrix that is optimized for sparse matrices and internally uses a graph data structure |

SparseAccumulator | Sparse accumulator datastructure as described in Kepner, Jeremy, and John Gilbert, eds |

Vector | Basic vector with double coefficients |

Algorithm | |

DynAlgorithm | |

ApproxBetweenness | Approximation of betweenness centrality according to algorithm described in Matteo Riondato and Evgenios M |

ListEntry_struct | |

ApproxCloseness | Approximation of closeness centrality according to algorithm described in Cohen et al., Computing Classic Closeness Centrality, at Scale |

Betweenness | |

Centrality | Abstract base class for centrality measures |

Closeness | |

CoreDecomposition | Computes k-core decomposition of a graph |

DegreeCentrality | Node centrality index which ranks nodes by their degree |

DynApproxBetweenness | Interface for dynamic approximated betweenness centrality algorithm |

CompareDist | |

DynBetweenness | Dynamic APSP |

DynBetweennessOneNode | Dynamic betweenness of a single node |

EigenvectorCentrality | Computes the leading eigenvector of the graph's adjacency matrix (normalized in 2-norm) |

EstimateBetweenness | Estimation of betweenness centrality according to algorithm described in Sanders, Geisberger, Schultes: Better Approximation of Betweenness Centrality |

GroupCloseness | |

KatzCentrality | Computes the Katz centrality of the graph |

KPathCentrality | |

LocalClusteringCoefficient | |

LocalPartitionCoverage | The local partition coverage is the amount of neighbors of a node u that are in the same partition as u |

PageRank | Compute PageRank as node centrality measure |

PermanenceCentrality | |

Sfigality | A |

SpanningEdgeCentrality | SpanningEdgeCentrality edge centrality |

TopCloseness | |

MaximalCliques | Algorithm for listing all maximal cliques |

ClusteringProjector | |

GraphCoarsening | Abstract base class for graph coarsening/contraction algorithms |

MatchingCoarsening | Coarsens graph according to a matching |

ParallelPartitionCoarsening | |

AdjustedRandMeasure | The adjusted rand dissimilarity measure as proposed by Huber and Arabie in "Comparing partitions" (http://link.springer.com/article/10.1007/BF01908075) |

ClusteringGenerator | Provides several methods for generating special clusterings |

CommunityDetectionAlgorithm | Abstract base class for community detection/graph clustering algorithms |

Conductance | Compute conductance of a 2-partition, i.e |

Coverage | Coverage is the fraction of intra-cluster edges |

CoverHubDominance | A quality measure that measures the dominance of hubs in clusters |

CutClustering | Cut clustering algorithm as defined in Flake, Gary William; Tarjan, Robert E |

DissimilarityMeasure | Base class for all clustering dissimilarity measures |

DynamicNMIDistance | |

EdgeCut | |

GraphStructuralRandMeasure | The graph-structural Rand measure assigns a similarity value in [0,1] to two partitions of a graph, by considering connected pairs of nodes |

HubDominance | A quality measure that measures the dominance of hubs in clusters |

IntrapartitionDensity | The intra-cluster density of a partition is defined as the number of existing edges divided by the number of possible edges |

IsolatedInterpartitionConductance | Isolated inter-partition conductance is a measure for how well a partition (communtiy/cluster) is separated from the rest of the graph |

IsolatedInterpartitionExpansion | Isolated inter-partition expansion is a measure for how well a partition (communtiy/cluster) is separated from the rest of the graph |

JaccardMeasure | |

LocalCommunityEvaluation | Virtual base class of all evaluation methods for a single clustering which is based on the evaluation of single clusters |

LocalCoverEvaluation | Virtual base class of all evaluation methods for a single Cover which is based on the evaluation of single clusters |

LocalPartitionEvaluation | Virtual base class of all evaluation methods for a single Partition which is based on the evaluation of single clusters |

LPDegreeOrdered | Label propagation-based community detection algorithm which processes nodes in increasing order of node degree |

Modularity | Modularity is a quality index for community detection |

NMIDistance | NMIDistance quantifies the dissimilarity between two clusterings using Normalized Mutual Information |

NodeStructuralRandMeasure | The node-structural Rand measure assigns a similarity value in [0,1] to two partitions of a graph, by considering all pairs of nodes |

ParallelAgglomerativeClusterer | A parallel agglomerative community detection algorithm, maximizing modularity |

PartitionFragmentation | This measure evaluates how fragmented a partition is |

PartitionHubDominance | A quality measure that measures the dominance of hubs in clusters |

PartitionIntersection | Class for calculating the intersection of two partitions, i.e |

PLM | Parallel Louvain Method - a multi-level modularity maximizer |

PLP | As described in Ovelgoenne et al: An Ensemble Learning Strategy for Graph Clustering Raghavan et al |

QualityMeasure | Abstract base class for all clustering quality measures |

SampledGraphStructuralRandMeasure | The graph-structural Rand measure assigns a similarity value in [0,1] to two partitions of a graph, by considering connected pairs of nodes |

SampledNodeStructuralRandMeasure | The node-structural Rand measure assigns a similarity value in [0,1] to two partitions of a graph, by considering pairs of nodes |

StablePartitionNodes | Evaluates how stable a given partition is |

ConnectedComponents | Determines the connected components of an undirected graph |

DynConnectedComponents | Determines and updates the connected components of an undirected graph |

DynWeaklyConnectedComponents | Determines and updates the weakly connected components of a directed graph |

ParallelConnectedComponents | Determines the connected components of an undirected graph |

StronglyConnectedComponents | Determines the strongly connected components of an directed graph |

WeaklyConnectedComponents | Determines the weakly connected components of a directed graph |

Assortativity | Assortativity computes a coefficient that expresses the correlation of a node attribute among connected pairs of nodes |

AdamicAdarDistance | An implementation of the Adamic Adar distance measure |

AlgebraicDistance | Algebraic distance assigns a distance value to pairs of nodes according to their structural closeness in the graph |

AllSimplePaths | Determines all the possible simple paths from a given source node to a target node of a directed unweighted graph |

APSP | Class for all-pair shortest path algorithm |

BFS | Used to do a breadth-first search on a Graph from a given source node |

CommuteTimeDistance | CommuteTimeDistance edge centrality |

Diameter | |

Dijkstra | Dijkstra's SSSP algorithm |

DynAPSP | Dynamic APSP |

DynBFS | Dynamic breadth-first search |

DynDijkstra | Dynamic Dijkstra |

DynSSSP | Interface for dynamic single-source shortest path algorithms |

Eccentricity | |

EffectiveDiameter | |

EffectiveDiameterApproximation | |

GraphDistance | |

HopPlotApproximation | |

IncompleteDijkstra | Implementation of IncompleteSSSP using a normal Dijkstra with binary heaps |

IncompleteSSSP | Abstract base class for single-source shortest path algorithms that return the nodes in order of increasing distance from the source and do not necessarily need to compute all distances |

JaccardDistance | Jaccard distance assigns a distance value to pairs of nodes according to the similarity of their neighborhoods |

NeighborhoodFunction | |

NeighborhoodFunctionApproximation | |

NeighborhoodFunctionHeuristic | |

NodeDistance | Abstract base class for node distance measures |

SSSP | Abstract base class for single-source shortest path algorithms |

DGSStreamParser | |

DGSWriter | |

GraphEvent | |

GraphEventHandler | |

GraphEventProxy | This class enables the observer pattern for dynamic graphs: It has the same modifiers as a Graph object |

GraphUpdater | |

ChibaNishizekiQuadrangleEdgeScore | |

ChibaNishizekiTriangleEdgeScore | An implementation of the triangle counting algorithm by Chiba/Nishizeki |

EdgeScore | Abstract base class for an edge score |

EdgeScoreAsWeight | |

EdgeScoreBlender | |

EdgeScoreLinearizer | |

EdgeScoreNormalizer | |

GeometricMeanScore | |

PrefixJaccardScore | |

TriangleEdgeScore | A parallel triangle counting implementation based on ideas in [0] |

EdmondsKarp | Implements the maximum flow algorithm by Edmonds and Karp |

BarabasiAlbertGenerator | Generates a scale-free graph using the Barabasi-Albert preferential attachment model |

ChungLuGenerator | Given an arbitrary degree sequence, the Chung-Lu generative model will produce a random graph with the same expected degree sequence |

ClusteredRandomGraphGenerator | Used to create a clustered random graph |

DorogovtsevMendesGenerator | |

DynamicBarabasiAlbertGenerator | |

DynamicDGSParser | |

DynamicDorogovtsevMendesGenerator | |

DynamicForestFireGenerator | The Forest Fire generative model produces dynamic graphs with the following properties: |

DynamicGraphGenerator | Abstract base class for a dynamic graph generator (in the new dynamic architecture) |

DynamicGraphSource | |

DynamicHyperbolicGenerator | |

DynamicPathGenerator | Example dynamic graph generator: Generates a dynamically growing path |

DynamicPubWebGenerator | |

EdgeSwitchingMarkovChainGenerator | Graph generator for generating a random simple graph with exactly the given degree sequence based on the Edge-Switching Markov-Chain method |

ErdosRenyiGenerator | Creates G(n, p) graphs |

HavelHakimiGenerator | Havel-Hakimi algorithm for generating a graph according to a given degree sequence |

HyperbolicGenerator | |

LFRGenerator | The LFR clustered graph generator as introduced by Andrea Lancichinetti, Santo Fortunato, and Filippo Radicchi |

PowerlawDegreeSequence | |

circle | |

PubWebGenerator | Generates a static graph that resembles an assumed geometric distribution of nodes in a P2P network |

QuadNode | |

QuadNodeCartesianEuclid | |

QuadNodePolarEuclid | |

Quadtree | |

QuadtreeCartesianEuclid | |

QuadtreePolarEuclid | |

RegularRingLatticeGenerator | |

RmatGenerator | Generates static R-MAT graphs |

StaticDegreeSequenceGenerator | |

StaticGraphGenerator | Abstract base class for static graph generators |

StochasticBlockmodel | |

WattsStrogatzGenerator | |

HyperbolicSpace | |

Point2D | Points in any dimension of templated type |

ClusteringCoefficient | |

GlobalClusteringCoefficient | |

Coordinates | DEPRECATED: A specialized container for node coordinates is no longer consistent with NetworKit's approach to node attributes |

WeightedEdge | A weighted edge used for the graph constructor with initializer list syntax |

Edge | |

Graph | A graph (with optional weights) and parallel iterator methods |

GraphBuilder | |

MyEdge | |

KruskalMSF | Creates a minimum spanning tree for each connected component |

RandomMaximumSpanningForest | Computes a random maximum-weight spanning forest using Kruskal's algorithm by randomizing the order of edges of the same weight |

RandomSpanningForest | Creates a random spanning tree for each connected component |

Sampling | |

SpanningForest | Base class for spanning forest/tree algorithms |

UnionMaximumSpanningForest | Union maximum-weight spanning forest algorithm, computes the union of all maximum-weight spanning forests using Kruskal's algorithm |

IndependentSetFinder | DEPRECATED: put into code archive, nobody seems to be using it Abstract base class for independent set algorithms |

Luby | DEPRECATED: put into code archive as nobody seems to be using it Luby's parallel independent set algorithm |

CoverReader | |

CoverWriter | Write a clustering to a file |

DGSReader | DGS is a file format allowing to store graphs and dynamic graphs in a textual human readable way, yet with a small size allowing to store large graphs |

DibapGraphReader | TODO: class documentation |

DotGraphWriter | This class turns a graph into a very basic GraphViz file as documented in the official manual [1] |

DotPartitionWriter | |

DynamicGraphReader | |

EdgeListCoverReader | |

EdgeListPartitionReader | |

EdgeListReader | A reader for various edge list formats, in which each line contains an edge as two node ids |

EdgeListWriter | A writer for the edge list format |

GMLGraphReader | Reader for the GML file format documented in [1] |

GMLGraphWriter | Writes a graph and its coordinates as a GML file |

GraphIO | |

GraphReader | Abstract base class for graph readers |

GraphToolBinaryReader | Reads graphs from files in the binary format defined by graph-tool[1] |

GraphToolBinaryWriter | Writes graphs to files in the binary format defined by graph-tool[1] |

GraphWriter | Abstract base class for graph writers |

KONECTGraphReader | |

LineFileReader | Reads a file and puts each line as a string into a vector |

MatrixMarketReader | Reader for the matrix market file format as described in http://math.nist.gov/MatrixMarket/reports/MMformat.ps |

MatrixReader | Abstract base class for matrix readers |

METISGraphReader | Reader for the METIS file format documented in [1] |

METISGraphWriter | |

METISParser | Parser for the METIS file format |

PartitionReader | |

PartitionWriter | Write a clustering to a file |

RasterReader | Reader for NASA raster data of population |

SNAPEdgeListPartitionReader | Reads the clustering files from the SNAP collection |

SNAPGraphReader | |

SNAPGraphWriter | Write graph in the Georgia Tech SNAP (Small-world Network Analysis and Partitioning) (http://snap-graph.sourceforge.net/) file format (do not confuse this with the Stanford Network Analysis Project.) From the SNAP user guide: |

LayoutAlgorithm | Base class for graph layout algorithms, i.e |

AdamicAdarIndex | Implementation of the Adamic/Adar Index |

AdjustedRandIndex | AdjustedRandIndex proposed by Hoffman et al |

AlgebraicDistanceIndex | Algebraic distance assigns a distance value to pairs of nodes according to their structural closeness in the graph |

CommonNeighborsIndex | The CommonNeighborsIndex calculates the number of common neighbors of a node-pair in a given graph |

EvaluationMetric | Abstract base class for evaluation curves |

JaccardIndex | Implementation of the Jaccard index which normalizes the Common Neighbors Index |

KatzIndex | Implementation of the Katz index |

LinkPredictor | Abstract base class for link predictors |

MissingLinksFinder | Allows the user to find missing links in the given graph |

NeighborhoodDistanceIndex | Assigns a distance value to pairs of nodes according to the overlap of their neighborhoods |

NeighborhoodUtility | Provides basic operations on neighborhoods in a given graph |

NeighborsMeasureIndex | Implementation of the Neighbors Measure Index |

PrecisionRecallMetric | Provides points that define the Precision-Recall curve for a given set of predictions |

PredictionsSorter | Allows the sorting of predictions by score or node-pair |

PreferentialAttachmentIndex | Implementation of the Preferential Attachment Index |

ResourceAllocationIndex | Implementation of the ResourceAllocationIndex |

ROCMetric | Provides points that define the Receiver Operating Characteristic curve for a given set of predictions |

SameCommunityIndex | Index to determine whether two nodes are in the same community |

TotalNeighborsIndex | Implementation of the Total Neighbors Index |

UDegreeIndex | Index that simply returns the degree of the first given node |

VDegreeIndex | Index that simply returns the degree of the second given node |

LocalMaxMatcher | LocalMax matching similar to the one described in the EuroPar13 paper by the Sanders group (Birn, Osipov, Sanders, Schulz, Sitchinava) |

Matcher | Abstract base class for matching algorithms |

Matching | |

PathGrowingMatcher | Path growing matching algorithm as described by Hougardy and Drake, http://dx.doi.org/10.1016/S0020-0190(02)00393-9 Computes an approximate maximum weight matching with guarantee 1/2 |

ConjugateGradient | Implementation of Conjugate Gradient |

GaussSeidelRelaxation | Implementation of the Gauss-Seidel smoother |

Lamg | Represents the interface to the Lean Algebraic Multigrid (LAMG) graph Laplacian linear solver by Oren E |

EliminationStage | |

Level | Abstract base class for an LAMG Level |

LevelAggregation | |

LevelElimination | |

LevelFinest | |

LevelHierarchy | |

MultiLevelSetup | Implements the setup phase of LAMG (Lean Algebraic Multigrid by Livne et al.) |

LAMGSolverStatus | Status parameters of the solver |

SolverLamg | Implements the solve phase of LAMG (Lean Algebraic Multigrid by Livne et al.) |

SolverStatus | Describes the status of a LinearSolver after the solver finished |

LinearSolver | Abstract base class for solvers that solve linear systems |

DiagonalPreconditioner | Simple preconditioner that approximates the matrix by a diagonal matrix |

IdentityPreconditioner | Simple preconditioner that returns the given vector unchanged |

Smoother | Abstract base class of a smoother |

HashingOverlapper | Determines the overlap of multiple partitions by hashing partition identifiers |

Overlapper | Abstract base class for algorithms which determine the overlap of multiple partitions |

ApproximatePageRank | Computes an approximate PageRank vector from a given seed |

GCE | The Greedy Community Expansion algorithm |

PageRankNibble | Variant of PageRank-Nibble algorithm due to Andersen, Chung and Lang |

SelectiveCommunityDetector | |

EdgeScoring | Abstract base class for algorithms associating a score with an edge |

ModularityScoring | |

EpidemicSimulationSEIR | Node centrality index which ranks nodes by their degree |

ChanceCorrectedTriangleScore | |

ForestFireScore | Based on the Forest Fire algorithm introduced by Leskovec et al |

GlobalThresholdFilter | Calculates a sparsified graph by applying a global threshold to an edge score |

AttributizedEdge | |

LocalDegreeScore | Local Degree sparsification method |

LocalFilterScore | Local filtering edge scoring |

greater | |

LocalSimilarityScore | Implementation of the Local Sparsification Algorithm by Sataluri et al |

MultiscaleScore | Calculates the multiscale edge score for a given graph |

RandomEdgeScore | Generates a random edge attribute |

RandomNodeEdgeScore | |

SCANStructuralSimilarityScore | |

SimmelianOverlapScore | Calculates the Simmelian backbone (paramaetric variant) for a given input graph |

RankedEdge | A directed edge with a simmelianness int value |

Redundancy | Represents the result of the comparison of two ranked neighborhood lists, namely the overlap of the top-k neighbors and the maximum jaccard index |

SimmelianScore | Abstract base class for the two variants of Simmelian backbones (OverlapFilter, JaccardFilter) |

Sparsifier | In this file, edge score calculators and edge score filters are combined into different sparsification algorithms |

SimmelianSparsifierNonParametric | Imlementation of the non-parametric variant of Simmelian Backbones, as introduced by Nick et al |

SimmelianSparsifierParametric | Imlementation of the parametric variant (Top-k neighborhood overlap) of Simmelian Backbones, as introduced by Nick et al |

MultiscaleSparsifier | Implementation of the Multiscale Backbone, as introduced by Serrano et al |

LocalSimilaritySparsifier | Local Similarity Sparsification as introduced by Satuluri et al |

SimmelianMultiscaleSparsifier | Multiscale backbone using simmelianness as input weight |

RandomSparsifier | Produces sparsified graphs that contain approximately a given percentage of edges of the original graph |

Cover | Implements a cover of a set, i.e |

Partition | Implements a partition of a set, i.e |

UnionFind | Implements the Union Find data structure to maintain disjoint sets efficiently |

FruchtermanReingold | DEPRECATED Fruchterman-Reingold graph drawing algorithm |

GraphLayoutAlgorithm | Abstract base class for algorithms that compute a layout of the Graph vertices in d-dimensional space |

ForwardEdge | |

MaxentStress | Implementation of MaxentStress by Ganser et al |

ResultStats | |

MultilevelLayouter | DEPRECATED |

BoundingBox | Bounding box used by the Octree class |

OctreeNode | Node in the octree data structure |

Octree | Implementation of a k-dimensional octree for the purpose of Barnes-Hut approximation |

PivotMDS | Implementation of PivotMDS proposed by Brandes and Pich |

Point | Formerly marked as deprecated: To take advantage of automatic mapping between C++ and Python data structures, use standard library containers (std::pair, std::tuple..) instead |

PostscriptWriter | EPS output of graphs with 2D coordinates |

OptionParser | The namespace of The Lean Mean C++ Option Parser |

Descriptor | Describes an option, its help text (usage) and how it should be parsed |

Option | A parsed option from the command line together with its argument if it has one |

Arg | Functions for checking the validity of option arguments |

Stats | Determines the minimum lengths of the buffer and options arrays used for Parser |

CountOptionsAction | |

Parser | Checks argument vectors for validity and parses them into data structures that are easier to work with |

Action | |

StoreOptionAction | |

PrintUsageImplementation | |

FunctionWriter | |

IStringWriter | |

LinePartIterator | |

LineWrapper | |

OStreamWriter | |

StreamWriter | |

SyscallWriter | |

TemporaryWriter | |

std | |

hash< NetworKit::Edge > | |

ttmath | Namespace for the TTMath library |

auxiliaryfunctions | |

Big | Big implements the floating point numbers |

Dec | |

Int | Int implements a big integer value with a sign |

Misc | |

Objects | |

Item | |

History | |

CGamma | |

Parser | Mathematical parser |

Item | |

ThreadLock | |

Conv | |

StopCalculating | |

ExceptionInfo | |

ReferenceError | |

RuntimeError | |

UInt | UInt implements a big integer value without a sign |

UInt< 0 > | |

Arg | |

ArithmeticSemiring | Add: arithmetic add mult: arithmetic multiplication zero: 0 one: 1 codomain = (-infty, +infty) |

GaloisFieldSemiring | Add: xor mult: bitwise and zero: 0 one: 1 codomain = [0, 1] |

IntLogicalSemiring | Add: logical or mult: logical and zero: 0 one: 1 codomain = [-infty, +infty] |

MaxMinSemiring | Add: max mult: min zero: -infty one: +infty codomain = [-infty, +infty] |

MaxPlusSemiring | Add: max mult: arithmetic add zero: -infty one: 0 codomain = [-infty, +infty) |

MinMaxSemiring | Add: min mult: max zero: +infty one: -infty codomain = [-infty, +infty] |

MinPlusSemiring | Add: min mult: arithmetic add zero: +infty one: 0 codomain = (-infty, +infty] |