MetabolicGraph

java.lang.Object
- org.jgrapht.graph.AbstractGraph<V,E>
- - org.jgrapht.graph.AbstractBaseGraph<V,E>
  - - org.jgrapht.graph.SimpleDirectedGraph<V,E>
    - - org.jgrapht.graph.SimpleDirectedWeightedGraph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>
      - massbalance.MetabolicGraph

All Implemented Interfaces:

Serializable, Cloneable, org.jgrapht.DirectedGraph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>, org.jgrapht.Graph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>, org.jgrapht.WeightedGraph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>
```
public class MetabolicGraph
extends org.jgrapht.graph.SimpleDirectedWeightedGraph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>
```
Objects of this class represent a metabolic network as a directed weighted bipartite graph. It includes methods for graph modification, randomization and calculation of graph properties.

Author:

Georg Basler

See Also:
Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

String version
- Fields inherited from interface org.jgrapht.WeightedGraph
  DEFAULT_EDGE_WEIGHT

Fields
Modifier and Type	Field and Description
`String`	`version`

Constructor Summary

Constructors
Constructor and Description
`MetabolicGraph(boolean reversible, boolean compartments)` Creates an empty MetabolicGraph, a SimpleDirectedWeightedGraph.
`MetabolicGraph(String version, int numberOfCompounds, boolean reversible, boolean compartments)` Creates a MetabolicGraph using numberOfCompounds as initial compounds hash capacity.

Method Summary

