All Superinterfaces:

Graph<Integer,Integer>

All Known Subinterfaces:

IndexGraph

All Known Implementing Classes:

GraphBaseWithEdgeEndpointsContainer
```
public interface IntGraph
extends Graph<Integer,Integer>
```
A discrete graph with int vertices and edges.
This interface is a specification of Graph for graphs with int vertices and edges, similarly how Int2IntMap is a specification of Map for maps with int keys and values. Methods that accept a primitive int as an identifier are provided, and the original ones that accept a Integer are deprecated. Specific IEdgeSet and IEdgeIter are returned for edges queries, avoiding boxing of integers. Similarly, the IWeights interface is used for weights containers, which accept primitive int as identifiers.
Each vertex and edge in the graph is identified by a unique non negative int identifier. Vertices and edges may be created by addVertex() and addEdge(int, int), in which case the graph implementation will choose the int identifier and will return it to the user. Alternatively, the methods addVertex(int) and addEdge(int, int, int) (similar the regular Graph methods) can be used to add new vertices and edges with user chosen identifiers.
Implementations of this interface are more efficient than the generic Graph interface, and should be used for better performance if its needed. For even better performance, consider using IndexGraph, which does violate the Graph interface as its vertices and edges may change during the lifetime of the graph and therefore less user friendly, but is even more efficient.
To create a new empty graph, use newUndirected() or newDirected(). The returned graph will use the default implementation. For more control over the graph details, see IntGraphFactory. To construct an immutable graph, use IntGraphBuilder.
```
 
 // Create a directed graph with three vertices and edges between them
 IntGraph g = IntGraph.newDirected();
 int v1 = g.addVertex();
 int v2 = g.addVertex();
 int v3 = g.addVertex();
 int e1 = g.addEdge(v1, v2);
 int e2 = g.addEdge(v2, v3);
 int e3 = g.addEdge(v1, v3);

 // Assign some weights to the edges
 IWeightsDouble weights = g.addEdgesWeights("weightsKey", double.class);
 weights.set(e1, 1.2);
 weights.set(e2, 3.1);
 weights.set(e3, 15.1);
 IWeightFunction weightFunc = weights;

 // Calculate the shortest paths from v1 to all other vertices
 ShortestPathSingleSource ssspAlgo = ShortestPathSingleSource.newInstance();
 ShortestPathSingleSource.Result ssspRes = ssspAlgo.computeShortestPaths(g, weightFunc, v1);

 // Print the shortest path from v1 to v3
 assert ssspRes.distance(v3) == 4.3;
 assert ssspRes.getPath(v3).edges().equals(IntList.of(e1, e2));
 System.out.println("Distance from v1 to v3 is: " + ssspRes.distance(v3));
 System.out.println("The shortest path from v1 to v3 is:");
 for (int e : ssspRes.getPath(v3).edges()) {
 	int u = g.edgeSource(e), v = g.edgeTarget(e);
 	System.out.println(" " + e + "(" + u + ", " + v + ")");
 }
 
```
Author:

Barak Ugav

See Also:

