Graph

java.lang.Object
- java.util.Observable
- - cusack.hcg.graph.Graph

All Implemented Interfaces:

SimpleGraph
```
public class Graph
extends java.util.Observable
implements SimpleGraph
```
This class is used to hold a collection of vertices that can be mapped in such a way as to represent a graph with coordinates, edges, and lists of adjacent vertices. A graph can be either directed or undirected. There are not pairs of methods (add/remove edge, for instance)-- that is, one for undirected, one for directed. Instead the directedGraph flag will determine how the operations behave. TODO As of now, there is no real support for directed graphs. Most of the operations will work, but there is no way to set the flag right now (easy to do, but keep reading), and we do not have a file format for directed graphs yet. Need to deal with this in the future if we deal with any directed graph problems.

Author:

Jeff Largent, Ryan Alfuth, Updated by Chuck Cusack, January 2010.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`CLOSE_DISTANCE`
`static char`	`DIRECTED`
`static int`	`HORIZONTAL`
`static int`	`NORMAL_DISTANCE`
`static char`	`UNDIRECTED`
`static int`	`VERTICAL`

Constructor Summary

Constructors
Constructor and Description
`Graph()`
`Graph(Graph graph)` Deep copy constructor
`Graph(Graph newGraph)` This constructor creates a new Graph object from a database.Graph object

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addDoppelgangerVertex(int indexOfVertex, boolean connectDoppelToGanger)` Add a new vertex (the doppel) in the graph that is connected to all of the vertices that the indexOfVertex-th vertex (the ganger) is connected to.
`void`	`addDoppelgangerVertex(int indexOfVertex, int numberOfDoppels, boolean connectDoppelsToGanger)` Add a set of doppelganger vertices to a vertex in the graph.
`boolean`	`addEdge(Vertex v1, Vertex v2)` Adds an edge between two given vertices
`java.util.ArrayList<Edge>`	`addEdges(java.util.List<Edge> edges)` Adds edges to this graph from a given list
`Vertex`	`addNewVertex(java.awt.Point p)` Adds new vertex to the graph with coordinates given by the passed in Point
`void`	`addSubGraph(java.awt.Point offset, Graph subgraph)` Add subgraph to this graph, offset by the given point.
`void`	`addVertex(Vertex v)` Adds a vertex to this graph.
`java.util.ArrayList<Edge>`	`addVertexAndLink(Vertex toPaste, java.util.ArrayList<Vertex> toLink)`
`void`	`addVertices(java.util.List<Vertex> verts)` Adds all of the vertices in the list to this graph
`boolean`	`areThereMissingEdges()` A method to make sure an undirected graph was created properly.
`java.util.ArrayList<Edge>`	`connectAll(java.util.ArrayList<Vertex> verts)` This method creates edges between all the vertices that are passed in
`boolean`	`containsInducedSubgraph(Graph other)` Returns true if other other is a subgraph of this where other matches exactly within the subgraph of this.
`boolean`	`containsSubgraph(Graph other)` Returns true if other other is a subgraph of this
`Edge`	`convertEdge(SimpleEdge simpleEdge)` Convert the SimpleEdge to an Edge, whether or not it is actually in the graph.
`java.util.ArrayList<Edge>`	`convertEdges(java.util.ArrayList<SimpleEdge> simpleEdges)` Return an ArrayList of Edges equivalent to the SimpleEdges passed in.
`Graph`	`copyOfOriginalGraph()` Makes a copy from the state of the graph when it was initialized (including from copy constructors) or when makeCurrentStateInitialState() was called
`java.util.ArrayList<Vertex>`	`copySubgraph(java.util.ArrayList<Vertex> verts)` Creates a corresponding vertex for each given vertex and adds corresponding edges between them
`java.util.ArrayList<Edge>`	`disconnectAll(java.util.ArrayList<Vertex> verts)` This method removes edges between all the vertices that are passed in
`void`	`ensureAdjacencyConsistency()` For each edge in this graph make sure that the corresponding edge obtained by flipping the source and the destination vertices exists.
`void`	`fromAdjMatrix(int[][] adjMatrix, boolean isDirectedGraph)` Generates a graph from an already created int matrix.
`void`	`fromAdjMatrixString(java.lang.String adjMatrix, boolean isDirectedGraph)`
`void`	`fromString(java.lang.String adjList)` This method sets the adjacency list of all the vertices in the graph based on a string that is passed in.
`int`	`getDegree(int index)` The degree will be defined as the sum of the weights of the edges, including negative weights.
`DegreeSequence`	`getDegreeSequence()`
`int`	`getDiam()`
`java.util.ArrayList<Edge>`	`getEdges()`
`java.util.ArrayList<Edge>`	`getExistingEdges(java.util.ArrayList<Vertex> verts)` Create a list of edges that exist between the vertices that were passed in and makes those edges either directed or undirected depending on the boolean flag's value
`int`	`getGraphID()` This method returns the graph ID.
`java.lang.String`	`getGraphName()`
`static int`	`getGridsize()`
`java.lang.String`	`getInitialVertexCoords()` Returns a String that represents the initial coordinates of all of the vertices in this graph in the format 'x,y x2,y2' etc.
`int`	`getMaximumXCoordinate()` This method finds the vertex with the greatest x-value and then returns that value.
`int`	`getMaximumYCoordinate()` This method finds the vertex with the greatest y-value and then returns that value.
`int`	`getMinimumXCoordinate()` This method finds the vertex with the smallest x-value and then returns that value.
`int`	`getMinimumYCoordinate()` This method finds the vertex with the smallest y-value and then returns that value.
`java.util.ArrayList<Edge>`	`getMissingEdges()` Returns the edges that are not in the graph but the reverse edge is in the graph
`java.util.ArrayList<Edge>`	`getNonExistingEdges(java.util.ArrayList<Vertex> verts)` Given a list of vertices, finds all vertex pairs that do not have an edge between them
`int`	`getNumberOfEdges()` This method returns the number of edges in this graph between pairs of vertices.
`int`	`getNumberOfVertices()`
`int`	`getRadius()`
`java.awt.Point`	`getSubGraphLowerRightPoint(java.util.ArrayList<Vertex> list)` Find the smallest x and y values of this subgraph based on the vertices in the graph
`int[]`	`getSubgraphPermutation(Graph other)` Determine if the other graph is a subgraph of this graph.
`java.awt.Point`	`getSubGraphUpperLeftPoint(java.util.ArrayList<Vertex> list)` Find the smallest x and y values of this subgraph based on the vertices in the graph
`int`	`getUserID()`
`Vertex`	`getVertexAtIndex(int n)` This method returns the vertex at a specific index.
`java.lang.String`	`getVertexCoords()` This method gets the coordinates of all the vertices in this graph parsed into a string so that it can be stored in the database.
`java.util.ArrayList<Vertex>`	`getVertices()` This method returns a list of all the vertices in the current graph.
`int[]`	`getVerticesDistanceDiamApart()` Returns DistanceMatrix.getVerticesDistanceDiamApart
`void`	`grow()` Spreads out the entire graph.
`void`	`grow(java.util.ArrayList<Vertex> verticesToGrow)` Spreads out the passed in vertices
`void`	`horizontalFlip()` Translates the vertices in this graph by flipping them across the x axis
`void`	`horizontalFlip(java.util.ArrayList<Vertex> verts)` Translates the group of vertices that are passed in by flipping them across a line on the x axis
`int`	`indexOf(Vertex vertex)` This method checks to see what the numerical location of a specific vertex is.
`boolean`	`isAcyclic()`
`boolean`	`isAdjacent(Vertex v1, Vertex v2)` Given two vertices, checks whether or not there is an edge between them
`boolean`	`isCompleteGraph()` Checks whether or not this graph is a complete graph (each vertex is adjacent to all other vertices in the graph).
`boolean`	`isConnectedGraph()` Checks whether or not this graph is connected (any vertex can be reached from a source vertex traveling by edges in the graph)
`boolean`	`isDirectedGraph()`
`boolean`	`isEditable()`
`boolean`	`isSnapToGrid()`
`void`	`makeCurrentStateInitialState()` Makes the graph act as if the current data it has was the initial data it was given.
`int`	`nextTimestamp()`
`java.util.ArrayList<Edge>`	`pasteSubgraph(java.util.ArrayList<Vertex> verts, int translateX, int translateY)` This method adds the list of vertices that are passed in to the graph and creates the necessary edges between them.
`java.util.ArrayList<Edge>`	`pasteSubgraphAndLink(java.util.ArrayList<Vertex> toPaste, java.util.ArrayList<Vertex> toLink, int translateX, int translateY)`
`boolean`	`removeEdge(Vertex from, Vertex to)` Removes an edge from this graph if the given vertices are adjacent
`java.util.ArrayList<Edge>`	`removeEdges(java.util.List<Edge> edges)` Removes edges contained in the given list from this graph
`java.util.ArrayList<Edge>`	`removeSubgraph(java.util.List<Vertex> verts)` Remove all of these vertices and the associated edges between them and to other vertices that are still in the graph.
`java.util.ArrayList<java.awt.Point>`	`resetToInitialLocations(boolean notifyListeners)` This method forces all the vertices in this graph to return to their intial starting locations.
`void`	`setEditable(boolean editable)`
`void`	`setGraphID(int graphID)` This method sets the graph ID of this graph.
`void`	`setGraphName(java.lang.String graphName)`
`void`	`setSnapToGrid(boolean snapToGrid)`
`void`	`setUserID(int userID)`
`void`	`setVertexCoords(java.lang.String graphConfig, boolean theseAreInitialCoords)` This method sets the coordinates of all the vertices in the list of vertices based on a string that is passed in from the database.
`void`	`shrink()` Puts all the vertices in this graph closer together.
`void`	`shrink(java.util.ArrayList<Vertex> verticesToShrink)` Puts all the vertices in the passed in list closer together
`void`	`snapToGrid(Vertex vert)` Normalizes the locations of the passed in vertex For example, if the grid size is 10, then it will round to the 10s place: (53, 36) would be rounded to (50, 40)
`java.lang.String`	`toAdjacencyMatrixString()` Get the adjacency matrix in its string representation.
`java.lang.String`	`toString()` This method returns a string that contains all the vertices in the graphs's adjacency lists.
`void`	`translateGraph(java.awt.Point change)` This method translates all the vertices in this graph by point passed in.
`void`	`translateGraphCloseToHome()`
`java.awt.Point`	`translateGraphToHome()`
`boolean`	`translateVertex(Vertex vert, java.awt.Point change)` This method takes a vertex that passed in an shifts (not translates) the vertex by the x and y coordinates that are in the point that is passed in.
`void`	`translateVertices(java.util.ArrayList<Vertex> verts, java.util.ArrayList<java.awt.Point> changes)` Adds the offset in 'changes' to the corresponding (same index) vertex's location (in 'verts').
`void`	`translateVertices(java.util.ArrayList<Vertex> toTranslate, java.awt.Point change)` This method translates all the vertices in this graph by the two amounts that are passed in.
`void`	`unResetToInitialLocations(java.util.ArrayList<java.awt.Point> oldLocations)` This method sets all the vertices in this graph to the passed in locations.
`Vertex`	`vertexAt(java.awt.Point p, int widthRad, int heightRad)` Returns a vertex which is "near" p--within a small threshold.
`boolean`	`vertexCoordsChanged()` Returns true if at least one of the vertices in this graph have been moved from their initial coordinates
`void`	`verticalFlip()` Translates the vertices in this graph by flipping them across the y axis
`void`	`verticalFlip(java.util.ArrayList<Vertex> verts)` Translates the group of vertices that are passed in by flipping them across a line on the y axis
`void`	`xyFlip()` Translates the vertices in this graph by flipping them across the line y=x
`void`	`xyFlip(java.util.ArrayList<Vertex> verts)` Translates the group of vertices that are passed in by flipping them across the line y=x

Methods inherited from class java.util.Observable
addObserver, countObservers, deleteObserver, deleteObservers, hasChanged, notifyObservers, notifyObservers

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

- Field Detail
  - HORIZONTAL
```
public static final int HORIZONTAL
```
    See Also:
    
    Constant Field Values
  - VERTICAL
```
public static final int VERTICAL
```
    See Also:
    
    Constant Field Values
  - CLOSE_DISTANCE
```
public static final int CLOSE_DISTANCE
```
    See Also:
    
    Constant Field Values
  - NORMAL_DISTANCE
```
public static final int NORMAL_DISTANCE
```
    See Also:
    
    Constant Field Values
  - UNDIRECTED
```
public static final char UNDIRECTED
```
    See Also:
    
    Constant Field Values
  - DIRECTED
```
public static final char DIRECTED
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - Graph
```
public Graph()
```
  - Graph