Methods
Modifier and Type	Method and Description
`org.jgrapht.graph.DefaultWeightedEdge`	`addEdge(Vertex source, Vertex target)` Adds an edge to connect source and target.
`boolean`	`addEdge(Vertex source, Vertex target, org.jgrapht.graph.DefaultWeightedEdge e)` Adds the edge to connect source and target.
`boolean`	`addVertex(Vertex vertex)` Adds the vertex to the graph and creates an entry in the compounds or reactions HashMap.
`void`	`adjacencyMatrix(String file)` Deprecated.
`double[]`	`assortativities_old()` Deprecated.
`double[]`	`assortativities()` Calculates two assortativity coefficients on the directed MM-network: the pearson correlation coefficient of (1) the compound in-degrees and the average in-degrees of predecessors, (2) the compound out-degrees and the average out-degrees of successors.
`BigDecimal`	`averageReactionDegree()` Determines the average reaction degree, i.e., the average of the in-degrees plus the out-degrees.
`int[]`	`balance(Vertex reaction)` Determines the mass balance of a reaction by summing over the substrate and product masses, multiplied by the corresponding stoichiometric coefficients.
`float`	`characteristicPathLength()` Implementation of Floyd-Warshall's algorithm for computing all shortest paths in a directed graph.
`MetabolicGraph`	`clone()` Creates an identical copy of the graph: reversibility is copied, vertices are copied with names, mass and reversible reactions, edges are copied with weights.
`double`	`clusteringCoefficientUndirected()` Determines the undirected clustering coefficient in the corresponding metabolite-metabolite network, i.e., the clustering coefficient in the mm-network, where all edges are considered undirected.
`boolean`	`compare(MetabolicGraph graph)` Compares this MetabolicGraph to the given MetabolicGraph.
`boolean`	`compareEdges(MetabolicGraph graph)` Compares the edges of this MetabolicGraph to the edges of the given MetabolicGraph.
`int`	`compoundDeadEnds(String outputFile)` Prints the dead-end compounds to a file.
`void`	`compoundDegrees(String file, boolean append)` Prints a tab-separated list of compound degrees.
`void`	`compoundInOutDegrees(String file, boolean in, boolean append)` Prints a tab-separated list of compound in- or out-degrees.
`ArrayList<Integer>`	`connectedComponents(boolean print)` Determines the sizes of all connected components in the graph by expanding the transitive closure until every compound was visited.
`double`	`correlation(int[] x, float meanX, float[] y, float meanY)` Calculates the empirical pearson correlation of x and y with given means meanX and meanY.
`int`	`cycleCount(List<Set<Vertex>> components, int n, boolean printCycles, boolean printComponents)` Given a set of strongly connected components, returns the number of n-cycles.
`int`	`distanceTo(MetabolicGraph graph)` Counts the differences in substrates and products between this graph and the given graph.
`double[]`	`eigenvalueDecomposition(double[] matrix, int m)` Calculates the full eigenvalue spectrum with double precision using the Fortran method dgeev.
`float[]`	`eigenvalueDecomposition(float[] matrix, int m)` Calculates the full eigenvalue spectrum with float precision using the Fortran method sgeev.
`double[]`	`eigenvectorDouble(double[] A, int m, double d, boolean forceDecomposition)` Calculates the eigenvector corresponding to the largest eigenvalue of A using the Fortran routines dnaupd and dgemv.
`float[]`	`eigenvectorFloat(float[] A, int m, double d, boolean forceDecomposition)` Calculates the eigenvector corresponding to the largest eigenvalue of A using the Fortran routines snaupd and sgemv.
`void`	`equationSubstitutions(MetabolicGraph originalGraph, HashMap<ArrayList<Integer>,EquivalenceClass> classes, HashSet<Vertex> preserved, String outputFile, boolean doubles)` Writes each possible single and pair substitution of the reaction equations of the original network to tab-separated files.
`BigDecimal`	`fixStoichiometry(Vertex reaction)` Fixes the stoichiometry of the reaction by finding the smallest factor such that for all compounds i: factor*weight[i] is an integer.
`HashMap<String,HashSet<Vertex>>`	`getCompartments()` Returns a map of compartment strings and vertex sets.
`HashMap<String,HashSet<Vertex>>`	`getCompartments(Vertex reaction)` Returns the map of compartment strings and the substrates/products of the reaction which belong to the compartment.
`Vertex`	`getCompound(String name, String compartment)` Returns the compound vertex with the specified name and compartment.
`Collection<Vertex>`	`getCompounds()` Returns an immutable collection of the compound vertices.
`Double`	`getDeltaGDifference(Vertex reaction, int side, Vertex compound, Vertex substitute, int[] solve)` Calculates the difference in deltaG of the reaction after substituting compound by substitute on the given side, without modifying the network.
`Double`	`getDeltaGDifference(Vertex reaction, int side, Vertex compound1, Vertex compound2, Vertex substitute1, Vertex substitute2, int[] solve)` Calculates the difference in deltaG of the reaction after substituting compound1 and compound1 by substitute1 and substitute2 on the given side.
`Double`	`getDeltaGn()` Calculates the sum of deltaGr over all reactions.
`Double`	`getDeltaGr(Vertex reaction, boolean reversible)` Calculates the deltaGr of a reaction by summing over the negative deltaGf of substrates and the positive deltaGf of products, multiplied by the stoichiometric coefficients.
`Vertex`	`getReaction(String name)` Returns the reaction vertex with the specified name.
`String`	`getReactionEquation(MetabolicGraph graph, Vertex reaction)` Returns the equation of the given reaction in the given graph as String.
`Set<String>`	`getReactionNames()` Returns the set of reactions names in the graph.
`Collection<Vertex>`	`getReactions()` Returns an immutable collection of the reaction vertices.
`int`	`getTransitionDegree(HashMap<ArrayList<Integer>,EquivalenceClass> classes, HashSet<Vertex> preserved)` Calculates the number of possible substitutions for all reactions, i.e., the degree of the node representing this graph in the transition graph Sigma_G.
`boolean`	`hasCompartments()` Indicates whether the graph has compartments, i.e., each compound vertex is specified by a unique pair of a name and compartment.
`boolean`	`hasCycle(Vertex reaction)` Determines whether the given reaction has a cycle, i.e., there is a substrates which is also a product.
`boolean`	`hasEdge(Vertex vertex1, Vertex vertex2)` Tests whether the graph has an edge connecting vertex1 and vertex2 in either direction.
`boolean`	`isAdjacent(Vertex c1, Vertex c2)` Tests if compound c1 is adjacent to compound c2, i.e., if there is a reaction which has c1 as a substrate and c2 as a product.
`boolean[]`	`isConnected(ArrayList<String> compounds, ArrayList<String> compartments, ArrayList<Boolean> reversible)` Tests whether the given compounds are connected via paths with the given reversibilities.
`boolean`	`isCyclic(Vertex reaction, boolean print)` Determines whether the given reaction is a cyclic reaction, i.e., the substrates and products are identical and have equal weights.
`Vertex`	`isDuplicate(Vertex reaction)` Returns the first found duplicate reaction.
`boolean`	`isNeighbour(Vertex v1, Vertex v2)` Tests if the two compounds are neighbours, i.e., if they are connected by a substrate-product or product-substrate relationship.
`boolean`	`isPath(ArrayList<String> compounds, boolean bothDirections)` Checks if the given intermediary compounds are adjacent in any compartment.
`boolean`	`isReachable(Vertex c1, Vertex c2, HashSet<Vertex> visited)` Test if compound c2 is reachable from compound c1, i.e., if there exists a directed path from c1 to c2.
`boolean`	`isReversible()` Indicates whether the graph is reversible, i.e., for each reaction a reversed reaction is added implicitly, which converts the products into the substrates.
`HashMap<Vertex,Double[]>`	`knockoutSet(Vertex knockout, double threshold)` From a given knockout reaction, returns the set of reactions that are affected by the knockout, and their knockout strength, up to the given threshold.
`void`	`leastIntegerMultiple(BigDecimal x)` Deprecated.
`void`	`leastIntegerMultiple(BigDecimal x, BigDecimal y)` Deprecated.
`double`	`localCentrality(HashSet<Vertex> products, HashSet<Vertex> substrates)`
`double`	`localCentrality(Vertex reaction1, Vertex reaction2, boolean reversible)` Calculates the local essentiality of reaction1 for reaction2, i.e., the reciprocal of the smallest in-degree of a product of reaction1 which is substrate of reaction2, or 0, if no such compound exists.
`double`	`localEssentiality(Vertex reaction, boolean reversible)` Calculates the local reaction essentiality, i.e., the sum of essentialities of the reaction for all its successor reactions.
`void`	`massMatrix(String outputFile, boolean labelled)` Prints a m x n matrix containing the mass vectors of the compounds in the network, where m is the number of compounds, and n the number of considered atomic elements (specified as ELEMENTS in the configuration file).
`void`	`matrixSubstitutions(HashMap<ArrayList<Integer>,EquivalenceClass> classes, HashSet<Vertex> preserved, String outputFile, boolean doubles, boolean reversible)` Writes each possible single and pair substitution of the stoichiometric matrix of the original network to tab-separated files.
`int`	`maxReactionDegree()` Returns the maximum undirected degree of a reaction in the network.
`int`	`maxReactionInDegree()` Returns the maximum in-degree of a reaction in the network.
`int`	`maxReactionOutDegree()` Returns the maximum out-degree of a reaction in the network.
`HashSet<Vertex>`	`neighborsOf(Vertex v)` Returns the set containing all second neighboring vertices.
`HashSet<Vertex>`	`predecessorsOf(Vertex v)` Returns the set containing all second predecessor vertices.
`BigDecimal`	`randomize(MetabolicGraph originalGraph, HashMap<ArrayList<Integer>,EquivalenceClass> classes, HashSet<Vertex> preserved, float p, boolean iterative, float depth, String deltaGFile, String substitutabilityFile, boolean append, String logFile)` Performs mass balanced randomization on the graph by perturbing single compounds and pairs.
`void`	`randomScopeSizes(int[] seedSizes, String scopeFile, String scopeFile2, boolean append)` Calculates random scopes for the given seed sizes and writes the scope sizes of each seed size to a separate file.
`TreeMap<Vertex,Number>`	`reactionCentralities(MetabolicGraph originalGraph, double d, boolean doublePrecision, boolean reversible)` Calculates the global propagation of the local reaction centralities.
`void`	`reactionDegrees(String file, boolean append)` Prints a tab-separated list of reaction in-degrees and reaction out-degrees.
`void`	`readDeltaG(String file, String logFile)` Reads the deltaGf of compounds from a tab-separated file and stores the values with the compound vertices.
`boolean`	`removeEdge(org.jgrapht.graph.DefaultWeightedEdge e)` Removes the edge.
`org.jgrapht.graph.DefaultWeightedEdge`	`removeEdge(Vertex source, Vertex target)` Removes the edge connecting source and target.
`boolean`	`removeVertex(Vertex vertex)` Removes the vertex from the graph and removes the entry from the compounds or reactions HashMap.
`HashSet<Vertex>`	`scope_old(HashSet<Vertex> seed)` Deprecated.
`Set<Vertex>`	`scope(Set<Vertex> seed)` Returns the scope for the given set of seed compounds.
`void`	`setEdgeWeight(org.jgrapht.graph.DefaultWeightedEdge e, double weight)` Sets the weight for the edge.
`void`	`stoichiometricMatrix(String file, boolean reversible, boolean labelled, boolean sorted, boolean log)` Exports the sparse stoichiometric matrix of the graph into a tab-separated file.
`void`	`substitutability(HashMap<ArrayList<Integer>,EquivalenceClass> classes, String substitutabilityFile)` Calculate the sample space and substitutability class sizes for individual and pair substitutions.
`HashSet<Vertex>`	`successorsOf(Vertex v)` Returns the set containing all second successor vertices.
`void`	`switchRandomize(boolean strict)` Performs switch-randomization on the graph.
`int`	`validDeltaGr()` Counts the number of reactions containing only compounds with a known deltaGf.
`void`	`weights(String file, boolean append)` Prints the edge weights of the graph into a tab-separated file.
`void`	`write(String outputFile, boolean printAllCoefficients)` Writes the graph to a tab- and delimiter-separated file readable by createGraph.
`void`	`write2(String outputFile, boolean printAllCoefficients)` Writes the graph to an alternative tab- and delimiter-separated file format.
`void`	`writeBalance(String outputFile, boolean append)` Writes the number of balanced reactions and the number of reactions which are fully annotated, i.e., of which all substrates and products have an annotated mass.

Methods inherited from class org.jgrapht.graph.AbstractBaseGraph
containsEdge, containsVertex, degreeOf, edgeSet, edgesOf, getAllEdges, getEdge, getEdgeFactory, getEdgeSource, getEdgeTarget, getEdgeWeight, incomingEdgesOf, inDegreeOf, isAllowingLoops, isAllowingMultipleEdges, outDegreeOf, outgoingEdgesOf, setEdgeSetFactory, vertexSet