IntGraphFactory, IntGraphBuilder, IndexGraph

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method	Description
`int`	`addEdge(int source, int target)`	Add a new edge to the graph.
`void`	`addEdge(int source, int target, int edge)`	Add a new edge to the graph with user chosen ID.
`default void`	`addEdge(Integer source, Integer target, Integer edge)`	Deprecated.
`int`	`addVertex()`	Add a new vertex to the graph.
`void`	`addVertex(int vertex)`	Add a new vertex to the graph with user chosen ID.
`default void`	`addVertex(Integer vertex)`	Deprecated.
`default IntGraph`	`copy()`	Create a copy of this graph, with the same vertices and edges, without copying weights.
`default IntGraph`	`copy(boolean copyWeights)`	Create a copy of this graph, with the same vertices and edges, with/without copying weights.
`default int`	`edgeEndpoint(int edge, int endpoint)`	Get the other end-point of an edge.
`default Integer`	`edgeEndpoint(Integer edge, Integer endpoint)`	Deprecated.
`IntSet`	`edges()`	Get the set of all edges of the graph.
`int`	`edgeSource(int edge)`	Get the source vertex of an edge.
`default Integer`	`edgeSource(Integer edge)`	Deprecated.
`int`	`edgeTarget(int edge)`	Get the target vertex of an edge.
`default Integer`	`edgeTarget(Integer edge)`	Deprecated.
`default int`	`getEdge(int source, int target)`	Get the edge whose source is `source` and target is `target`.
`default Integer`	`getEdge(Integer source, Integer target)`	Deprecated.
`IEdgeSet`	`getEdges(int source, int target)`	Get the edges whose source is `source` and target is `target`.
`default EdgeSet<Integer,Integer>`	`getEdges(Integer source, Integer target)`	Deprecated.
`<T,WeightsT extends IWeights<T>> WeightsT`	`getEdgesIWeights(String key)`	Get the edges weights of some key.
`default <T,WeightsT extends Weights<Integer,T>> WeightsT`	`getEdgesWeights(String key)`	Get the edges weights of some key.
`<T,WeightsT extends IWeights<T>> WeightsT`	`getVerticesIWeights(String key)`	Get the vertices weights of some key.
`default <T,WeightsT extends Weights<Integer,T>> WeightsT`	`getVerticesWeights(String key)`	Get the vertices weights of some key.
`default IntGraph`	`immutableCopy()`	Create an immutable copy of this graph, with the same vertices and edges, without copying weights.
`default IntGraph`	`immutableCopy(boolean copyWeights)`	Create an immutable copy of this graph, with the same vertices and edges, with/without copying weights.
`default IntGraph`	`immutableView()`	Get an immutable view of this graph.
`IndexIntIdMap`	`indexGraphEdgesMap()`	Get the index-id edges mapping of this graph.
`IndexIntIdMap`	`indexGraphVerticesMap()`	Get the index-id vertices mapping of this graph.
`IEdgeSet`	`inEdges(int target)`	Get the edges whose target is `target`.
`default EdgeSet<Integer,Integer>`	`inEdges(Integer target)`	Deprecated.
`static IntGraph`	`newDirected()`	Create a new directed empty int graph.
`static IntGraph`	`newUndirected()`	Create a new undirected empty int graph.
`IEdgeSet`	`outEdges(int source)`	Get the edges whose source is `source`.
`default EdgeSet<Integer,Integer>`	`outEdges(Integer source)`	Deprecated.
`void`	`removeEdge(int edge)`	Remove an edge from the graph.
`default void`	`removeEdge(Integer edge)`	Deprecated.
`default void`	`removeEdgesOf(int vertex)`	Remove all the edges of a vertex.
`default void`	`removeEdgesOf(Integer vertex)`	Deprecated.
`default void`	`removeInEdgesOf(int target)`	Remove all edges whose target is `target`.
`default void`	`removeInEdgesOf(Integer vertex)`	Deprecated.
`default void`	`removeOutEdgesOf(int source)`	Remove all edges whose source is `source`.
`default void`	`removeOutEdgesOf(Integer vertex)`	Deprecated.
`void`	`removeVertex(int vertex)`	Remove a vertex and all its edges from the graph.
`default void`	`removeVertex(Integer vertex)`	Deprecated.
`void`	`reverseEdge(int edge)`	Reverse an edge by switching its source and target.
`default void`	`reverseEdge(Integer edge)`	Deprecated.
`default IntGraph`	`reverseView()`	Get a reversed view of this graph.
`default IntGraph`	`subGraphCopy(Collection<Integer> vertices, Collection<Integer> edges)`	Create a new graph that is a subgraph of this graph.
`default IntGraph`	`undirectedView()`	Get an undirected view of this (directed) graph.
`IntSet`	`vertices()`	Get the set of all vertices of the graph.

Methods inherited from interface com.jgalgo.graph.Graph
addEdgesWeights, addEdgesWeights, addVerticesWeights, addVerticesWeights, clear, clearEdges, getEdgesWeightsKeys, getVerticesWeightsKeys, indexGraph, isAllowParallelEdges, isAllowSelfEdges, isDirected, removeEdgesWeights, removeVerticesWeights

- Method Detail
  - vertices
```
IntSet vertices()
```
    Description copied from interface: Graph
    
    Get the set of all vertices of the graph.
    Each vertex in the graph is identified by a unique non null hashable object and the returned set is a set of all these identifiers.
    The Graph object does not expose an explicit method to get the number of vertices, but it can accessed using this method by g.vertices().size().
    
    Specified by:
    
    vertices in interface Graph<Integer,Integer>
    
    Returns:
    
    a set containing all vertices of the graph
  - edges
```
IntSet edges()
```
    Description copied from interface: Graph
    
    Get the set of all edges of the graph.
    Each edge in the graph is identified by a unique non null hashable object, and the returned set is a set of all these identifiers.
    The Graph object does not expose an explicit method to get the number of edges, but it can accessed using this method by g.edges().size().
    
    Specified by:
    
    edges in interface Graph<Integer,Integer>
    
    Returns:
    
    a set containing all edges of the graph
  - addVertex