```
public Graph(Graph graph)
```
    Deep copy constructor
    
    Parameters:
    
    graph - The Graph to make the deep copy from
  - Graph
```
public Graph(Graph newGraph)
```
    This constructor creates a new Graph object from a database.Graph object
    
    Parameters:
    
    newGraph - The database.Graph object to be passed in
- Method Detail
  - copyOfOriginalGraph
```
public Graph copyOfOriginalGraph()
```
    Makes a copy from the state of the graph when it was initialized (including from copy constructors) or when makeCurrentStateInitialState() was called
    
    Returns:
    
    A Graph object based on whatever is considered the initial state of this graph.
  - makeCurrentStateInitialState
```
public void makeCurrentStateInitialState()
```
    Makes the graph act as if the current data it has was the initial data it was given.
  - fromString
```
public void fromString(java.lang.String adjList)
```
    This method sets the adjacency list of all the vertices in the graph based on a string that is passed in.
    
    Parameters:
    
    adjList - The adjacency list from the database
  - fromAdjMatrix
```
public void fromAdjMatrix(int[][] adjMatrix,
                          boolean isDirectedGraph)
```
    Generates a graph from an already created int matrix. mark.powers - 6/23/2017
  - fromAdjMatrixString
```
public void fromAdjMatrixString(java.lang.String adjMatrix,
                                boolean isDirectedGraph)
```
  - toString