Methods inherited from class org.jgrapht.graph.AbstractGraph
containsEdge, removeAllEdges, removeAllEdges, removeAllVertices, toString

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.jgrapht.Graph
containsEdge, containsEdge, containsVertex, edgeSet, edgesOf, getAllEdges, getEdge, getEdgeFactory, getEdgeSource, getEdgeTarget, getEdgeWeight, removeAllEdges, removeAllEdges, removeAllVertices, vertexSet

Methods inherited from interface org.jgrapht.DirectedGraph
incomingEdgesOf, inDegreeOf, outDegreeOf, outgoingEdgesOf

- Field Detail
  - version
```
public String version
```
- Constructor Detail
  - MetabolicGraph
```
public MetabolicGraph(boolean reversible,
              boolean compartments)
```
    Creates an empty MetabolicGraph, a SimpleDirectedWeightedGraph.
  - MetabolicGraph
```
public MetabolicGraph(String version,
              int numberOfCompounds,
              boolean reversible,
              boolean compartments)
```
    Creates a MetabolicGraph using numberOfCompounds as initial compounds hash capacity.
    
    Parameters:
    numberOfCompounds -
    reversible -
- Method Detail
  - isReversible
```
public boolean isReversible()
```
    Indicates whether the graph is reversible, i.e., for each reaction a reversed reaction is added implicitly, which converts the products into the substrates.
    
    Returns:
    true, if the graph is reversible, false otherwise.
  - hasCompartments
```
public boolean hasCompartments()
```
    Indicates whether the graph has compartments, i.e., each compound vertex is specified by a unique pair of a name and compartment.
    
    Returns:
    true, if the graph supports compartments, false otherwise.
  - getCompound
```
public Vertex getCompound(String name,
                 String compartment)
```
    Returns the compound vertex with the specified name and compartment. Compartment may be null only if the graph does not support compartments.
    
    Parameters:
    name -
    compartment -
    
    Returns:
    Compound vertex.
  - getCompounds
```
public Collection<Vertex> getCompounds()
```
    Returns an immutable collection of the compound vertices.
    
    Returns:
    Collection of compound vertices.
  - getReaction
```
public Vertex getReaction(String name)
```
    Returns the reaction vertex with the specified name.
    
    Parameters:
    name -
    
    Returns:
    Reaction vertex.
  - getReactions
```
public Collection<Vertex> getReactions()
```
    Returns an immutable collection of the reaction vertices. Only the vertices representing the forward direction of reversible reactions are included.
    
    Returns:
    Collection of the reaction vertices.
  - getReactionNames
```
public Set<String> getReactionNames()
```
    Returns the set of reactions names in the graph. Only the names representing the forward direction of reversible reactions are included.
    
    Returns:
    Set of reaction names.
  - getReactionEquation
```
public String getReactionEquation(MetabolicGraph graph,
                         Vertex reaction)
```
    Returns the equation of the given reaction in the given graph as String.
    
    Parameters:
    reaction -
    
    Returns:
    The reaction equation as String.
  - fixStoichiometry
```
public BigDecimal fixStoichiometry(Vertex reaction)
```
    Fixes the stoichiometry of the reaction by finding the smallest factor such that for all compounds i: factor*weight[i] is an integer. Returns the factor by which the weights were multiplied.
    
    Parameters:
    reaction -
    
    Returns:
    The factor by which the stoichiometry was multiplied.
  - leastIntegerMultiple
```
public void leastIntegerMultiple(BigDecimal x)
```
    Deprecated.
    
    Parameters:
    x -
  - leastIntegerMultiple
```
public void leastIntegerMultiple(BigDecimal x,
                        BigDecimal y)
```
    Deprecated.
    
    Parameters:
    x -
    y -
  - balance
```
public int[] balance(Vertex reaction)
```
    Determines the mass balance of a reaction by summing over the substrate and product masses, multiplied by the corresponding stoichiometric coefficients. Returns a vector of atom imbalances with values <0 indicating atoms missing on the left side, values >0 indicating atoms in excess on the left side, and values == 0 indicating atom balance. Returns null if the reaction contains an unannotated compound.
    
    Parameters:
    reaction -
    
    Returns:
    A vector of imbalances or null, if the reaction contains an unannotated compound.
  - adjacencyMatrix
```
@Deprecated
public void adjacencyMatrix(String file)
                     throws IOException
```
    Deprecated.
    
    Exports the sparse adjacency matrix of the graph into a tab-separated file. Upper-left and lower-right sub-matrices contain only zeroes because the graph is bipartite. Time: O(m*n). TODO validate before using this method TODO reversed reactions are not considered
    
    Parameters:
    file -
    
    Throws:
    
    IOException
  - stoichiometricMatrix
```
public void stoichiometricMatrix(String file,
                        boolean reversible,
                        boolean labelled,
                        boolean sorted,
                        boolean log)
                          throws IOException
```
    Exports the sparse stoichiometric matrix of the graph into a tab-separated file. Note that coefficients are summed if a substrate is as well a product of a reaction. If reversible==true, then reversible reactions are represented by two columns, one for each direction of the reaction. Otherwise, only the 'forward' direction is represented as a column, and the reversible reaction names and indices are printed to the log-file. If labelled==true initial column and row labels containing the reaction and compound names are printed, otherwise the reactions and compounds are ordered lexicographically. Time: O(m*n).
    
    Parameters:
    file -
    reversible -
    labelled -
    sorted -
    log -
    
    Throws:
    
    IOException
  - massMatrix
```
public void massMatrix(String outputFile,
              boolean labelled)
                throws IOException
```
    Prints a m x n matrix containing the mass vectors of the compounds in the network, where m is the number of compounds, and n the number of considered atomic elements (specified as ELEMENTS in the configuration file).
    
    Parameters:
    outputFile - The output file to write to.
    labelled - If labelled==true, an additional header row and column are printed containing the names of atomic elements, respectively compound names.
    
    Throws:
    
    IOException
  - averageReactionDegree
```
public BigDecimal averageReactionDegree()
```
    Determines the average reaction degree, i.e., the average of the in-degrees plus the out-degrees.
    
    Returns:
    Average reaction degree.
  - maxReactionInDegree
```
public int maxReactionInDegree()
```
    Returns the maximum in-degree of a reaction in the network.
    
    Returns:
    Maximum in-degree.
  - maxReactionOutDegree
```
public int maxReactionOutDegree()
```
    Returns the maximum out-degree of a reaction in the network.
    
    Returns:
    Maximum out-degree.
  - maxReactionDegree
```
public int maxReactionDegree()
```
    Returns the maximum undirected degree of a reaction in the network.
    
    Returns:
    Maximum in-degree.
  - compoundDegrees
```
public void compoundDegrees(String file,
                   boolean append)
                     throws IOException
```
    Prints a tab-separated list of compound degrees. The degree of a compound is the number of reactions it takes part in, not including reversed reactions. NOTE: do not run this method from parallel processes writing to the same output file, as the files remain open during method execution.
    
    Parameters:
    file -
    append -
    
    Throws:
    
    IOException
  - compoundDeadEnds
```
public int compoundDeadEnds(String outputFile)
                     throws IOException
```
    Prints the dead-end compounds to a file. Dead-ends are compounds which have either an in-degree or out-degree of 0.
    
    Parameters:
    outputFile -
    
    Returns:
    Number of dead-end compounds.
    
    Throws:
    
    IOException
  - reactionDegrees