```
int addVertex()
```
    Add a new vertex to the graph.
    The graph implementation will choose a new int identifier which is not currently used as one of the graph edges, and will return it as the new vertex ID.
    
    Returns:
    
    the new vertex identifier
  - addVertex
```
void addVertex(int vertex)
```
    Add a new vertex to the graph with user chosen ID.
    In contrast to addVertex(), in which the implementation chooses ,the new vertex identifier, the user can specified what int ID the new vertex should be assigned. The set of graph vertices must not contain duplications, therefore the provided identifier must not be currently used as one of the graph vertices IDs.
    Note that vertices IDs must be non negative.
    
    Parameters:
    
    vertex - a user chosen identifier for the new vertex
    
    Throws:
    
    IllegalArgumentException - if the provided identifier is already used as identifier of one of the graph vertices, or if its negative
  - addVertex
```
@Deprecated
default void addVertex(Integer vertex)
```
    Deprecated.
    
    Description copied from interface: Graph
    
    Add a new vertex to the graph.
    A vertex can be any non null hashable object, namely it must implement Object.hashCode() and Object.equals(Object) methods. The set of graph vertices must not contain duplications, therefore the provided identifier must not be currently used as one of the graph vertices IDs.
    
    Specified by:
    
    addVertex in interface Graph<Integer,Integer>
    
    Parameters:
    
    vertex - new vertex
  - removeVertex
```
void removeVertex(int vertex)
```
    Remove a vertex and all its edges from the graph.
    
    Parameters:
    
    vertex - the vertex identifier to remove
    
    Throws:
    
    NoSuchVertexException - if vertex is not a valid vertex identifier
  - removeVertex
```
@Deprecated
default void removeVertex(Integer vertex)
```
    Deprecated.
    
    Description copied from interface: Graph
    
    Remove a vertex and all its edges from the graph.
    
    Specified by:
    
    removeVertex in interface Graph<Integer,Integer>
    
    Parameters:
    
    vertex - the vertex identifier to remove
  - outEdges
```
IEdgeSet outEdges(int source)
```
    Get the edges whose source is source.
    In case the graph is undirected, the set will contain all edges whose source is one of their end points.
    The graph object does not expose an explicit method to get the (out) degree of a vertex, but it can accessed using this method by g.outEdges(vertex).size().
    
    Parameters:
    
    source - a source vertex
    
    Returns:
    
    all the edges whose source is source
    
    Throws:
    
    NoSuchVertexException - if source is not a valid vertex identifier
  - outEdges
```
@Deprecated
default EdgeSet<Integer,Integer> outEdges(Integer source)
```
    Deprecated.
    
    Description copied from interface: Graph
    
    Get the edges whose source is source.
    In case the graph is undirected, the set will contain all edges whose source is one of their end points.
    The graph object does not expose an explicit method to get the (out) degree of a vertex, but it can accessed using this method by g.outEdges(vertex).size().
    
    Specified by:
    
    outEdges in interface Graph<Integer,Integer>
    
    Parameters:
    
    source - a source vertex
    
    Returns:
    
    all the edges whose source is source
  - inEdges
```
IEdgeSet inEdges(int target)
```
    Get the edges whose target is target.
    In case the graph is undirected, the set will contain all edges whose target is one of their end points.
    The graph object does not expose an explicit method to get the (in) degree of a vertex, but it can accessed using this method by g.inEdges(vertex).size().
    
    Parameters:
    
    target - a target vertex
    
    Returns:
    
    all the edges whose target is target
    
    Throws:
    
    NoSuchVertexException - if target is not a valid vertex identifier
  - inEdges
```
@Deprecated
default EdgeSet<Integer,Integer> inEdges(Integer target)
```
    Deprecated.
    
    Description copied from interface: Graph
    
    Get the edges whose target is target.
    In case the graph is undirected, the set will contain all edges whose target is one of their end points.
    The graph object does not expose an explicit method to get the (in) degree of a vertex, but it can accessed using this method by g.inEdges(vertex).size().
    
    Specified by:
    
    inEdges in interface Graph<Integer,Integer>
    
    Parameters:
    
    target - a target vertex
    
    Returns:
    
    all the edges whose target is target
  - getEdge
