Graphs/Guava - Revision history

Admin: Replacing charlesreid1.com:3000 with git.charlesreid1.com

2019-10-09T03:26:35Z

Replacing charlesreid1.com:3000 with git.charlesreid1.com

← Older revision		Revision as of 03:26, 9 October 2019
Line 45:		Line 45:
	The Traveling Salesperson Problem repository on http://git.charlesreid1.com provides an example of how to construct a MutableNetwork, and then turn the MutableNetwork into an ImmutableNetwork.		The Traveling Salesperson Problem repository on http://git.charlesreid1.com provides an example of how to construct a MutableNetwork, and then turn the MutableNetwork into an ImmutableNetwork.

	The key line is here: https://charlesreid1.com~~:3000~~/charlesreid1/hello-data-structures/src/master/java/guava/TSP.java#L101		The key line is here: https://git.charlesreid1.com/charlesreid1/hello-data-structures/src/master/java/guava/TSP.java#L101

	The method that constructs the graph and returns an ImmutableNetwork object is reproduced below:		The method that constructs the graph and returns an ImmutableNetwork object is reproduced below:
Line 100:		Line 100:
	==Useful Links==		==Useful Links==

	Traveling Salesperson Problem in Guava: https://charlesreid1.com~~:3000~~/charlesreid1/hello-data-structures/src/master/java/guava/TSP.java		Traveling Salesperson Problem in Guava: https://git.charlesreid1.com/charlesreid1/hello-data-structures/src/master/java/guava/TSP.java

	Graphs Explained: Google Guava Github Wiki: https://github.com/google/guava/wiki/GraphsExplained		Graphs Explained: Google Guava Github Wiki: https://github.com/google/guava/wiki/GraphsExplained

Admin: /* Flags */

2017-08-22T01:26:10Z

Flags

@@ Line 97: / Line 97: @@
+	}
 </pre>
 ==Flags==

Admin: /* Building Graphs */

2017-08-22T01:05:27Z

Building Graphs

← Older revision		Revision as of 01:05, 22 August 2017
Line 41:		Line 41:
	</pre>		</pre>

			===Example===

			The Traveling Salesperson Problem repository on http://git.charlesreid1.com provides an example of how to construct a MutableNetwork, and then turn the MutableNetwork into an ImmutableNetwork.

			The key line is here: https://charlesreid1.com:3000/charlesreid1/hello-data-structures/src/master/java/guava/TSP.java#L101

			The method that constructs the graph and returns an ImmutableNetwork object is reproduced below:

			<pre>
			/** This method actually constructs the graph. */
			public ImmutableNetwork<Node,Edge> buildGraph() {
			/** Make a NetworkBuilder object for an undirected network and call build().
			*
			* https://github.com/google/guava/wiki/GraphsExplained#building-graph-instances
			*/

			// MutableNetwork is an interface requiring a type for nodes and a type for edges
			MutableNetwork<Node,Edge> roads = NetworkBuilder.undirected().build();

			// Construct a dictionary of nodes (cities)
			String[] cities = {"A","B","C","D","E"};
			Map<String,Node> all_nodes = new TreeMap<String,Node>();
			for(int i = 0; i<cities.length; i++) {
			Node node = new Node(cities[i]);
			all_nodes.put(cities[i], node);

			// Add the nodes to the network
			roads.addNode(node);
			}

			// Construct Edges for roads,
			// and add them to a map
			String[] distances = {"A:B:24","A:C:5","A:D:20","A:E:18","B:C:10","B:D:20","C:D:4","C:E:28","D:E:3"};
			Map<String,Edge> all_edges = new TreeMap<String,Edge>();
			for(int j = 0; j<distances.length; j++) {
			// Parse out (city1):(city2):(distance)
			String[] splitresult = distances[j].split(":");
			String left = splitresult[0];
			String right = splitresult[1];
			String label = left + ":" + right;
			int value = Integer.parseInt(splitresult[2]);

			// Add edges to map
			Edge edge = new Edge(left, right, value);
			all_edges.put(label, edge);

			// Add edges to network
			roads.addEdge(all_nodes.get(edge.left), all_nodes.get(edge.right), edge);
			}

			// Freeze the network
			ImmutableNetwork<Node,Edge> frozen_roads = ImmutableNetwork.copyOf(roads);

			return frozen_roads;
			}
			</pre>

	==Flags==		==Flags==

Admin: /* Mutability and Immutability */

2017-08-22T01:03:19Z

Mutability and Immutability