```
public void reactionDegrees(String file,
                   boolean append)
                     throws IOException
```
    Prints a tab-separated list of reaction in-degrees and reaction out-degrees. NOTE: do not run this method from parallel processes writing to the same output file, as the files remain open during method execution.
    
    Parameters:
    file -
    append -
    
    Throws:
    
    IOException
  - compoundInOutDegrees
```
public void compoundInOutDegrees(String file,
                        boolean in,
                        boolean append)
                          throws IOException
```
    Prints a tab-separated list of compound in- or out-degrees. The in-/out-degree of a compound is the number of reactions it takes part in as a product/substrate, including reversed reactions. NOTE: do not run this method from parallel processes writing to the same output file, as the files remain open during method execution.
    
    Parameters:
    file -
    append -
    
    Throws:
    
    IOException
  - weights
```
public void weights(String file,
           boolean append)
             throws IOException
```
    Prints the edge weights of the graph into a tab-separated file. Reversed reactions are omitted (they have the same weights as the corresponding forward reaction). NOTE: do not run this method from parallel processes writing to the same output file, as the files remain open during method execution.
    
    Parameters:
    file -
    
    Throws:
    
    IOException
  - clusteringCoefficientUndirected
```
public double clusteringCoefficientUndirected()
```
    Determines the undirected clustering coefficient in the corresponding metabolite-metabolite network, i.e., the clustering coefficient in the mm-network, where all edges are considered undirected. Note that edge directions are considered in the metabolite-reaction network, such that the neighbours of a compound are all compounds occurring on the opposite side of a reaction. The local clustering coefficient of compounds with less than two neighbours is 0. NOTE: the result is (slightly) imprecise due to floating point representations.
    
    Returns:
    Clustering coefficient.
  - isNeighbour
```
public boolean isNeighbour(Vertex v1,
                  Vertex v2)
```
    Tests if the two compounds are neighbours, i.e., if they are connected by a substrate-product or product-substrate relationship.
    
    Parameters:
    v1 -
    v2 -
    
    Returns:
    true, if v1 and v2 are neighbours.
  - isAdjacent
```
public boolean isAdjacent(Vertex c1,
                 Vertex c2)
```
    Tests if compound c1 is adjacent to compound c2, i.e., if there is a reaction which has c1 as a substrate and c2 as a product.
    
    Parameters:
    c1 -
    c2 -
    
    Returns:
    true, if c1 and c2 are adjacent, false otherwise.
  - isReachable
```
public boolean isReachable(Vertex c1,
                  Vertex c2,
                  HashSet<Vertex> visited)
```
    Test if compound c2 is reachable from compound c1, i.e., if there exists a directed path from c1 to c2. First call should pass an empty HashSet of visited compounds.
    
    Parameters:
    c1 -
    c2 -
    visited -
    
    Returns:
    true, if c2 is reachable from c1, false otherwise.
  - isConnected
```
public boolean[] isConnected(ArrayList<String> compounds,
                    ArrayList<String> compartments,
                    ArrayList<Boolean> reversible)
```
    Tests whether the given compounds are connected via paths with the given reversibilities. If reversible is true at index i, then the compounds i and i+1 must be connected via directed paths in both directions.
    
    Parameters:
    compounds -
    compartments -
    reversible -
    
    Returns:
    boolean[] of length compounds.length-1, true at index i, if a path exists between compound i and compound i+1, false otherwise.
  - isPath
```
public boolean isPath(ArrayList<String> compounds,
             boolean bothDirections)
```
    Checks if the given intermediary compounds are adjacent in any compartment. If bothDirections==true, then the compounds must be adjacent in both directions.
    
    Parameters:
    compounds - Intermediary compounds to check for connections.
    
    Returns:
    true, if the path exists, false otherwise.
  - isCyclic
```
public boolean isCyclic(Vertex reaction,
               boolean print)
```
    Determines whether the given reaction is a cyclic reaction, i.e., the substrates and products are identical and have equal weights.
    
    Parameters:
    reaction -
    print -
    
    Returns:
    true, if the reaction is cyclic, false otherwise.
  - hasCycle
```
public boolean hasCycle(Vertex reaction)
```
    Determines whether the given reaction has a cycle, i.e., there is a substrates which is also a product.
    
    Parameters:
    reaction -
    
    Returns:
    true, if the reaction has a cycle, false otherwise.
  - getCompartments
```
public HashMap<String,HashSet<Vertex>> getCompartments(Vertex reaction)
```
    Returns the map of compartment strings and the substrates/products of the reaction which belong to the compartment. If the size of the key set is greater than 1, than the reaction is involved in a compartment transport.
    
    Parameters:
    reaction -
    
    Returns:
    HashMap of compartment strings and their substrates/products.
  - cycleCount
```
public int cycleCount(List<Set<Vertex>> components,
             int n,
             boolean printCycles,
             boolean printComponents)
```
    Given a set of strongly connected components, returns the number of n-cycles. Algorithm by Liu, Wang (2006). Note that this implementation includes reversible reactions, e.g. as 2-cycles.
    
    Parameters:
    components -
    n -
    printCycles -
    printComponents -
    
    Returns:
    Number of n-cycles.
  - randomScopeSizes
```
public void randomScopeSizes(int[] seedSizes,
                    String scopeFile,
                    String scopeFile2,
                    boolean append)
                      throws IOException
```
    Calculates random scopes for the given seed sizes and writes the scope sizes of each seed size to a separate file. The output file names are created by appending the seed size to the given file name. NOTE: do not run this method from parallel processes writing to the same output file, as the files remain open during method execution.
    
    Parameters:
    seedSizes -
    scopeFile -
    scopeFile2 -
    append -
    
    Throws:
    
    IOException
  - scope
```
public Set<Vertex> scope(Set<Vertex> seed)
```
    Returns the scope for the given set of seed compounds.
  - scope_old
```
public HashSet<Vertex> scope_old(HashSet<Vertex> seed)
```
    Deprecated.
    
    Parameters:
    seed -
    
    Returns:
    The scope for the given set of seed compounds.
  - connectedComponents
```
public ArrayList<Integer> connectedComponents(boolean print)
```
    Determines the sizes of all connected components in the graph by expanding the transitive closure until every compound was visited.
    
    Returns:
    A sorted list containing the size of each connected component.
  - characteristicPathLength
```
public float characteristicPathLength()
```
    Implementation of Floyd-Warshall's algorithm for computing all shortest paths in a directed graph. Adapted to calculate the average shortest path length. For reversible graphs the calculation could be faster by skipping the reverse path, but this implementation is already apx. 86 times faster than the naive algorithm. See http://algowiki.net/wiki/index.php/Floyd-Warshall%27s_algorithm..
    NOTE: the result is (slightly) imprecise due to floating point representations.
    
    Returns:
    Characteristic path length.
  - assortativities
```
public double[] assortativities()
```
    Calculates two assortativity coefficients on the directed MM-network: the pearson correlation coefficient of (1) the compound in-degrees and the average in-degrees of predecessors, (2) the compound out-degrees and the average out-degrees of successors. Note that, in contrast to Newman (Phys. Rev. E 67, 026126 (2003)) we use the actual degree instead of the excess degree (degree-1).
    
    Returns:
    double[] of size 2 containing the in-degree/in-degree correlation coefficient at index 0, and the out-degree/out-degree correlation coefficient at index 1.
  - assortativities_old