```
default int getEdge(int source,
                    int target)
```
    Get the edge whose source is source and target is target.
    If the graph is not directed, the return edge is an edge that its end-points are source and target.
    In case there are multiple (parallel) edges between source and target, a single arbitrary one is returned.
    
    Parameters:
    
    source - a source vertex
    
    target - a target vertex
    
    Returns:
    
    id of the edge or -1 if no such edge exists
    
    Throws:
    
    NoSuchVertexException - if source or target are not valid vertices identifiers
  - getEdge
```
@Deprecated
default Integer getEdge(Integer source,
                        Integer target)
```
    Deprecated.
    
    Description copied from interface: Graph
    
    Get the edge whose source is source and target is target.
    If the graph is not directed, the return edge is an edge that its end-points are source and target.
    In case there are multiple (parallel) edges between source and target, a single arbitrary one is returned.
    
    Specified by:
    
    getEdge in interface Graph<Integer,Integer>
    
    Parameters:
    
    source - a source vertex
    
    target - a target vertex
    
    Returns:
    
    id of the edge or null if no such edge exists
  - getEdges
```
IEdgeSet getEdges(int source,
                  int target)
```
    Get the edges whose source is source and target is target.
    
    Parameters:
    
    source - a source vertex
    
    target - a target vertex
    
    Returns:
    
    all the edges whose source is source and target is target
    
    Throws:
    
    NoSuchVertexException - if source or target are not valid vertices identifiers
  - getEdges
```
@Deprecated
default EdgeSet<Integer,Integer> getEdges(Integer source,
                                                Integer target)
```
    Deprecated.
    
    Description copied from interface: Graph
    
    Get the edges whose source is source and target is target.
    
    Specified by:
    
    getEdges in interface Graph<Integer,Integer>
    
    Parameters:
    
    source - a source vertex
    
    target - a target vertex
    
    Returns:
    
    all the edges whose source is source and target is target
  - addEdge
```
int addEdge(int source,
            int target)
```
    Add a new edge to the graph.
    The graph implementation will choose a new int identifier which is not currently used as one of the graph edges, and will return it as the new edge ID.
    
    Parameters:
    
    source - a source vertex
    
    target - a target vertex
    
    Returns:
    
    the new edge identifier
    
    Throws:
    
    NoSuchVertexException - if source or target are not valid vertices identifiers
  - addEdge
```
void addEdge(int source,
             int target,
             int edge)
```
    Add a new edge to the graph with user chosen ID.
    In contrast to addEdge(int, int), in which the implementation chooses the new edge identifier, the user can specified what int ID the new edge should be assigned. The set of graph edges must not contain duplications, therefore the provided identifier must not be currently used as one of the graph edges IDs.
    
    Parameters:
    
    source - a source vertex
    
    target - a target vertex
    
    edge - a user chosen identifier for the new edge
    
    Throws:
    
    IllegalArgumentException - if the provided identifier is already used as identifier of one of the graph edges, or if its negative
  - addEdge
```
@Deprecated
default void addEdge(Integer source,
                     Integer target,
                     Integer edge)
```
    Deprecated.
    
    Description copied from interface: Graph
    
    Add a new edge to the graph.
    If the graph does not support parallel edges, and an edge between source and target already exists, an exception will be raised. If the graph does not support self edges, and source and target are the same vertex, an exception will be raised.
    The edge identifier must be unique and non null.
    
    Specified by:
    
    addEdge in interface Graph<Integer,Integer>
    
    Parameters:
    
    source - a source vertex
    
    target - a target vertex
    
    edge - a new edge identifier
  - removeEdge
```
void removeEdge(int edge)
```
    Remove an edge from the graph.
    
    Parameters:
    
    edge - the edge identifier
    
    Throws:
    
    NoSuchEdgeException - if edge is not a valid edge identifier
  - removeEdge
```
@Deprecated
default void removeEdge(Integer edge)
```
    Deprecated.
    
    Description copied from interface: Graph
    
    Remove an edge from the graph.
    
    Specified by:
    
    removeEdge in interface Graph<Integer,Integer>
    
    Parameters:
    
    edge - the edge to remove
  - removeEdgesOf
```
default void removeEdgesOf(int vertex)
```
    Remove all the edges of a vertex.
    
    Parameters:
    
    vertex - a vertex in the graph
    
    Throws:
    
    NoSuchVertexException - if vertex is not a valid vertex identifier
  - removeEdgesOf