```
public java.lang.String toString()
```
    This method returns a string that contains all the vertices in the graphs's adjacency lists.
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    
    The string that can be stored in the database as a list of all adjacent vertices
  - nextTimestamp
```
public int nextTimestamp()
```
  - getGraphName
```
public java.lang.String getGraphName()
```
  - addNewVertex
```
public Vertex addNewVertex(java.awt.Point p)
```
    Adds new vertex to the graph with coordinates given by the passed in Point
    
    Parameters:
    
    p - 2-Dimensional coordinates representing where the new vertex is added
    
    Returns:
    
    The new vertex that was created
  - addVertex
```
public void addVertex(Vertex v)
```
    Adds a vertex to this graph.
    
    Parameters:
    
    v - The vertex to be added to this graph
  - addVertices
```
public void addVertices(java.util.List<Vertex> verts)
```
    Adds all of the vertices in the list to this graph
    
    Parameters:
    
    verts - The list of vertices to add to the graph
  - addEdge
```
public boolean addEdge(Vertex v1,
                       Vertex v2)
```
    Adds an edge between two given vertices
    
    Parameters:
    
    v1 - The source vertex of the edge
    
    v2 - The destination vertex of the edge
    
    Returns:
    
    True if the edge is added and false if the edge already exists
  - removeEdge