```
public double[] assortativities_old()
```
    Deprecated.
    
    Returns:
    double[] of size 2 containing the in-degree/in-degree correlation coefficient at index 0, and the out-degree/out-degree correlation coefficient at index 1.
  - correlation
```
public double correlation(int[] x,
                 float meanX,
                 float[] y,
                 float meanY)
```
    Calculates the empirical pearson correlation of x and y with given means meanX and meanY. Zeros in x are skipped.
    
    Parameters:
    x -
    meanX -
    y -
    meanY -
    
    Returns:
    Correlation coefficient.
  - localCentrality
```
public double localCentrality(Vertex reaction1,
                     Vertex reaction2,
                     boolean reversible)
```
    Calculates the local essentiality of reaction1 for reaction2, i.e., the reciprocal of the smallest in-degree of a product of reaction1 which is substrate of reaction2, or 0, if no such compound exists. If reversible==false, both directions of reversible reactions are considered independently, otherwise the essentiality of reaction1 is measured by considering both its substrates and products. For reaction2 only substrates are considered in any case. Note: imprecision possible due to numerical errors.
    
    Parameters:
    reaction1 -
    reaction2 -
    reversible -
    
    Returns:
    local centrality between reaction1 and reaction2.
  - localCentrality
```
public double localCentrality(HashSet<Vertex> products,
                     HashSet<Vertex> substrates)
```
  - localEssentiality
```
public double localEssentiality(Vertex reaction,
                       boolean reversible)
```
    Calculates the local reaction essentiality, i.e., the sum of essentialities of the reaction for all its successor reactions. If reversible==false, only the given direction of the reaction is considered, otherwise both directions of a reversible reaction are considered together.
    
    Parameters:
    reaction -
    
    Returns:
    local essentiality of the reaction.
  - knockoutSet
```
public HashMap<Vertex,Double[]> knockoutSet(Vertex knockout,
                                   double threshold)
```
    From a given knockout reaction, returns the set of reactions that are affected by the knockout, and their knockout strength, up to the given threshold. The knockout strength is determined by the maximum product of the local essentialities along any path from the knockout to the affected reaction. If the initial knockout reaction is reversible, both directions are considered to be knocked out. For the propagation, only the affected reaction directions are considered.
    
    Parameters:
    knockout -
    threshold -
    
    Returns:
    HashMap of vertices and their knockout path up to the specified threshold.
    See Also:
    MetabolicGraph.localEssentiality(Vertex,boolean)
  - reactionCentralities
```
public TreeMap<Vertex,Number> reactionCentralities(MetabolicGraph originalGraph,
                                          double d,
                                          boolean doublePrecision,
                                          boolean reversible)
```
    Calculates the global propagation of the local reaction centralities. These are given by the eigenvector corresponding to the largest eigenvalue of the reaction incidence matrix, normalized by the page rank transformation with damping factor d. The reaction incidence matrix is an m x m matrix containing the local essentiality scores between pairs of reactions.
    If originalGraph==null, then the reaction centralities are calculated from this graph. Otherwise, the centralities are calculated repeatedly by preserving every reaction, one at a time. This allows calculating the centrality of a reaction randomized network while preserving the reaction itself, without additional randomization runs. originalGraph must be the original graph from which this network was randomized.
    If reversible==true, then the local dependence between a source reaction and a target reaction is the same for both directions of a reversible source reaction (the knockout of the source affects both its directions equally). Otherwise, the local dependence considers both directions of a reversible source reaction independently. Note that both directions of a reversible target reaction are always affected independently (a knockout affects both directions independently).
    
    Parameters:
    originalGraph - The originalGraph (not randomized) required for preserving each reaction one at a time.
    d - Damping factor for the PageRank transformation.
    doublePrecision - If true, calculates the eigenvector in double precision, otherwise float precision.
    reversible - If true, both directions of a reversible source reaction are considered as one, otherwise both directions are considered independently.
    
    Returns:
    TreeMap containing the reaction vertices as key and their centrality score as Number.
    See Also:
    localCentrality(Vertex,Vertex,boolean), localCentrality(HashSet,HashSet), eigenvectorFloat(float[],int,double,boolean), eigenvectorDouble(double[],int,double,boolean)
  - eigenvectorFloat
```
public float[] eigenvectorFloat(float[] A,
                       int m,
                       double d,
                       boolean forceDecomposition)
```
    Calculates the eigenvector corresponding to the largest eigenvalue of A using the Fortran routines snaupd and sgemv. If the fast calculation using the Arnoldi method fails, then the eigenvector corresponding to the largest eigenvalue is determined from the full eigenvalue spectrum using the LAPACK routine sgeev (eigenvalueDecomposition(float[],int).
    Before eigenvalue calculation, the matrix A is normalized according to page rank with damping factor d:
    A_i,j = e(r_i,r_j)*(A_i,j/colsum_j)*d+(1-d)/m)
    where e(r_i,r_j) = max(1/inDegreeOf(c)) is the local essentiality for all c which are a product of r_i and a substrate of r_j, or 0, if no such c exists;
    colsum_j is the sum of all entries of column j;
    m is the number of columns/rows.
    The netlib-java Fortran interfaces to ARPACK were used for eigenvalue calculation, as they clearly outperformed five other java based libraries: Shared, JAMA, Colt, JBLAS, MTJ, as well as Fortran routines for calculating all eigenvalues, JLAPACK.
    However, the ARPACK routines for directly calculating the largest eigenvalue are unstable for some parameters. If an error occurs, the eigenvector corresponding to the largest eigenvalue is determined from the full eigenvalue spectrum using the LAPACK routines sgeev or dgeev (eigenvalueDecomposition(float[],int) or eigenvalueDecomposition(float[],int)).
    Most critical parameters for the ARPACK routines are INFO, TOL, RESID and NCV. Certain values of TOL seem to cause numerical errors or a number overflow when using double precision and certain initial residual vectors RESID, either with INFO==0 or INFO==1. NCV causes error message if inadequate values are set.
    The following parameters seem to be more or less stable for both float and double precision: d=0.85 or d=0.9 TOL = Float.MIN_VALUE, resp. Double.MIN_VALUE INFO = 0 RESID = new float[N], resp. new double[N]; (no initial residuals) NCV = Math.min(Math.max(2*NEV+1, 20), N);
    The important parameter is d. The dgems/sgemv methods are highly unstable for other values of d, e.g. d=0.99, d=0.95, and d=0.995.
    The following references were most informative for using ARPACK: - R. B. Lehoucq, D. C. Sorensen, C. Yang: ARPACK Users' Guide: Solution of Large Scale Eigenvalue Problems with Implicitly Restarted Arnoldi Methods. - Matlab implementation of eigs: eigs.m - SciPy Development Wiki, for snaupd.f and sneupd.f - BLAS (Basic Linear Algebra Subprograms) documentation, particularly for sgemv.f.
    
    Parameters:
    A - Matrix for calculating the eigenvector in Fortran matrix style.
    m - Number of rows/columns in A.
    d - Damping factor.
    forceDecomposition - If true and an error occurs, calculates the full eigenvalue spectrum.
    
    Returns:
    The eigenvector corresponding to the largest eigenvalue.
    See Also:
    reactionCentralities(MetabolicGraph,double,boolean,boolean), eigenvectorDouble(double[],int,double,boolean)
  - eigenvectorDouble