```
@Deprecated
default void removeEdgesOf(Integer vertex)
```
    Deprecated.
    
    Description copied from interface: Graph
    
    Remove all the edges of a vertex.
    
    Specified by:
    
    removeEdgesOf in interface Graph<Integer,Integer>
    
    Parameters:
    
    vertex - a vertex in the graph
  - removeOutEdgesOf
```
default void removeOutEdgesOf(int source)
```
    Remove all edges whose source is source.
    
    Parameters:
    
    source - a vertex in the graph
    
    Throws:
    
    NoSuchVertexException - if source is not a valid vertex identifier
  - removeOutEdgesOf
```
@Deprecated
default void removeOutEdgesOf(Integer vertex)
```
    Deprecated.
    
    Description copied from interface: Graph
    
    Remove all edges whose source is source.
    
    Specified by:
    
    removeOutEdgesOf in interface Graph<Integer,Integer>
    
    Parameters:
    
    vertex - a vertex in the graph
  - removeInEdgesOf
```
default void removeInEdgesOf(int target)
```
    Remove all edges whose target is target.
    
    Parameters:
    
    target - a vertex in the graph
    
    Throws:
    
    NoSuchVertexException - if target is not a valid vertex identifier
  - removeInEdgesOf
```
@Deprecated
default void removeInEdgesOf(Integer vertex)
```
    Deprecated.
    
    Description copied from interface: Graph
    
    Remove all edges whose target is target.
    
    Specified by:
    
    removeInEdgesOf in interface Graph<Integer,Integer>
    
    Parameters:
    
    vertex - a vertex in the graph
  - reverseEdge
```
void reverseEdge(int edge)
```
    Reverse an edge by switching its source and target.
    If the graph is undirected, this method does nothing.
    
    Parameters:
    
    edge - an existing edge in the graph
    
    Throws:
    
    NoSuchEdgeException - if edge is not a valid edge identifier
  - reverseEdge
```
@Deprecated
default void reverseEdge(Integer edge)
```
    Deprecated.
    
    Description copied from interface: Graph
    
    Reverse an edge by switching its source and target.
    If the graph is undirected, this method does nothing.
    
    Specified by:
    
    reverseEdge in interface Graph<Integer,Integer>
    
    Parameters:
    
    edge - an existing edge in the graph
  - edgeSource
```
int edgeSource(int edge)
```
    Get the source vertex of an edge.
    If the graph is undirected, this function return an arbitrary end-point of the edge, but always other end-point than edgeTarget(int) returns.
    
    Parameters:
    
    edge - the edge identifier
    
    Returns:
    
    the edge source vertex
    
    Throws:
    
    NoSuchEdgeException - if edge is not a valid edge identifier
  - edgeSource
```
@Deprecated
default Integer edgeSource(Integer edge)
```
    Deprecated.
    
    Description copied from interface: Graph
    
    Get the source vertex of an edge.
    If the graph is undirected, this function return an arbitrary end-point of the edge, but always other end-point than Graph.edgeTarget(Object) returns.
    
    Specified by:
    
    edgeSource in interface Graph<Integer,Integer>
    
    Parameters:
    
    edge - the edge identifier
    
    Returns:
    
    the edge source vertex
  - edgeTarget
```
int edgeTarget(int edge)
```
    Get the target vertex of an edge.
    If the graph is undirected, this function return an arbitrary end-point of the edge, but always the other end-point than edgeSource(int) returns.
    
    Parameters:
    
    edge - the edge identifier
    
    Returns:
    
    the edge target vertex
    
    Throws:
    
    NoSuchEdgeException - if edge is not a valid edge identifier
  - edgeTarget
```
@Deprecated
default Integer edgeTarget(Integer edge)
```
    Deprecated.
    
    Description copied from interface: Graph
    
    Get the target vertex of an edge.
    If the graph is undirected, this function return an arbitrary end-point of the edge, but always the other end-point than Graph.edgeSource(Object) returns.
    
    Specified by:
    
    edgeTarget in interface Graph<Integer,Integer>
    
    Parameters:
    
    edge - the edge identifier
    
    Returns:
    
    the edge target vertex
  - edgeEndpoint
```
default int edgeEndpoint(int edge,
                         int endpoint)
```
    Get the other end-point of an edge.
    Given an edge \((u,v)\) and a vertex \(w\), assuming \(w\) is an endpoint of the edge, namely that \(w\) is either \(u\) or \(v\), the method will return the other endpoint which is not \(w\). If \(w=u\) the method will return \(v\), if \(w=v\) the method will return \(u\).
    
    Parameters:
    
    edge - an edge identifier
    
    endpoint - one of the edge end-point
    
    Returns:
    
    the other end-point of the edge
    
    Throws:
    
    NoSuchEdgeException - if edge is not a valid edge identifier
    
    IllegalArgumentException - if endpoint is not an endpoint of the edge
  - edgeEndpoint