← Older revision		Revision as of 01:03, 22 August 2017
Line 17:		Line 17:

	The Guava FAQ recommends enforcing that any objects stored in the nodes or edges of an immutable graph are themselves immutable - otherwise you have a nominally "immutable" graph but in reality the elements being wrapped by the graph can be modified at will. This is not a deeply immutable graph.		The Guava FAQ recommends enforcing that any objects stored in the nodes or edges of an immutable graph are themselves immutable - otherwise you have a nominally "immutable" graph but in reality the elements being wrapped by the graph can be modified at will. This is not a deeply immutable graph.

			Immutable types can guarantee the following:
			* shallow immutability
			* deterministic iteration (consistent iteration order)
			* thread safety (safe to access graph concurrently from multiple threads)
			* integrity (it is not possible to subclass the Immutable types in a way that would violate these guarantees)

	==Building Graphs==		==Building Graphs==

Admin: /* Immutability */

2017-08-22T01:01:59Z

Immutability

← Older revision		Revision as of 01:01, 22 August 2017
Line 14:		Line 14:
	* Network is a type of graph that treats all edges as formal first-clsas types, just like nodes; this enables parallel edges with arbitrary objects.		* Network is a type of graph that treats all edges as formal first-clsas types, just like nodes; this enables parallel edges with arbitrary objects.

	===Immutability===		===Mutability and Immutability===

	The Guava FAQ recommends enforcing that any objects stored in the nodes or edges of an immutable graph are themselves immutable - otherwise you have a nominally "immutable" graph but in reality the elements being wrapped by the graph can be modified at will. This is not a deeply immutable graph.		The Guava FAQ recommends enforcing that any objects stored in the nodes or edges of an immutable graph are themselves immutable - otherwise you have a nominally "immutable" graph but in reality the elements being wrapped by the graph can be modified at will. This is not a deeply immutable graph.

Admin at 01:01, 22 August 2017

2017-08-22T01:01:40Z

← Older revision		Revision as of 01:01, 22 August 2017
Line 34:		Line 34:
	ImmutableGraph<Integer> immutableGraph = ImmutableGraph.copyOf(graph);		ImmutableGraph<Integer> immutableGraph = ImmutableGraph.copyOf(graph);
	</pre>		</pre>



			==Flags==

			{{GraphsFlag}}

			{{CSFlag}}

			[[Category:Java]]
			[[Category:Guava]]
			[[Category:Graphs]]
			[[Category:CS]]

Admin at 01:00, 22 August 2017

2017-08-22T01:00:43Z

@@ Line 1: / Line 1: @@
 {{Main|Guava}}
 Guava implements high performance data containers for Java. There are a number of things to be aware of when dealing with Guava Graphs. Most of these notes are taken from the Guava wiki on Github: https://github.com/google/guava/wiki/GraphsExplained#building-graph-instances
@@ Line 11: / Line 13: @@
 * ValueGraph is a graph where edges store a value (the value does not need to be unique); the value associated with the edge is (maybe??) of arbitrary type. The edges are stored as a map from a pair of vertices to a value.
 * Network is a type of graph that treats all edges as formal first-clsas types, just like nodes; this enables parallel edges with arbitrary objects.

Admin at 00:53, 22 August 2017

2017-08-22T00:53:29Z

← Older revision		Revision as of 00:53, 22 August 2017
Line 1:		Line 1:
	{{Main\|Guava}}		{{Main\|Guava}}

	Guava implements high performance data containers for Java.		Guava implements high performance data containers for Java. There are a number of things to be aware of when dealing with Guava Graphs. Most of these notes are taken from the Guava wiki on Github: https://github.com/google/guava/wiki/GraphsExplained#building-graph-instances

			First, Guava Graphs should be thought of as extensions of the Java Collections types; they are not intended to scale to massive graphs, nor do they provide any specialized functionality (e.g., visualization). That is separate functionality to be implemented in separate libraries.

			Next, there are two major classes of graphs in Guava: mutable and immutable.

			There are three types of graphs available: <code>Graph</code>, <code>ValueGraph</code>, and <code>Network</code>. These are summarized as follows:
			* Graph is your classic graph, it just deals with node-to-node relationships with "anonymous" edges defined only by endpoints.
			* ValueGraph is a graph where edges store a value (the value does not need to be unique); the value associated with the edge is (maybe??) of arbitrary type. The edges are stored as a map from a pair of vertices to a value.
			* Network is a type of graph that treats all edges as formal first-clsas types, just like nodes; this enables parallel edges with arbitrary objects.

Admin: Created page with "{{Main|Guava}} Guava implements high performance data containers for Java."

2017-08-22T00:41:09Z

Created page with "{{Main|Guava}} Guava implements high performance data containers for Java."

New page

{{Main|Guava}}

Guava implements high performance data containers for Java.