```
public double[] eigenvectorDouble(double[] A,
                         int m,
                         double d,
                         boolean forceDecomposition)
```
    Calculates the eigenvector corresponding to the largest eigenvalue of A using the Fortran routines dnaupd and dgemv. If the fast calculation using the Arnoldi method fails, then the eigenvector corresponding to the largest eigenvalue is determined from the full eigenvalue spectrum using the LAPACK routine dgeev (eigenvalueDecomposition(double[],int).
    Before eigenvalue calculation, the matrix A is normalized according to page rank with damping factor d:
    A_i,j = e(r_i,r_j)*(A_i,j/colsum_j)*d+(1-d)/m)
    where e(r_i,r_j) = max(1/inDegreeOf(c)) is the local essentiality for all c which are a product of r_i and a substrate of r_j, or 0, if no such c exists;
    colsum_j is the sum of all entries of column j;
    m is the number of columns/rows.
    See eigenvalueDecomposition(float[],int) for additional information.
    
    Parameters:
    A - Matrix for calculating the eigenvector in Fortran matrix style.
    m - Number of rows/columns in A.
    d - Damping factor.
    forceDecomposition - If true and an error occurs, calculates the full eigenvalue spectrum.
    
    Returns:
    The eigenvector corresponding to the largest eigenvalue.
    See Also:
    reactionCentralities(MetabolicGraph,double,boolean,boolean), eigenvectorFloat(float[],int,double,boolean)
  - eigenvalueDecomposition
```
public double[] eigenvalueDecomposition(double[] matrix,
                               int m)
```
    Calculates the full eigenvalue spectrum with double precision using the Fortran method dgeev.
    
    Parameters:
    matrix - The matrix in Fortran-style array format (column order).
    m - Number of reactions.
    
    Returns:
    The eigenvector corresponding to the largest eigenvalue of the given matrix.
    See Also:
    reactionCentralities(MetabolicGraph,double,boolean,boolean)
  - eigenvalueDecomposition
```
public float[] eigenvalueDecomposition(float[] matrix,
                              int m)
```
    Calculates the full eigenvalue spectrum with float precision using the Fortran method sgeev.
    
    Parameters:
    matrix - The matrix in Fortran-style array format (column order).
    m - Number of reactions.
    
    Returns:
    The eigenvector corresponding to the largest eigenvalue of the given matrix.
    See Also:
    reactionCentralities(MetabolicGraph,double,boolean,boolean)
  - getTransitionDegree
```
public int getTransitionDegree(HashMap<ArrayList<Integer>,EquivalenceClass> classes,
                      HashSet<Vertex> preserved)
```
    Calculates the number of possible substitutions for all reactions, i.e., the degree of the node representing this graph in the transition graph Sigma_G. Assumes that the stoichiometry of any reaction is allowed to be updated.
    
    Returns:
    Number of possible substitutions.
  - neighborsOf
```
public HashSet<Vertex> neighborsOf(Vertex v)
```
    Returns the set containing all second neighboring vertices. The size of the set is the degree of the node in the corresponding undirected unipartite network.
    
    Parameters:
    v -
    
    Returns:
    HashSet of neighboring vertices.
  - successorsOf
```
public HashSet<Vertex> successorsOf(Vertex v)
```
    Returns the set containing all second successor vertices. The size of the set is the out-degree of the node in the corresponding unipartite network.
    
    Parameters:
    v -
    
    Returns:
    HashSet of successor vertices.
  - predecessorsOf
```
public HashSet<Vertex> predecessorsOf(Vertex v)
```
    Returns the set containing all second predecessor vertices. The size of the set is the in-degree of the node in the corresponding unipartite network.
    
    Parameters:
    v -
    
    Returns:
    HashSet of predecessor vertices.
  - readDeltaG
```
public void readDeltaG(String file,
              String logFile)
                throws IOException
```
    Reads the deltaGf of compounds from a tab-separated file and stores the values with the compound vertices.
    
    Parameters:
    file -
    
    Throws:
    
    IOException
  - getDeltaGn
```
public Double getDeltaGn()
```
    Calculates the sum of deltaGr over all reactions. For performance reasons the result is allowed to be slightly imprecise (use of primitive types). However, the corresponding float representation should be precise. Use Double.floatValue() to reproduce exact results.
    
    Returns:
    Sum of deltaGr.
  - validDeltaGr
```
public int validDeltaGr()
```
    Counts the number of reactions containing only compounds with a known deltaGf.
    
    Returns:
    Number of reactions with a deltaGf.
  - getDeltaGr
```
public Double getDeltaGr(Vertex reaction,
                boolean reversible)
```
    Calculates the deltaGr of a reaction by summing over the negative deltaGf of substrates and the positive deltaGf of products, multiplied by the stoichiometric coefficients. For performance reasons the result is allowed to be slightly imprecise (use of primitive types). However, the corresponding float representation should be precise. Use Double.floatValue() to reproduce exact results. If reversible==true, the deltaGr of reversible reactions is considered 0. Otherwise, the deltaGr of the reaction vertex is returned, independent of whether the vertex is the forward or reversed direction of a reversible reaction.
    
    Parameters:
    reaction -
    reversible -
    
    Returns:
    deltaGr of the reaction.
  - getCompartments
```
public HashMap<String,HashSet<Vertex>> getCompartments()
```
    Returns a map of compartment strings and vertex sets. Each vertex set contains the compounds from the corresponding compartment string.
    
    Returns:
    HashMap of compartment strings and vertex sets.
  - substitutability
```
public void substitutability(HashMap<ArrayList<Integer>,EquivalenceClass> classes,
                    String substitutabilityFile)
                      throws IOException
```
    Calculate the sample space and substitutability class sizes for individual and pair substitutions. Note that the pair substitutability classes also contain implicit pairs, i.e., pairwise linearly dependent individual compounds. Note that the sample space is not affected by the set of preserved vertices.
    
    Parameters:
    classes -
    substitutabilityFile -
    
    Throws:
    
    IOException
  - randomize
```
public BigDecimal randomize(MetabolicGraph originalGraph,
                   HashMap<ArrayList<Integer>,EquivalenceClass> classes,
                   HashSet<Vertex> preserved,
                   float p,
                   boolean iterative,
                   float depth,
                   String deltaGFile,
                   String substitutabilityFile,
                   boolean append,
                   String logFile)
                     throws IOException
```
    Performs mass balanced randomization on the graph by perturbing single compounds and pairs. In a randomized reaction, substrates and products, and pairs thereof, are replaced by substitutes from the corresponding mass equivalence class.
    The perturbations preserve the reaction degree with respect to compounds, i.e., the number of unique substrates/products is not changed. Mass balance is preserved: any reaction has the same numbers of chemical species on each side after perturbation. Generating duplicate reactions in the network is avoided.
    If compartments==true, then compounds are only substituted within the same compartment. In addition, reactions which connect compartments and reactions with in- or out-degree of zero are skipped.
    If preserveStrongComponents==true, then the sizes of strongly connected components are preserved in the following way: any substitution which changes the size of the component of the original compound is skipped. In that way, the creation of 'orphane' or 'dead end' metabolites is avoided.
    
    Parameters:
    classes - Mass equivalence classes of the compounds.
    preserved - A set of vertices (compounds or reactions) which are not randomized.
    p - if p<1, then each reaction is only perturbed with probability p.
    depth - factor indicating randomization strength. 1 indicates default values (see below).
    iterative - if true, then each reaction is randomized (deg*deg+deg)/2 times, otherwise |V_r|*avgDeg^2 reaction sides are chosen at random and perturbed once. reactions are randomized once.
    logFile -
    
    Returns:
    The ratio of modified reactions in the network if logFile != null, null otherwise.
    
    Throws:
    
    IOException
  - matrixSubstitutions