```
@Deprecated
default Integer edgeEndpoint(Integer edge,
                             Integer endpoint)
```
    Deprecated.
    
    Description copied from interface: Graph
    
    Get the other end-point of an edge.
    Given an edge \((u,v)\) and a vertex \(w\), assuming \(w\) is an endpoint of the edge, namely that \(w\) is either \(u\) or \(v\), the method will return the other endpoint which is not \(w\). If \(w=u\) the method will return \(v\), if \(w=v\) the method will return \(u\).
    
    Specified by:
    
    edgeEndpoint in interface Graph<Integer,Integer>
    
    Parameters:
    
    edge - an edge identifier
    
    endpoint - one of the edge end-point
    
    Returns:
    
    the other end-point of the edge
  - getVerticesIWeights
```
<T,WeightsT extends IWeights<T>> WeightsT getVerticesIWeights(String key)
```
    Get the vertices weights of some key.
    See IWeights for a complete documentation of the weights containers.
    
    Type Parameters:
    
    T - The weight data type
    
    WeightsT - the weights container, used to avoid casts of containers of primitive types such as IWeightsInt, IWeightsDouble ect.
    
    Parameters:
    
    key - key of the weights
    
    Returns:
    
    vertices weights of the key, or null if no container found with the specified key
  - getVerticesWeights
```
default <T,WeightsT extends Weights<Integer,T>> WeightsT getVerticesWeights(String key)
```
    Description copied from interface: Graph
    
    Get the vertices weights of some key.
    See Weights for a complete documentation of the weights containers.
    
    Specified by:
    
    getVerticesWeights in interface Graph<Integer,Integer>
    
    Type Parameters:
    
    T - The weight data type
    
    WeightsT - the weights container, used to avoid casts of containers of primitive types such as WeightsInt, WeightsDouble ect.
    
    Parameters:
    
    key - key of the weights
    
    Returns:
    
    vertices weights of the key, or null if no container found with the specified key
  - getEdgesIWeights
```
<T,WeightsT extends IWeights<T>> WeightsT getEdgesIWeights(String key)
```
    Get the edges weights of some key.
    See IWeights for a complete documentation of the weights containers.
    
    Type Parameters:
    
    T - The weight data type
    
    WeightsT - the weights container, used to avoid casts of containers of primitive types such as IWeightsInt, IWeightsDouble ect.
    
    Parameters:
    
    key - key of the weights
    
    Returns:
    
    edges weights of the key, or null if no container found with the specified key
  - getEdgesWeights
```
default <T,WeightsT extends Weights<Integer,T>> WeightsT getEdgesWeights(String key)
```
    Description copied from interface: Graph
    
    Get the edges weights of some key.
    See Weights for a complete documentation of the weights containers.
    
    Specified by:
    
    getEdgesWeights in interface Graph<Integer,Integer>
    
    Type Parameters:
    
    T - The weight data type
    
    WeightsT - the weights container, used to avoid casts of containers of primitive types such as WeightsInt, WeightsDouble ect.
    
    Parameters:
    
    key - key of the weights
    
    Returns:
    
    edges weights of the key, or null if no container found with the specified key
  - indexGraphVerticesMap
```
IndexIntIdMap indexGraphVerticesMap()
```
    Description copied from interface: Graph
    
    Get the index-id vertices mapping of this graph.
    A regular graph contains vertices and edges which are identified by a fixed int IDs. An IndexGraph view is provided by the Graph.indexGraph() method, which is a graph in which all methods are accessed with indices rather than fixed IDs. This method expose the mapping between the indices and the fixed IDs of the graph vertices.
    Note that the mapping may change during the graph lifetime, as vertices are added and removed from the graph, and a regular graph IDs are fixed, while a index graph indices are always (0,1,2, ...,verticesNum-1). The returned mapping object will be updated automatically in such cases.
    
    Specified by:
    
    indexGraphVerticesMap in interface Graph<Integer,Integer>
    
    Returns:
    
    a mapping that map vertices IDs to vertices indices
  - indexGraphEdgesMap