```
public boolean removeEdge(Vertex from,
                          Vertex to)
```
    Removes an edge from this graph if the given vertices are adjacent
    
    Parameters:
    
    from - The source vertex of the edge
    
    to - The destination vertex of the edge
    
    Returns:
    
    True if the edge is removed or false if this graph does not contain the edge specified
  - addEdges
```
public java.util.ArrayList<Edge> addEdges(java.util.List<Edge> edges)
```
    Adds edges to this graph from a given list
    
    Parameters:
    
    edges - A list of edges to be added to this graph
    
    Returns:
    
    the list of edges that were really added (because they weren't there), or an empty list if none were added.
  - removeEdges
```
public java.util.ArrayList<Edge> removeEdges(java.util.List<Edge> edges)
```
    Removes edges contained in the given list from this graph
    
    Parameters:
    
    edges - The edges to remove
    
    Returns:
    
    The list of edges that were really removed (because they were in the graph), or an empty list if none were removed
  - addSubGraph
```
public void addSubGraph(java.awt.Point offset,
                        Graph subgraph)
```
    Add subgraph to this graph, offset by the given point. It is assumed that this subgraph is not connected to the current graph in any way. This method does not make a copy of the vertices from the given subgraph. Instead, it adds these vertices to this graph directly.
    
    Parameters:
    
    offset - The values that are added to the coordinates of the vertices of the subgraph before they are added to this graph. For example, if a vertex is at (4,5) in the original subgraph and the offset is (2,3), then the corresponding vertex added to this graph will be at the point (6,8).
    
    subgraph - A graph whose vertices and edges are added to this graph
  - removeSubgraph
```
public java.util.ArrayList<Edge> removeSubgraph(java.util.List<Vertex> verts)
```
    Remove all of these vertices and the associated edges between them and to other vertices that are still in the graph. Return a list of all edges removed, including those with edges involving a vertex from the subgraph to be removed and this graph as a whole.
    
    Parameters:
    
    verts - A list of the vertices of the subgraph to remove
    
    Returns:
    
    A list of the edges removed from this graph. This includes both edges between 2 vertices in the subgraph and edges with one vertex in the subgraph and one in this graph.
  - getEdges
```
public java.util.ArrayList<Edge> getEdges()
```
  - connectAll
```
public java.util.ArrayList<Edge> connectAll(java.util.ArrayList<Vertex> verts)
```
    This method creates edges between all the vertices that are passed in
    
    Parameters:
    
    verts - The vertices that need to have edges created between them
    
    Returns:
    
    A list of edges that were added to this graph
  - disconnectAll
```
public java.util.ArrayList<Edge> disconnectAll(java.util.ArrayList<Vertex> verts)
```
    This method removes edges between all the vertices that are passed in
    
    Parameters:
    
    verts - The vertices that need to have edges removed between them
    
    Returns:
    
    A list of edges that were removed from this graph
  - horizontalFlip
```
public void horizontalFlip()
```
    Translates the vertices in this graph by flipping them across the x axis
  - verticalFlip
```
public void verticalFlip()
```
    Translates the vertices in this graph by flipping them across the y axis
  - xyFlip
```
public void xyFlip()
```
    Translates the vertices in this graph by flipping them across the line y=x
  - horizontalFlip
```
public void horizontalFlip(java.util.ArrayList<Vertex> verts)
```
    Translates the group of vertices that are passed in by flipping them across a line on the x axis
    
    Parameters:
    
    verts - The list of vertices to be translated
  - verticalFlip
```
public void verticalFlip(java.util.ArrayList<Vertex> verts)
```
    Translates the group of vertices that are passed in by flipping them across a line on the y axis
    
    Parameters:
    
    verts - The list of vertices to be translated
  - xyFlip
```
public void xyFlip(java.util.ArrayList<Vertex> verts)
```
    Translates the group of vertices that are passed in by flipping them across the line y=x
    
    Parameters:
    
    verts - The list of vertices to be translated
  - copySubgraph
```
public java.util.ArrayList<Vertex> copySubgraph(java.util.ArrayList<Vertex> verts)
```
    Creates a corresponding vertex for each given vertex and adds corresponding edges between them
    
    Parameters:
    
    verts - The list of vertices to be copied
    
    Returns:
    
    A list containing the copied vertices
  - pasteSubgraph
```
public java.util.ArrayList<Edge> pasteSubgraph(java.util.ArrayList<Vertex> verts,
                                               int translateX,
                                               int translateY)
```
    This method adds the list of vertices that are passed in to the graph and creates the necessary edges between them.
    
    Parameters:
    
    verts - The list of vertices to be added to the graph
  - addVertexAndLink
```
public java.util.ArrayList<Edge> addVertexAndLink(Vertex toPaste,
                                                  java.util.ArrayList<Vertex> toLink)
```
  - pasteSubgraphAndLink
```
public java.util.ArrayList<Edge> pasteSubgraphAndLink(java.util.ArrayList<Vertex> toPaste,
                                                      java.util.ArrayList<Vertex> toLink,
                                                      int translateX,
                                                      int translateY)
```
  - getExistingEdges
```
public java.util.ArrayList<Edge> getExistingEdges(java.util.ArrayList<Vertex> verts)
```
    Create a list of edges that exist between the vertices that were passed in and makes those edges either directed or undirected depending on the boolean flag's value
    
    Parameters:
    
    verts - The vertices that will be used to generate the list of edges
    
    edgeExists - If true this method will return the edges that exist. False, the edges that could, but don't
    
    isDirected - Determines whether or not the edges will be directed or undirected
    
    Returns:
    
    The list of edges that were created
  - getNonExistingEdges
```
public java.util.ArrayList<Edge> getNonExistingEdges(java.util.ArrayList<Vertex> verts)
```
    Given a list of vertices, finds all vertex pairs that do not have an edge between them
    
    Parameters:
    
    verts - The list of vertices that will be used to determine what the possible edges that will be returned are
    
    Returns:
    
    A list of edges between the given vertices that are not in this graph
  - isAdjacent
```
public boolean isAdjacent(Vertex v1,
                          Vertex v2)
```
    Given two vertices, checks whether or not there is an edge between them
    
    Parameters:
    
    v1 - The source vertex
    
    v2 - The destination vertex
    
    Returns:
    
    True if there is an edge between the two vertices
  - indexOf
```
public int indexOf(Vertex vertex)
```
    This method checks to see what the numerical location of a specific vertex is.
    
    Parameters:
    
    vertex - The vertex to check
    
    Returns:
    
    The vertex's location, -1 if it is not in the graph.
  - getVertexAtIndex
```
public Vertex getVertexAtIndex(int n)
```
    This method returns the vertex at a specific index.
    
    Parameters:
    
    n - The index at which the vertex is expected to be found
    
    Returns:
    
    The vertex that was found at the specified vertex or null if there is no vertex with the specified index.
  - getVertices
```
public java.util.ArrayList<Vertex> getVertices()
```
    This method returns a list of all the vertices in the current graph.
    
    Returns:
    
    A list of all the vertices in this graph
  - getNumberOfVertices
```
public int getNumberOfVertices()
```
    Specified by:
    
    getNumberOfVertices in interface SimpleGraph
  - getNumberOfEdges
```
public int getNumberOfEdges()
```
    This method returns the number of edges in this graph between pairs of vertices.
    
    Specified by:
    
    getNumberOfEdges in interface SimpleGraph
    
    Returns:
    
    The number of edges in this graph
  - isCompleteGraph
```
public boolean isCompleteGraph()
```
    Checks whether or not this graph is a complete graph (each vertex is adjacent to all other vertices in the graph).
    
    Returns:
    
    True if all possible edges are in the graph, assuming it is NOT a multigraph, and false otherwise
  - isConnectedGraph
```
public boolean isConnectedGraph()
```
    Checks whether or not this graph is connected (any vertex can be reached from a source vertex traveling by edges in the graph)
    
    Returns:
    
    True if the graph is connected, and false otherwise.
  - ensureAdjacencyConsistency
```
public void ensureAdjacencyConsistency()
```
    For each edge in this graph make sure that the corresponding edge obtained by flipping the source and the destination vertices exists. If not, this method adds it.
  - getUserID
```
public int getUserID()
```
    Returns:
    
    the userID
  - setUserID
```
public void setUserID(int userID)
```
    Parameters:
    
    userID - the userID to set
  - translateVertices
```
public void translateVertices(java.util.ArrayList<Vertex> verts,
                              java.util.ArrayList<java.awt.Point> changes)
```
    Adds the offset in 'changes' to the corresponding (same index) vertex's location (in 'verts').
    
    Parameters:
    
    verts - A list of vertices to be shifted
    
    changes - A list of points. Their x and y values are added to the corresponding vertex's coordinates
  - translateVertex
```
public boolean translateVertex(Vertex vert,
                               java.awt.Point change)
```
    This method takes a vertex that passed in an *shifts* (not translates) the vertex by the x and y coordinates that are in the point that is passed in. The point that is passed in will not become the new point that the vertex is located at.
    
    Parameters:
    
    vert - The vertex to move
    
    change - The Point that holds the amount to shift this vertex by
    
    Returns:
    
    Whether or not the translation was successful
  - translateVertices
```
public void translateVertices(java.util.ArrayList<Vertex> toTranslate,
                              java.awt.Point change)
```
    This method translates all the vertices in this graph by the two amounts that are passed in. Same as the next one but this one sends a notification so it can be recorded and undone.
    
    Parameters:
    
    edges - The list of vertices to translate
    
    xAmount - The amount to move them horizontally
    
    yAmount - The amount to move them vertically
  - translateGraph
```
public void translateGraph(java.awt.Point change)
```
    This method translates all the vertices in this graph by point passed in. If this would take it to the left or top of screen, don't move in that direction. Since this moves the whole graph, we do not notify listeners because we don't ultimately save relative positions of the whole graph anyway.
  - translateGraphToHome
```
public java.awt.Point translateGraphToHome()
```
  - translateGraphCloseToHome
```
public void translateGraphCloseToHome()
```
  - grow
```
public void grow()
```
    Spreads out the entire graph.
  - grow
```
public void grow(java.util.ArrayList<Vertex> verticesToGrow)
```
    Spreads out the passed in vertices
    
    Parameters:
    
    verticesToGrow - The vertices to spread out
  - shrink
```
public void shrink()
```
    Puts all the vertices in this graph closer together.
  - shrink
```
public void shrink(java.util.ArrayList<Vertex> verticesToShrink)
```
    Puts all the vertices in the passed in list closer together
    
    Parameters:
    
    verticesToShrink - The vertices to be put closer together.
  - isDirectedGraph
```
public boolean isDirectedGraph()
```
  - getGraphID
```
public int getGraphID()
```
    This method returns the graph ID.
    
    Returns:
    
    int The ID of this graph
  - setGraphID
```
public void setGraphID(int graphID)
```
    This method sets the graph ID of this graph.
    
    Parameters:
    
    graphID - The int value that will be set as the graph ID
  - setGraphName
```
public void setGraphName(java.lang.String graphName)
```
  - setVertexCoords
```
public void setVertexCoords(java.lang.String graphConfig,
                            boolean theseAreInitialCoords)
```
    This method sets the coordinates of all the vertices in the list of vertices based on a string that is passed in from the database.
    
    Parameters:
    
    graphConfig - The string that contains all the coordinate information
  - vertexCoordsChanged
```
public boolean vertexCoordsChanged()
```
    Returns true if at least one of the vertices in this graph have been moved from their initial coordinates
    
    Returns:
    
    True if at least one vertex has been moved. False otherwise.
  - getVertexCoords
```
public java.lang.String getVertexCoords()
```
    This method gets the coordinates of all the vertices in this graph parsed into a string so that it can be stored in the database.
    
    Returns:
    
    String The string that will allow this graph to be stored in the database
  - getInitialVertexCoords
```
public java.lang.String getInitialVertexCoords()
```
    Returns a String that represents the initial coordinates of all of the vertices in this graph in the format 'x,y x2,y2' etc.
    
    Returns:
    
    A String that represents the initial coordinates of all of the vertices in this graph
  - vertexAt
```
public Vertex vertexAt(java.awt.Point p,
                       int widthRad,
                       int heightRad)
```
    Returns a vertex which is "near" p--within a small threshold. Returns null if none are near enough.
    
    Parameters:
    
    p - The center of the area that is searched for a vertex
    
    widthRad - Distance from the center that the x value of a vertex is allowed to differ and still be selected
    
    heightRad - Distance from the center that the y value of a vertex is allowed to differ and still be selected
    
    Returns:
    
    The vertex with the lowest index that is within the specified threshold
  - getGridsize
```
public static int getGridsize()
```
    Returns:
    
    the gridsize
  - isSnapToGrid
```
public boolean isSnapToGrid()
```
    Returns:
    
    the snapToGrid
  - setSnapToGrid
```
public void setSnapToGrid(boolean snapToGrid)
```
    Parameters:
    
    snapToGrid - the snapToGrid to set
  - snapToGrid
```
public void snapToGrid(Vertex vert)
```
    Normalizes the locations of the passed in vertex For example, if the grid size is 10, then it will round to the 10s place: (53, 36) would be rounded to (50, 40)
    
    Parameters:
    
    vert -
  - isEditable
```
public boolean isEditable()
```
  - setEditable
```
public void setEditable(boolean editable)
```
  - resetToInitialLocations
```
public java.util.ArrayList<java.awt.Point> resetToInitialLocations(boolean notifyListeners)
```
    This method forces all the vertices in this graph to return to their intial starting locations.
    
    Parameters:
    
    notifyListeners - TODO
  - unResetToInitialLocations
```
public void unResetToInitialLocations(java.util.ArrayList<java.awt.Point> oldLocations)
```
    This method sets all the vertices in this graph to the passed in locations.
    
    Parameters:
    
    oldLocations - The locations that the points are moved to
  - getMinimumYCoordinate
```
public int getMinimumYCoordinate()
```
    This method finds the vertex with the smallest y-value and then returns that value.
    
    Returns:
    
    The smallest y-value
  - getMaximumYCoordinate
```
public int getMaximumYCoordinate()
```
    This method finds the vertex with the greatest y-value and then returns that value.
    
    Returns:
    
    The greatest y-value
  - getMinimumXCoordinate
```
public int getMinimumXCoordinate()
```
    This method finds the vertex with the smallest x-value and then returns that value.
    
    Returns:
    
    int The smallest x-value of all vertices
  - getMaximumXCoordinate
```
public int getMaximumXCoordinate()
```
    This method finds the vertex with the greatest x-value and then returns that value.
    
    Returns:
    
    int The greatest x-value
  - getSubGraphUpperLeftPoint
```
public java.awt.Point getSubGraphUpperLeftPoint(java.util.ArrayList<Vertex> list)
```
    Find the smallest x and y values of this subgraph based on the vertices in the graph
    
    Parameters:
    
    list - The subgraph to check
    
    Returns:
    
    The point that contains the least x and y values in the graph
  - getSubGraphLowerRightPoint
```
public java.awt.Point getSubGraphLowerRightPoint(java.util.ArrayList<Vertex> list)
```
    Find the smallest x and y values of this subgraph based on the vertices in the graph
    
    Parameters:
    
    list - The subgraph to check
    
    Returns:
    
    The point that contains the least x and y values in the graph
  - areThereMissingEdges
```
public boolean areThereMissingEdges()
```
    A method to make sure an undirected graph was created properly.
    
    Returns:
    
    True if for each edge, the reverse edge also exists. False if the graph is directed or if the reverse edge does not exist for every edge
  - getMissingEdges
```
public java.util.ArrayList<Edge> getMissingEdges()
```
    Returns the edges that are not in the graph but the reverse edge is in the graph
    
    Returns:
    
    The edges that are not in the graph but the reverse edge is in the graph
  - getDegree
```
public int getDegree(int index)
```
    The degree will be defined as the sum of the weights of the edges, including negative weights. This may be a bad thing, but so be it.
    
    Specified by:
    
    getDegree in interface SimpleGraph
    
    Parameters:
    
    index - Index of the vertex whose degree we want to check
    
    Returns:
    
    The degree of the specified vertex
  - getSubgraphPermutation
```
public int[] getSubgraphPermutation(Graph other)
```
    Determine if the other graph is a subgraph of this graph. This is the naive algorithm that is not at all efficient so it should not be used on large graphs.
    
    Parameters:
    
    other - the potential subgraph
    
    Returns:
    
    a permuation p, where p[i] is the index in this graph that vertex i in other relates to, null if otherwise
  - containsSubgraph
```
public boolean containsSubgraph(Graph other)
```
    Returns true if other other is a subgraph of this
  - containsInducedSubgraph
```
public boolean containsInducedSubgraph(Graph other)
```
    Returns true if other other is a subgraph of this where other matches exactly within the subgraph of this. That is, no extra edges between corresponding nodes in the subgraph exist.
  - getDiam
```
public int getDiam()
```
  - getVerticesDistanceDiamApart
```
public int[] getVerticesDistanceDiamApart()
```
    Returns DistanceMatrix.getVerticesDistanceDiamApart
    
    Returns:
    
    An array of 2 vertices distance diam(G) apart
  - getRadius
```
public int getRadius()
```
  - isAcyclic
```
public boolean isAcyclic()
```
  - getDegreeSequence
```
public DegreeSequence getDegreeSequence()
```
    Specified by:
    
    getDegreeSequence in interface SimpleGraph
  - convertEdges
```
public java.util.ArrayList<Edge> convertEdges(java.util.ArrayList<SimpleEdge> simpleEdges)
```
    Return an ArrayList of Edges equivalent to the SimpleEdges passed in. If a SimpleEdge does not occur, do not include it in the returned list. (So the returned list might be shorter.)
    
    Parameters:
    
    simpleEdges - A list of Simple Edges to be converted
    
    Returns:
    
    The converted edges
  - convertEdge
```
public Edge convertEdge(SimpleEdge simpleEdge)
```
    Convert the SimpleEdge to an Edge, whether or not it is actually in the graph.
  - toAdjacencyMatrixString
```
public java.lang.String toAdjacencyMatrixString()
```
    Get the adjacency matrix in its string representation.
    
    Returns:
    
    A string representing the adjacency matrix for this graph.
  - addDoppelgangerVertex
```
public void addDoppelgangerVertex(int indexOfVertex,
                                  boolean connectDoppelToGanger)
```
    Add a new vertex (the doppel) in the graph that is connected to all of the vertices that the indexOfVertex-th vertex (the ganger) is connected to. Also connect the doppel to the ganger if connectDoppelToGanger is true.
    
    Parameters:
    
    indexOfVertex -
    
    connectDoppelToGanger -
  - addDoppelgangerVertex
```
public void addDoppelgangerVertex(int indexOfVertex,
                                  int numberOfDoppels,
                                  boolean connectDoppelsToGanger)
```
    Add a set of doppelganger vertices to a vertex in the graph. If connectDoppelstoGanger is true, all doppels will be connected to each other and the ganger. Otherwise they will not be connected to each other or to the ganger.
    
    Parameters:
    
    indexOfVertex -
    
    numberOfDoppels -
    
    connectDoppelsToGanger -

Class Graph

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.util.Observable

Methods inherited from class java.lang.Object

Field Detail

HORIZONTAL

VERTICAL

CLOSE_DISTANCE

NORMAL_DISTANCE

UNDIRECTED

DIRECTED

Constructor Detail

Graph

Graph

Graph

Method Detail

copyOfOriginalGraph

makeCurrentStateInitialState

fromString

fromAdjMatrix

fromAdjMatrixString

toString

nextTimestamp

getGraphName

addNewVertex

addVertex

addVertices

addEdge

removeEdge

addEdges

removeEdges

addSubGraph

removeSubgraph

getEdges

connectAll

disconnectAll

horizontalFlip

verticalFlip

xyFlip

horizontalFlip

verticalFlip

xyFlip

copySubgraph

pasteSubgraph

addVertexAndLink

pasteSubgraphAndLink

getExistingEdges

getNonExistingEdges

isAdjacent

indexOf

getVertexAtIndex

getVertices

getNumberOfVertices

getNumberOfEdges

isCompleteGraph

isConnectedGraph

ensureAdjacencyConsistency

getUserID

setUserID

translateVertices

translateVertex

translateVertices

translateGraph

translateGraphToHome

translateGraphCloseToHome

grow

grow

shrink

shrink

isDirectedGraph

getGraphID

setGraphID

setGraphName

setVertexCoords

vertexCoordsChanged

getVertexCoords

getInitialVertexCoords

vertexAt