```
public void matrixSubstitutions(HashMap<ArrayList<Integer>,EquivalenceClass> classes,
                       HashSet<Vertex> preserved,
                       String outputFile,
                       boolean doubles,
                       boolean reversible)
                         throws IOException
```
    Writes each possible single and pair substitution of the stoichiometric matrix of the original network to tab-separated files. Does not modify the network. Each line of the files corresponds to one substitution: reaction D=deltaGr d=diff old_compound(s) new_compound(s) (i j s)+ where deltaGr is the DeltaGr of the original reaction, and diff is the difference in DeltaGr between the original and the new reaction. (i j s)+ is any number of triplets, with i the row index (compound), j the column index (reaction), and s the new coefficient (i.e., [i,j] is set to s). If reversible==true, then the substitution indices correspond to the stoichiometric matrix including reversible reactions as two columns, one for each direction (corresponding to a call of stoichiometricMatrix(String,boolean,boolean,boolean,boolean) with reversible==true). Otherwise, the indices correspond to the stoichiometric matrix excluding reversed directions of reversible reactions (corresponding to a call of stoichiometricMatrix(String,boolean,boolean,boolean,boolean) with reversible==false). Note: the order of substitutions is not the same as in equationSubstitutions(MetabolicGraph,HashMap,HashSet,String,boolean). TODO include reaction equations from equationSubstitutions in output file.
    
    Parameters:
    classes -
    outputFile -
    doubles -
    reversible -
    
    Throws:
    
    IOException
    See Also:
    equationSubstitutions(MetabolicGraph,HashMap,HashSet,String,boolean)
  - equationSubstitutions
```
public void equationSubstitutions(MetabolicGraph originalGraph,
                         HashMap<ArrayList<Integer>,EquivalenceClass> classes,
                         HashSet<Vertex> preserved,
                         String outputFile,
                         boolean doubles)
                           throws IOException
```
    Writes each possible single and pair substitution of the reaction equations of the original network to tab-separated files. Does not modify the network. Each line of the files corresponds to one substitution: reaction old_equation deltaGr new_equation diff where old_equation is the reaction equation of the original reaction, deltaGr is the DeltaGr of the original reaction, new_equation is the equation of the substituted reaction, and diff is the difference in DeltaGr between the original and the new reaction. Note: the order of substitutions is not the same as in matrixSubstitutions(HashMap,HashSet,String,boolean,boolean).
    
    Parameters:
    originalGraph -
    classes -
    outputFile -
    doubles -
    
    Throws:
    
    IOException
    See Also:
    matrixSubstitutions(HashMap,HashSet,String,boolean,boolean)
  - getDeltaGDifference
```
public Double getDeltaGDifference(Vertex reaction,
                         int side,
                         Vertex compound,
                         Vertex substitute,
                         int[] solve)
```
    Calculates the difference in deltaG of the reaction after substituting compound by substitute on the given side, without modifying the network. For reversible reactions, the difference is calculated for the direction of the given reaction, as the full deltaGr is always 0.
    
    Parameters:
    reaction -
    side -
    compound -
    substitute -
    
    Returns:
    Difference in deltaG.
  - getDeltaGDifference
```
public Double getDeltaGDifference(Vertex reaction,
                         int side,
                         Vertex compound1,
                         Vertex compound2,
                         Vertex substitute1,
                         Vertex substitute2,
                         int[] solve)
```
    Calculates the difference in deltaG of the reaction after substituting compound1 and compound1 by substitute1 and substitute2 on the given side. For reversible reactions, the difference is calculated for the direction of the given reaction.
    
    Parameters:
    reaction -
    side -
    compound1 -
    compound2 -
    substitute1 -
    substitute2 -
    solve -
    
    Returns:
    Difference in deltaG.
  - distanceTo
```
public int distanceTo(MetabolicGraph graph)
```
    Counts the differences in substrates and products between this graph and the given graph. Note that this method assumes all corresponding reactions have the same number of substrates and products, and compounds have the same names.
    
    Parameters:
    graph -
  - isDuplicate
```
public Vertex isDuplicate(Vertex reaction)
```
    Returns the first found duplicate reaction. Two reactions are duplicate, if either they have identical substrates and products with equal stoichiometric cofficients, or if one of them is reversible and the substrates of one reaction equal the products of the other (and vice versa). If no such duplicate exists, null is returned. For reactions with in- and out-degree zero null is returned, even though such duplicates may exist.
    
    Returns:
    The first found duplicate reaction, if it exists, null otherwise.
  - switchRandomize
```
public void switchRandomize(boolean strict)
```
    Performs switch-randomization on the graph. Two (non-reversed) edges of the same type (substrate or product) are drawn at random and switched, i.e., the corresponding sources and targets of the edges are exchanged. The reaction degrees are preserved, because only vertices of the same type (substrate or product) are exchanged. If strict==true, then reversible reactions are never switched with irreversible reactions, such that the in- and out-degrees of compounds are preserved. If strict==false, then reversible reactions may be switched with irreversible reactions, in which case the in- and out-degrees of switched compounds increase respectively decrease by 1. In any case, the total number of chemical reactions any compound takes part in (reversible+irreversible) is preserved.
    In case the drawn edges share a common source or target, the graph is not actually modified.
    The number of perturbations is given by the number of distinct substrate edge pairs plus the number of distinct product edge pairs, i.e., s*(s-1)+p*(p-1), where s is the number of substrate edges and p the number of product edges.
    Note that reversed reactions are not switched explicitly, as they are synchronized implicitly with every modification (see addEdge(Vertex,Vertex)).
    
    Parameters:
    strict -
  - hasEdge
```
public boolean hasEdge(Vertex vertex1,
              Vertex vertex2)
```
    Tests whether the graph has an edge connecting vertex1 and vertex2 in either direction.
    
    Parameters:
    vertex1 -
    vertex2 -
    
    Returns:
    true, if such an edge exists, false otherwise.
  - addVertex
```
public boolean addVertex(Vertex vertex)
```
    Adds the vertex to the graph and creates an entry in the compounds or reactions HashMap. If the graph is reversible or the vertex is of type Vertex.REACTION and has a reversed reaction, then the reversed reaction is added implicitly.
    
    Specified by:
    
    addVertex in interface org.jgrapht.Graph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>
    
    Overrides:
    
    addVertex in class org.jgrapht.graph.AbstractBaseGraph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>
    
    Returns:
    True if the graph did not already contain the specified vertex.
  - removeVertex