```
IndexIntIdMap indexGraphEdgesMap()
```
    Description copied from interface: Graph
    
    Get the index-id edges mapping of this graph.
    A regular graph contains vertices and edges which are identified by a fixed int IDs. An IndexGraph view is provided by the Graph.indexGraph() method, which is a graph in which all methods are accessed with indices rather than fixed IDs. This method expose the mapping between the indices and the fixed IDs of the graph edges.
    Note that the mapping may change during the graph lifetime, as edges are added and removed from the graph, and a regular graph IDs are fixed, while a index graph indices are always (0,1,2, ...,edgesNum-1). The returned mapping object will be updated automatically in such cases.
    
    Specified by:
    
    indexGraphEdgesMap in interface Graph<Integer,Integer>
    
    Returns:
    
    a mapping that map edges IDs to edges indices
  - copy
```
default IntGraph copy()
```
    Description copied from interface: Graph
    
    Create a copy of this graph, with the same vertices and edges, without copying weights.
    An identical copy of this graph will be created, with the same vertices, edges, capabilities (inclusive) such as self edges and parallel edges support, without copying the vertices/edges weights. The returned graph will always be modifiable, with no side affects on the original graph.
    
    Specified by:
    
    copy in interface Graph<Integer,Integer>
    
    Returns:
    
    an identical copy of this graph, with the same vertices and edges, without this graph weights
  - copy
```
default IntGraph copy(boolean copyWeights)
```
    Description copied from interface: Graph
    
    Create a copy of this graph, with the same vertices and edges, with/without copying weights.
    An identical copy of this graph will be created, with the same vertices, edges, capabilities (inclusive) such as self edges and parallel edges support, with/without copying the vertices/edges weights. The returned graph will always be modifiable, with no side affects on the original graph.
    Note that although g.equals(g.copy()) is always true if copyWeights is true, there is no guarantee that g.indexGraph().equals(g.copy().indexGraph()). Namely, when the graph is copied, new indices may be assigned to the vertices and edges.
    
    Specified by:
    
    copy in interface Graph<Integer,Integer>
    
    Parameters:
    
    copyWeights - if true, the weights of the vertices and edges will be copied to the new graph
    
    Returns:
    
    an identical copy of the given graph, with the same vertices and edges, with/without this graph weights
  - immutableCopy
```
default IntGraph immutableCopy()
```
    Description copied from interface: Graph
    
    Create an immutable copy of this graph, with the same vertices and edges, without copying weights.
    An identical copy of this graph will be created, with the same vertices and edges, without copying the vertices/edges weights. The returned graph will be immutable, and no vertices/edges/weights can be added or removed from it.
    A more compact and efficient representation may be used for the graph, if its known that it will not be changed in the future. It may be more efficient to create an immutable copy of a graph and pass the copy to algorithms instead of using the original graph.
    Note that although g.equals(g.immutableCopy()) is always true, there is no guarantee that g.indexGraph().equals(g.immutableCopy().indexGraph()). Namely, when the graph is copied, new indices may be assigned to the vertices and edges.
    
    Specified by:
    
    immutableCopy in interface Graph<Integer,Integer>
    
    Returns:
    
    an immutable copy of this graph, with the same vertices and edges, without this graph weights
  - immutableCopy
```
default IntGraph immutableCopy(boolean copyWeights)
```
    Description copied from interface: Graph
    
    Create an immutable copy of this graph, with the same vertices and edges, with/without copying weights.
    An identical copy of this graph will be created, with the same vertices and edges, with/without copying the vertices/edges weights. The returned graph will be immutable, and no vertices/edges/weights can be added or removed from it.
    A more compact and efficient representation may be used for the graph, if its known that it will not be changed in the future. It may be more efficient to create an immutable copy of a graph and pass the copy to algorithms instead of using the original graph.
    Note that although g.equals(g.immutableCopy()) is always true if copyWeights is true, there is no guarantee that g.indexGraph().equals(g.immutableCopy().indexGraph()). Namely, when the graph is copied, new indices may be assigned to the vertices and edges.
    
    Specified by:
    
    immutableCopy in interface Graph<Integer,Integer>
    
    Parameters:
    
    copyWeights - if true, the weights of the vertices and edges will be copied to the new graph
    
    Returns:
    
    an immutable copy of this graph, with the same vertices and edges, with/without this graph weights
  - immutableView
```
default IntGraph immutableView()
```
    Description copied from interface: Graph
    
    Get an immutable view of this graph.
    This method return a view of this graph, namely a Graph that contains the same vertices, edges and weights, that is automatically updated when the original graph is updated. The view is immutable, namely all operations that modify the graph will throw UnsupportedOperationException.
    
    Specified by:
    
    immutableView in interface Graph<Integer,Integer>
    
    Returns:
    
    an immutable view of this graph
  - reverseView