```
public boolean removeVertex(Vertex vertex)
```
    Removes the vertex from the graph and removes the entry from the compounds or reactions HashMap. If the vertex is a reaction and a reversed reaction exists (vertex.reversedReaction()!=null), then the reversed reaction is also removed.
    
    Specified by:
    
    removeVertex in interface org.jgrapht.Graph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>
    
    Overrides:
    
    removeVertex in class org.jgrapht.graph.AbstractBaseGraph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>
    
    Returns:
    True if the graph contained the specified vertex, false otherwise.
  - addEdge
```
public org.jgrapht.graph.DefaultWeightedEdge addEdge(Vertex source,
                                            Vertex target)
```
    Adds an edge to connect source and target. If the graph is reversible or the reaction vertex has a reversed reaction, then the reversed edge is created implicitly.
    
    Specified by:
    
    addEdge in interface org.jgrapht.Graph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>
    
    Overrides:
    
    addEdge in class org.jgrapht.graph.AbstractBaseGraph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>
    
    Returns:
    The new edge connecting source and target, or null if the edge could not be added (see AbstractBaseGraph.addEdge(Vertex,Vertex)).
  - addEdge
```
public boolean addEdge(Vertex source,
              Vertex target,
              org.jgrapht.graph.DefaultWeightedEdge e)
```
    Adds the edge to connect source and target. If the graph is reversible or the reaction vertex has a reversed reaction, then the reversed edge is created implicitly.
    
    Specified by:
    
    addEdge in interface org.jgrapht.Graph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>
    
    Overrides:
    
    addEdge in class org.jgrapht.graph.AbstractBaseGraph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>
    
    Returns:
    The new edge connecting source and target, or null if the edge could not be added (see AbstractBaseGraph.addEdge(Vertex,Vertex,E)).
  - removeEdge
```
public org.jgrapht.graph.DefaultWeightedEdge removeEdge(Vertex source,
                                               Vertex target)
```
    Removes the edge connecting source and target. If the graph is reversible or the reaction vertex has a reversed reaction, then also removes the corresponding edge of the reversed reaction.
    
    Specified by:
    
    removeEdge in interface org.jgrapht.Graph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>
    
    Overrides:
    
    removeEdge in class org.jgrapht.graph.AbstractBaseGraph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>
    
    Returns:
    The removed edge previously connecting source and target, or null if this edge did not exist.
  - removeEdge
```
public boolean removeEdge(org.jgrapht.graph.DefaultWeightedEdge e)
```
    Removes the edge. If the graph is reversible, also removes the corresponding edge of the reversed reaction.
    
    Specified by:
    
    removeEdge in interface org.jgrapht.Graph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>
    
    Overrides:
    
    removeEdge in class org.jgrapht.graph.AbstractBaseGraph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>
    
    Returns:
    True if the edge existed, false otherwise.
  - setEdgeWeight
```
public void setEdgeWeight(org.jgrapht.graph.DefaultWeightedEdge e,
                 double weight)
```
    Sets the weight for the edge. If the graph is reversible or the reaction vertex has a reversed reaction, then also sets the same weight for the edge of the reversed reaction.
    
    Specified by:
    
    setEdgeWeight in interface org.jgrapht.WeightedGraph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>
    
    Overrides:
    
    setEdgeWeight in class org.jgrapht.graph.AbstractBaseGraph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>
  - clone
```
public MetabolicGraph clone()
```
    Creates an identical copy of the graph: reversibility is copied, vertices are copied with names, mass and reversible reactions, edges are copied with weights.
    
    Overrides:
    
    clone in class org.jgrapht.graph.AbstractBaseGraph<Vertex,org.jgrapht.graph.DefaultWeightedEdge>
  - compare
```
public boolean compare(MetabolicGraph graph)
```
    Compares this MetabolicGraph to the given MetabolicGraph. Compares member variables as well as the member variables of all vertices and all edges (their sources and targets). Compares amongst others the following member variables: - version - isReversible() - vertexSet().size() - edgeSet().size() - for every vertex v in vertexSet(): containsVertex(v) and v.compare() - for every edge e in edgeSet(): containsEdge(e), getEdgeSource(e).compare(), getEdgeTarget(e).compare(), and getEdgeWeight(e).
    
    Parameters:
    graph -
    
    Returns:
    true, if the graphs are identical, false otherwixe.
  - compareEdges
```
public boolean compareEdges(MetabolicGraph graph)
```
    Compares the edges of this MetabolicGraph to the edges of the given MetabolicGraph. Compares the member variables of all all edges (their sources and targets). The vertices must exist in both graphs and have identical names and compartments. Compares amongst others the following member variables: - edgeSet().size() - for every edge e in edgeSet(): containsEdge(e), getEdgeSource(e).compare(), getEdgeTarget(e).compare(), and getEdgeWeight(e).
    
    Parameters:
    graph -
    
    Returns:
    true, if the edge sets are equal, false otherwise.
  - write
```
public void write(String outputFile,
         boolean printAllCoefficients)
           throws IOException
```
    Writes the graph to a tab- and delimiter-separated file readable by createGraph.
    
    Parameters:
    outputFile -
    
    Throws:
    
    IOException
  - write2
```
public void write2(String outputFile,
          boolean printAllCoefficients)
            throws IOException
```
    Writes the graph to an alternative tab- and delimiter-separated file format.
    
    Parameters:
    outputFile -
    
    Throws:
    
    IOException
  - writeBalance
```
public void writeBalance(String outputFile,
                boolean append)
                  throws IOException
```
    Writes the number of balanced reactions and the number of reactions which are fully annotated, i.e., of which all substrates and products have an annotated mass. The latter number may vary between randomized graphs.
    
    Parameters:
    outputFile -
    append -
    
    Throws:
    
    IOException

Class MetabolicGraph

Field Summary

Fields inherited from interface org.jgrapht.WeightedGraph

Constructor Summary

Method Summary

Methods inherited from class org.jgrapht.graph.AbstractBaseGraph

Methods inherited from class org.jgrapht.graph.AbstractGraph

Methods inherited from class java.lang.Object

Methods inherited from interface org.jgrapht.Graph

Methods inherited from interface org.jgrapht.DirectedGraph

Field Detail

version

Constructor Detail

MetabolicGraph

MetabolicGraph

Method Detail

isReversible

hasCompartments

getCompound

getCompounds

getReaction

getReactions

getReactionNames

getReactionEquation

fixStoichiometry

leastIntegerMultiple

leastIntegerMultiple

balance

adjacencyMatrix

stoichiometricMatrix

massMatrix

averageReactionDegree

maxReactionInDegree

maxReactionOutDegree

maxReactionDegree

compoundDegrees

compoundDeadEnds

reactionDegrees

compoundInOutDegrees

weights

clusteringCoefficientUndirected

isNeighbour

isAdjacent

isReachable

isConnected

isPath

isCyclic

hasCycle

getCompartments

cycleCount

randomScopeSizes

scope

scope_old

connectedComponents

characteristicPathLength

assortativities

assortativities_old

correlation

localCentrality

localCentrality

localEssentiality

knockoutSet

reactionCentralities

eigenvectorFloat

eigenvectorDouble

eigenvalueDecomposition

eigenvalueDecomposition

getTransitionDegree

neighborsOf

successorsOf

predecessorsOf

readDeltaG

getDeltaGn

validDeltaGr

getDeltaGr

getCompartments

substitutability

randomize

matrixSubstitutions

equationSubstitutions