```
default IntGraph reverseView()
```
    Description copied from interface: Graph
    
    Get a reversed view of this graph.
    This method return a view of this graph, namely a Graph that contains the same vertices, edges and weights, that is automatically updated when the original graph is updated and vice versa. The view is reversed, namely each source and target vertices of each edge are swapped.
    Note that modifying the returned view will change the original graph.
    
    Specified by:
    
    reverseView in interface Graph<Integer,Integer>
    
    Returns:
    
    a reversed view of this graph
  - undirectedView
```
default IntGraph undirectedView()
```
    Description copied from interface: Graph
    
    Get an undirected view of this (directed) graph.
    This method return a view of this graph, namely a Graph that contains the same vertices, edges and weights, that is automatically updated when the original graph is updated and vice versa. The view is undirected, namely each directed edge \((u,v)\) will exist in all the sets g.outEdges(u), g.inEdges(u), g.outEdges(v) and g.inEdges(u). The view will contain the same number of edges as this graph.
    The returned view will return true for Graph.isAllowParallelEdges() even if the original graph does not support parallel edges. This is because the original graph could have both \((u,v)\) in \((v,u)\) without violating the parallel edges constraint, but the view will treat them as parallel edges as the direction is 'forgotten'.
    If this graph is undirected, this function return the graph itself.
    
    Specified by:
    
    undirectedView in interface Graph<Integer,Integer>
    
    Returns:
    
    an undirected view of this graph
  - subGraphCopy
```
default IntGraph subGraphCopy(Collection<Integer> vertices,
                              Collection<Integer> edges)
```
    Create a new graph that is a subgraph of this graph.
    If edges is null, then the created graph will be an induced subgraph of this graph, namely an induced subgraph of a graph \(G=(V,E)\) is a graph \(G'=(V',E')\) where \(V' \subseteq V\) and \(E' = \{\{u,v\} \mid u,v \in V', \{u,v\} \in E\}\). vertices must not be null in this case.
    If vertices is null, then edges must not be null, and the sub graph will contain all the vertices which are either a source or a target of an edge in edges.
    The created graph will have the same type (directed/undirected) as this graph. The vertices and edges of the created graph will be a subset of the vertices and edges of this graph.
    The weights of both vertices and edges will not be copied to the new sub graph. For more flexible sub graph creation, see Graphs.subGraph(Graph, Collection, Collection, boolean, boolean).
    Prefer to pass a IntCollection instead of Collection<Integer> as collections of vertices and edges.
    
    Specified by:
    
    subGraphCopy in interface Graph<Integer,Integer>
    
    Parameters:
    
    vertices - the vertices of the sub graph, if null then edges must not be null and the vertices of the sub graph will be all the vertices which are either a source or a target of an edge in edges
    
    edges - the edges of the sub graph, if null then vertices must not be null and the sub graph will be an induced subgraph of this graph
    
    Returns:
    
    a new graph that is a subgraph of this graph
  - newUndirected
```
static IntGraph newUndirected()
```
    Create a new undirected empty int graph.
    The returned graph will be implemented using the default implementation. For more control over the graph details, see IntGraphFactory.
    
    Returns:
    
    a new undirected empty graph
  - newDirected
```
static IntGraph newDirected()
```
    Create a new directed empty int graph.
    The returned graph will be implemented using the default implementation. For more control over the graph details, see IntGraphFactory.
    
    Returns:
    
    a new directed empty graph

Interface IntGraph

Method Summary

Methods inherited from interface com.jgalgo.graph.Graph

Method Detail

vertices

edges

addVertex

addVertex

addVertex

removeVertex

removeVertex

outEdges

outEdges

inEdges

inEdges

getEdge

getEdge

getEdges

getEdges

addEdge

addEdge

addEdge

removeEdge

removeEdge

removeEdgesOf

removeEdgesOf

removeOutEdgesOf

removeOutEdgesOf

removeInEdgesOf

removeInEdgesOf

reverseEdge

reverseEdge

edgeSource

edgeSource

edgeTarget

edgeTarget

edgeEndpoint

edgeEndpoint

getVerticesIWeights

getVerticesWeights

getEdgesIWeights

getEdgesWeights

indexGraphVerticesMap

indexGraphEdgesMap

copy

copy

immutableCopy

immutableCopy

immutableView

reverseView

undirectedView

subGraphCopy

newUndirected

newDirected