GraphPlot
GraphPlot[g]
generates a plot of the graph g.
GraphPlot[{e1,e2,…}]
generates a plot of the graph with edges ei.
GraphPlot[{…,w[ei],…}]
plots ei with features defined by the symbolic wrapper w.
GraphPlot[{vi 1vj 1,…}]
uses rules vikvjk to specify the graph g.
GraphPlot[m]
uses the adjacency matrix m to specify the graph g.
Details and Options
- GraphPlot attempts to place vertices to give a well-laid-out version of the graph.
- GraphPlot supports the same vertices and edges as Graph.
- The following special wrappers can be used for the edges ei:
-
Annotation[ei,label] provide an annotation Button[ei,action] define an action to execute when the element is clicked EventHandler[ei,…] define a general event handler for the element Hyperlink[ei,uri] make the element act as a hyperlink Labeled[ei,…] display the element with labeling PopupWindow[ei,cont] attach a popup window to the element StatusArea[ei,label] display in the status area when the element is moused over Style[ei,opts] show the element using the specified styles Tooltip[ei,label] attach an arbitrary tooltip to the element - GraphPlot has the same options as Graphics, with the following additions and changes: [List of all options]
-
DataRange Automatic the range of vertex coordinates to generate DirectedEdges False whether to interpret Rule as DirectedEdge EdgeLabels None labels and label placements for edges EdgeLabelStyle Automatic style to use for edge labels EdgeShapeFunction Automatic generate graphic shapes for edges EdgeStyle Automatic styles for edges GraphLayout Automatic how to lay out vertices and edges GraphHighlight {} vertices and edges to highlight GraphHighlightStyle Automatic style for highlight Method Automatic method to use PerformanceGoal Automatic aspects of performance to try to optimize PlotStyle Automatic graphics directives to determine styles PlotTheme Automatic overall theme for the graph VertexCoordinates Automatic coordinates for vertices VertexLabels None labels and label placements for vertices VertexLabelStyle Automatic style to use for vertex labels VertexShape Automatic graphic shape for vertices VertexShapeFunction Automatic generate graphic shapes for vertices VertexSize Automatic size of vertices VertexStyle Automatic styles for vertices - With the setting VertexCoordinates->Automatic, the embedding of vertices and routing of edges is computed automatically, based on the setting for GraphLayout.
- Possible special embeddings for GraphLayout include:
-
"BipartiteEmbedding" vertices on two parallel lines 
"CircularEmbedding" vertices on a circle 
"CircularMultipartiteEmbedding" vertices on segments of a circle 
"DiscreteSpiralEmbedding" vertices on a discrete spiral 
"GridEmbedding" vertices on a grid 
"LinearEmbedding" vertices on a line 
"MultipartiteEmbedding" vertices on several parallel lines 
"SpiralEmbedding" vertices on a 3D spiral projected to 2D 
"StarEmbedding" vertices on a circle with a center - Possible structured embeddings for layered graphs such as trees and directed acyclic graphs include:
-
"BalloonEmbedding" vertices on a circle with the center at the parent vertex 
"RadialEmbedding" vertices on a circular segment 
"LayeredDigraphEmbedding" vertices on parallel lines for directed acyclic graphs 
"LayeredEmbedding" vertices on parallel lines - Possible optimizing embeddings all minimize a quantity and include:
-
"HighDimensionalEmbedding" energy for spring-electrical in high dimension 
"PlanarEmbedding" number of edge crossings 
"SpectralEmbedding" weighted sum of squares distances 
"SpringElectricalEmbedding" energy with edges as springs and vertices as charges 
"SpringEmbedding" energy with edges as springs 
"TutteEmbedding" number of edge crossings and distance to neighbors - Possible settings for PlotTheme include common base themes:
-
"Business" a bright, modern look appropriate for business presentations or infographics 
"Detailed" identify data by employing labels and tooltips 
"Marketing" elegant, eye-catching design suitable for marketing needs 
"Minimal" simple graph 
"Monochrome" single-color design 
"Scientific" candid design useful for analyzing detailed data with labels and tooltips 
"Web" clean, bold design suitable for a consumer website or blog 
"Classic" historical design of graph to remain compatible with existing uses - Graph features themes affect plot of vertices and edges. Feature themes include:
-
"LargeGraph" large graph 
"ClassicLabeled" classic graph 
"IndexLabeled" index-labeled graph
List of all options
Examples
open all close allBasic Examples (3)
Scope (11)
Graph Specification (6)
Specify a graph using a graph:
GraphPlot[Graph[{12, 23, 34, 41, 24}]]Specify a graph using a rule list:
GraphPlot[{1 -> 2, 2 -> 3, 3 -> 4, 4 -> 1, 2 -> 4}]Specify a graph using a dense adjacency matrix:
GraphPlot[{{0, 1, 0, 0}, {0, 0, 1, 1}, {0, 0, 0, 1}, {1, 0, 0, 0}}]Specify a graph using a sparse adjacency matrix:
GraphPlot[SparseArray[{{1, 2}, {2, 3}, {3, 4}, {4, 1}, {2, 4}} -> 1, {4, 4}]]Use GraphData for collections of graphs:
Table[GraphPlot[GraphData[g, "EdgeRules"]], {g, {{"GeneralizedPetersen", {9, 2}}, "ClebschGraph", "TesseractGraph"}}]Use ExampleData for collections of sparse matrices:
GraphPlot[ExampleData[{"Matrix", "Bai/dwa512"}, "Matrix"]]Graph Styling (5)
GraphPlot[{1 -> 2, Labeled[2 -> 3, "23"], 3 -> 1, 2 -> 4, 2 -> 5}]GraphPlot[{5 -> 4, 6 -> 2, 6 -> 3, 6 -> 5, 4 -> 5, 7 -> 1, 7 -> 7, 7 -> 3, 7 -> 4, 7 -> 6}, VertexLabels -> "Name"]GraphPlot[{1 -> 6, 2 -> 6, 3 -> 6, 4 -> 6, 5 -> 6}, DirectedEdges -> True]Plot a disconnected graph using different packing methods:
Table[Framed@GraphPlot[Table[i -> Mod[i ^ 2, 102], {i, 0, 102}], GraphLayout -> {"PackingLayout" -> pm}], {pm, {Automatic, "ClosestPacking"}}]For very large graphs, it is often better not to draw vertices at all:
GraphPlot[Table[i -> Mod[i ^ 2, 500], {i, 500}], VertexShapeFunction -> None]Options (71)
DataRange (1)
DirectedEdges (1)
GraphLayout (66)
"BalloonEmbedding" (6)
Place each vertex in an enclosing circle centered at its parent vertex:
GraphPlot[Table[Floor[j / 12]j, {j, 1, 30}], GraphLayout -> "BalloonEmbedding"]"BalloonEmbedding" works best for tree graphs:
GraphPlot[RandomInteger[{1, #}] # + 1 & /@ Range[30], GraphLayout -> "BalloonEmbedding"]Use the option "EvenAngle"->True to place vertices evenly in an enclosing circle:
GraphPlot[KaryTree[48, 5], GraphLayout -> {"BalloonEmbedding", "EvenAngle" -> #}]& /@ {True, False}With the setting "OptimalOrder"->True, the vertex ordering optimizes the angular resolution and the aspect ratio:
GraphPlot[KaryTree[48, 5], GraphLayout -> {"BalloonEmbedding", "OptimalOrder" -> #}]& /@ {True, False}Use the option "RootVertex"->v to set the root vertex:
GraphPlot[KaryTree[48, 5], GraphLayout -> {"BalloonEmbedding", "RootVertex" -> #}]& /@ {1, 2}Use "SectorAngles"->s to control the size of each sector:
GraphPlot[KaryTree[48, 5], GraphLayout -> {"BalloonEmbedding", "SectorAngles" -> {1 -> Pi / 2}}]"BipartiteEmbedding" (1)
"CircularEmbedding" (2)
GraphPlot[Table[iMod[i + 1, 3], {i, 8}], GraphLayout -> "CircularEmbedding"]Use the option "Offset"->offset to specify the offset angles:
GraphPlot[CompleteGraph[7], GraphLayout -> {"CircularEmbedding", "Offset" -> #}]& /@ {Automatic, {30 Degree, 30 Degree}, {50 Degree, 80 Degree}}"CircularMultipartiteEmbedding" (2)
Place vertices on polygon lines based on a vertex partition:
GraphPlot[Flatten[Table[ij, {i, 4}, {j, 5, 8}]], GraphLayout -> {"CircularMultipartiteEmbedding", "VertexPartition" -> {2, 3, 3}}]Use "VertexPartition"->partition to specify a partition of vertices:
GraphPlot[CompleteGraph[{3, 3, 2}], GraphLayout -> {"CircularMultipartiteEmbedding", "VertexPartition" -> {3, 3, 2}}]"DiscreteSpiralEmbedding" (3)
Place vertices on a discrete spiral:
GraphPlot[Table[ii + 1, {i, 11}], GraphLayout -> "DiscreteSpiralEmbedding"]"DiscreteSpiralEmbedding" works best for path graphs:
GraphPlot[PathGraph[Range[30]], GraphLayout -> "DiscreteSpiralEmbedding"]With the setting "OptimalOrder"->True, vertices are reordered so that they lie nicely on a discrete spiral:
edges = RandomSample[EdgeList[PathGraph[Range[20]]], 19];
{GraphPlot[edges, GraphLayout -> {"DiscreteSpiralEmbedding", "OptimalOrder" -> True}],
GraphPlot[edges, GraphLayout -> {"DiscreteSpiralEmbedding", "OptimalOrder" -> False}]}"GridEmbedding" (2)
"HighDimensionalEmbedding" (2)
Place vertices in high dimension according to spring-electrical embedding and project down:
GraphPlot[{12, 13, 15, 19, 24, 26, 210, 34, 37, 311, 48, 412, 56, 57, 513, 68, 614, 78, 715, 816, 910, 911, 913, 1012, 1014, 1112, 1115, 1216, 1314, 1315, 1416, 1516}, GraphLayout -> "HighDimensionalEmbedding"]Use "RandomSeed"->int to specify a seed for the random number generator that computes the initial vertex placement:
edge = {13, 15, 17, 23, 26, 27, 28, 34, 38, 46, 58, 78};GraphPlot[edge, GraphLayout -> {"HighDimensionalEmbedding", "RandomSeed" -> #}]& /@ {1, 50}"LayeredEmbedding" (6)
Place vertices in several layers in such a way as to minimize edges between nonadjacent layers:
GraphPlot[Table[iMod[i + 1, 5], {i, 12}], GraphLayout -> "LayeredEmbedding"]"LayeredEmbedding" works best for tree graphs:
GraphPlot[RandomInteger[{1, #}] # + 1 & /@ Range[20], GraphLayout -> "LayeredEmbedding"]Use the option "LayerSizeFunction"->func to specify the relative height:
GraphPlot[KaryTree[10, 3], GraphLayout -> {"LayeredEmbedding", LayerSizeFunction -> (2&)}]Use the option "RootVertex"->v to set the root vertex:
GraphPlot[KaryTree[10, 3], GraphLayout -> {"LayeredEmbedding", "RootVertex" -> #}]& /@ {1, 4}Use the option "LeafDistance"->d to specify the leaf distance:
GraphPlot[KaryTree[10, 3], GraphLayout -> {"LayeredEmbedding", "LeafDistance" -> #}]& /@ {1, 2}Use the option "Orientation"->o to draw a tree with different orientations:
Table[GraphPlot[KaryTree[6, 3], GraphLayout -> {"LayeredEmbedding", "Orientation" -> o}], {o, {Top, Bottom, Left, Right}}]"LayeredDigraphEmbedding" (3)
Place vertices in a series of layers:
GraphPlot[{12, 13, 23, 14, 24, 15}, GraphLayout -> "LayeredDigraphEmbedding"]Use the option "RootVertex"->v to set the root vertex:
GraphPlot[{12, 13, 23, 14, 24, 15}, GraphLayout -> {"LayeredDigraphEmbedding", "RootVertex" -> #}]& /@ {1, 3}Use the option "Orientation"->o to draw a tree with different orientations:
Table[GraphPlot[{12, 13, 23, 14, 24, 15}, GraphLayout -> {"LayeredDigraphEmbedding", "Orientation" -> o}], {o, {Top, Bottom, Left, Right}}]"LinearEmbedding" (2)
GraphPlot[{12, 23, 34}, GraphLayout -> "LinearEmbedding"]Use the option "Method"->m to specify the algorithm:
Table[GraphPlot[CompleteGraph[4], GraphLayout -> {"LinearEmbedding", Method -> m}], {m, {"Spectral", "SpectralOrdering", "TwoNormApproximation", "TwoNormApproximationOrdering"}}]"MultipartiteEmbedding" (2)
Place vertices on multiple line grids based on a vertex partition:
GraphPlot[Flatten[Table[ij, {i, 3}, {j, 4, 8}]], GraphLayout -> {"MultipartiteEmbedding", "VertexPartition" -> {2, 1, 3, 2}}]Use "VertexPartition"->partition to specify a partition of vertices:
GraphPlot[CompleteGraph[{3, 2, 4}], GraphLayout -> {"MultipartiteEmbedding", "VertexPartition" -> {3, 2, 4}}]"PlanarEmbedding" (1)
"RadialEmbedding" (2)
Place vertices in concentric circles:
GraphPlot[Table[Floor[j / 7]j, {j, 1, 30}], GraphLayout -> "RadialEmbedding"]Use the option "RootVertex"->v to set the root vertex:
GraphPlot[KaryTree[60, 5], GraphLayout -> {"RadialEmbedding", "RootVertex" -> #}]& /@ {1, 2}"RandomEmbedding" (1)
"SpectralEmbedding" (2)
Place vertices so the weighted sum of squares of mutual distances is minimized:
GraphPlot[{12, 13, 15, 19, 24, 26, 210, 34, 37, 311, 48, 412, 56, 57, 513, 68, 614, 78, 715, 816, 910, 911, 913, 1012, 1014, 1112, 1115, 1216, 1314, 1315, 1416, 1516}, GraphLayout -> "SpectralEmbedding"]Use the option "RelaxationFactor"->r to get the layout based on a relaxed Laplace matrix:
Table[GraphPlot[GridGraph[{10, 10}], GraphLayout -> {"SpectralEmbedding", "RelaxationFactor" -> i}], {i, 0, 1, .3}]"SpiralEmbedding" (2)
GraphPlot[Table[iMod[i + 1, 20, 1], {i, 20}], GraphLayout -> "SpiralEmbedding"]With the setting "OptimalOrder"->True, vertices are reordered so that they lie on the spiral nicely:
edges = RandomSample[EdgeList[CycleGraph[20]], 20];
GraphPlot[edges, GraphLayout -> {"SpiralEmbedding", "OptimalOrder" -> #}]& /@ {True, False}"SpringElectricalEmbedding" (12)
Place vertices so that they minimize mechanical and electrical energy when each vertex has a charge and each edge corresponds to a spring:
GraphPlot[{12, 13, 15, 19, 24, 26, 210, 34, 37, 311, 48, 412, 56, 57, 513, 68, 614, 78, 715, 816, 910, 911, 913, 1012, 1014, 1112, 1115, 1216, 1314, 1315, 1416, 1516}, GraphLayout -> "SpringElectricalEmbedding"]With the setting "EdgeWeighted"->True, edge weights are used:
edge = RandomInteger[#]# + 1& /@ Range[0, 10];
weight = RandomInteger[{1, 5}, 11];GraphPlot[edge, EdgeWeight -> weight, GraphLayout -> {"SpringElectricalEmbedding", "EdgeWeighted" -> #}]& /@ {True, False}Use the option "EnergyControl"->e to specify limitations on the total energy of the system during minimization:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];GraphPlot[edge, {GraphLayout -> {"SpringElectricalEmbedding", "EnergyControl" -> #, "StepControl" -> "Monotonic"}}]& /@ {Automatic, "Monotonic", "NonMonotonic"}Use "InferentialDistance"->d to specify a cutoff distance beyond which the interaction between vertices is assumed to be nonexistent:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];GraphPlot[edge, GraphLayout -> {"SpringElectricalEmbedding", "InferentialDistance" -> #}]& /@ {Automatic, .1, .5}Use "MaxIteration"->it to specify a maximum number of iterations to be used in attempting to minimize the energy:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];GraphPlot[edge, GraphLayout -> {"SpringElectricalEmbedding", "MaxIteration" -> #}]& /@ {Automatic, 1, 2}Use "Multilevel"->method to specify a method used during a recursive procedure of coarsening a graph:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];GraphPlot[edge, GraphLayout -> {"SpringElectricalEmbedding", "Multilevel" -> #}]& /@ {Automatic, None, "MaximalIndependentVertexSet", "MaximalIndependentVertexSetRugeStuben", "MaximalIndependentVertexSetInjection", "MaximalIndependentVertexSetRugeStubenInjection", "MaximalIndependentEdgeSetHeavyEdge", "MaximalIndependentEdgeSet", "MaximalIndependentEdgeSetSmallestVertexWeight", "Hybrid"}With the setting "Octree"->True, an octree data structure (in three dimensions) or a quadtree data structure (in two dimensions) is used in the calculation of repulsive force:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];GraphPlot[edge, GraphLayout -> {"SpringElectricalEmbedding", "Octree" -> #}]& /@ {True, False}Use "RandomSeed"->int to specify a seed for the random number generator that computes the initial vertex placement:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];GraphPlot[edge, GraphLayout -> {"SpringElectricalEmbedding", "RandomSeed" -> #}]& /@ {1, 5}Use "RepulsiveForcePower"->r to control how fast the repulsive force decays over distance:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];GraphPlot[edge, GraphLayout -> {"SpringElectricalEmbedding", "RepulsiveForcePower" -> #}]& /@ {-1, -2.5}Use "StepControl"->method to define how step length is modified during energy minimization:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];GraphPlot[edge, GraphLayout -> {"SpringElectricalEmbedding", "StepControl" -> #}]& /@ {Automatic, "Monotonic", "NonMonotonic", "StrictlyMonotonic"}Use "StepLength"->r to specify the initial step length used in moving the vertices around:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];GraphPlot[edge, GraphLayout -> {"SpringElectricalEmbedding", "StepLength" -> #}]& /@ {1, 4.5}Use "Tolerance"->r to specify the tolerance used in terminating the energy minimization process:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];GraphPlot[edge, GraphLayout -> {"SpringElectricalEmbedding", "Tolerance" -> #}]& /@ {Automatic, .5}"SpringEmbedding" (10)
Place vertices so that they minimize mechanical energy when each edge corresponds to a spring:
GraphPlot[{114, 115, 116, 25, 26, 213, 37, 314, 319, 48, 415, 420, 511, 519, 612, 620, 711, 716, 812, 816, 910, 914, 917, 1015, 1018, 1112, 1317, 1318, 1719, 1820}, GraphLayout -> "SpringEmbedding"]With the setting "EdgeWeighted"->True, edge weights are used:
edge = RandomInteger[#]# + 1& /@ Range[0, 10];
weight = RandomInteger[{1, 5}, 11];GraphPlot[edge, EdgeWeight -> weight, GraphLayout -> {"SpringEmbedding", "EdgeWeighted" -> #}]& /@ {True, False}Use the option "EnergyControl"->e to specify limitations on the total energy of the system during minimization:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];GraphPlot[edge, {GraphLayout -> {"SpringEmbedding", "EnergyControl" -> #}}]& /@ {Automatic, "Monotonic", "NonMonotonic"}Use "InferentialDistance"->d to specify a cutoff distance beyond which the interaction between vertices is assumed to be nonexistent:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];GraphPlot[edge, GraphLayout -> {"SpringEmbedding", "InferentialDistance" -> #}]& /@ {Automatic, .5, 2}Use "MaxIteration"->it to specify a maximum number of iterations to be used in attempting to minimize the energy:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];GraphPlot[edge, GraphLayout -> {"SpringEmbedding", "MaxIteration" -> #}]& /@ {Automatic, 1, 2}Use "Multilevel"->method to specify a method used during a recursive procedure of coarsening a graph:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];GraphPlot[edge, GraphLayout -> {"SpringEmbedding", "Multilevel" -> #}]& /@ {Automatic, None, "MaximalIndependentVertexSet", "MaximalIndependentVertexSetRugeStuben", "MaximalIndependentVertexSetInjection", "MaximalIndependentVertexSetRugeStubenInjection", "MaximalIndependentEdgeSetHeavyEdge", "MaximalIndependentEdgeSet", "MaximalIndependentEdgeSetSmallestVertexWeight", "Hybrid"}Use "RandomSeed"->int to specify a seed for the random number generator that computes the initial vertex placement:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];GraphPlot[edge, GraphLayout -> {"SpringEmbedding", "RandomSeed" -> #}]& /@ {1, 5}Use "StepControl"->method to define how step length is modified during energy minimization:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];GraphPlot[edge, GraphLayout -> {"SpringEmbedding", "StepControl" -> #}]& /@ {Automatic, "Monotonic", "NonMonotonic", "StrictlyMonotonic"}Use "StepLength"->r to specify the initial step length used in moving the vertices around:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];GraphPlot[edge, GraphLayout -> {"SpringEmbedding", "StepLength" -> #}]& /@ {1, 4.5}Use "Tolerance"->r to specify the tolerance used in terminating the energy minimization process:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];GraphPlot[edge, GraphLayout -> {"SpringEmbedding", "Tolerance" -> #}]& /@ {Automatic, .5}"StarEmbedding" (3)
Place vertices on a star shape:
GraphPlot[Table[1i, {i, 2, 6}], GraphLayout -> "StarEmbedding"]Use the option "Offset"->offset to specify the offset angles:
GraphPlot[StarGraph[15], GraphLayout -> {"StarEmbedding", "Offset" -> #}]& /@ {Automatic, {30 Degree, 30 Degree}, {50 Degree, 80 Degree}}Use the option "Center"->center to specify the center:
GraphPlot[StarGraph[15], GraphLayout -> {"StarEmbedding", "Center" -> #}]& /@ {Automatic, 10}"TutteEmbedding" (2)
Place vertices without crossing edges and minimize the sum of distances to neighbors:
GraphPlot[{12, 13, 14, 23, 24, 34}, GraphLayout -> "TutteEmbedding"]"TutteEmbedding" works for 3-connected planar graphs only:
GraphPlot[GraphData[{"JohnsonSkeleton", 77}, "EdgeList"], GraphLayout -> "TutteEmbedding"]PlotStyle (3)
Specify an overall style for the graph:
Table[GraphPlot[{1 -> 2, 2 -> 3, 3 -> 4, 1 -> 4, 1 -> 3}, PlotStyle -> ps], {ps, {Red, Dashed, Directive[Red, Dashed]}}]PlotStyle can be combined with VertexShapeFunction, which has higher priority:
GraphPlot[{1 -> 2, 2 -> 3, 3 -> 4, 1 -> 4, 1 -> 3}, PlotStyle -> Directive[PointSize[Large], Red], VertexShapeFunction -> Function[{p}, {Green, Point[p]}]]PlotStyle can be combined with EdgeShapeFunction, which has higher priority:
GraphPlot[{1 -> 2, 2 -> 3, 3 -> 4, 1 -> 4, 1 -> 3}, PlotStyle -> Directive[Dashed, Red], EdgeShapeFunction -> Function[{p}, {Green, Line[p]}]]Applications (27)
Basic Applications (3)
GraphPlot[{12, 23, Labeled[31, "hello"]}, VertexLabels -> {2 -> "Name"}]Plot a graph with "BalloonEmbedding":
GraphPlot[Table[Floor[j / 12]j, {j, 1, 30}], GraphLayout -> "BalloonEmbedding"]GraphPlot[ExampleData[{"Matrix", "Bai/cryg2500"}, "Matrix"]]Graph Theory (5)
Plot a complete graph on 10 nodes:
GraphPlot[ConstantArray[1, {10, 10}]]Plot a random graph on 10 nodes:
GraphPlot[RandomInteger[1, {10, 10}]]A random graph with 1% of possible edges filled in:
GraphPlot[RandomChoice[{0.01, 0.99} -> {1, 0}, {100, 100}]]A graph describing a simple relation:
GraphPlot[Table[i -> Mod[2 ^ i, 21], {i, 20}], PlotTheme -> "ClassicDiagram"]Draw the graph of a random permutation:
GraphPlot[Thread[Range[20] -> RandomSample[Range[20]]]]Linguistic or Geographic Data (3)
Generate a network of "nearby" words in a dictionary:
words = DictionaryLookup["wol*"];Flatten[Map[(Thread[# -> DeleteCases[Nearest[words, #, 3], #]])&, words]];GraphPlot[%, VertexShapeFunction -> (Text[Style[#2, Black], #1, Background -> White]&)]A word graph, with edges between adjacent letters in a word:
w = Characters["Shakespeare"];
GraphPlot[
Thread[Drop[w, -1] -> Drop[w, 1]], VertexStyle -> LightDarkSwitched[RGBColor[1, 1, 0.85], GrayLevel[0.5]], PlotTheme -> "ClassicDiagram", DirectedEdges -> True]Show the adjacent countries in South America:
GraphPlot[Flatten[Thread[# -> CountryData[#, "BorderingCountries"]]& /@ CountryData["SouthAmerica"]], GraphLayout -> {"EdgeLayout" -> "StraightLine"}, VertexLabels -> Placed["Name", Center, Framed[#["Name"], Background -> StandardYellow]&]]Number Properties (11)
Numbers that have a common divisor:
GraphPlot[Table[If[GCD[m, n] == 1, 0, 1], {m, 20}, {n, 20}], PlotTheme -> "SmallNetwork"]Numbers that have no common divisor:
GraphPlot[Table[If[GCD[m, n] == 1, 1, 0], {m, 20}, {n, 20}], PlotTheme -> "SmallNetwork"]Link a number to another with a 1 bit inserted:
GraphPlot[Flatten[Table[Table[j -> FromDigits[Insert[IntegerDigits[j, 2], 1, i], 2], {i, Length[IntegerDigits[j, 2]] + 1}], {j, 0, 2 ^ 6 - 1}]], GraphLayout -> {"EdgeLayout" -> "StraightLine"}]Link a number to another with a 0 bit inserted:
GraphPlot[Flatten[Table[Table[j -> FromDigits[Insert[IntegerDigits[j, 2], 0, i], 2], {i, Length[IntegerDigits[j, 2]] + 1}], {j, 0, 2 ^ 6 - 1}]], GraphLayout -> {"EdgeLayout" -> "StraightLine"}]Link a number to another with 1 bit deleted:
GraphPlot[Flatten[Table[Table[j -> FromDigits[Drop[IntegerDigits[j, 2], {i}], 2], {i, Length[IntegerDigits[j, 2]]}], {j, 2 ^ 6 - 1}]], GraphLayout -> {"EdgeLayout" -> "StraightLine"}]Link a number to another that is one bit different:
GraphPlot[Flatten[Map[Thread, Thread[Range[0, 2 ^ 6 - 1] -> Table[Thread[BitXor[Table[2 ^ i - 1, {i, Length[IntegerDigits[j, 2]]}], j]], {j, 0, 2 ^ 6 - 1}], List]]], GraphLayout -> {"EdgeLayout" -> "StraightLine"}]Link a number to another that is one bit reversed:
GraphPlot[Table[j -> FromDigits[Reverse[IntegerDigits[j, 2]], 2], {j, 0, 2 ^ 9 - 1}]]Link a number to another that is one bit rotated right:
GraphPlot[Table[j -> FromDigits[RotateRight[IntegerDigits[j, 2]], 2], {j, 0, 2 ^ 9 - 1}], GraphLayout -> "RadialEmbedding"]Link a number to another that is one bit rotated left:
GraphPlot[Table[j -> FromDigits[RotateLeft[IntegerDigits[j, 2]], 2], {j, 0, 2 ^ 9 - 1}], GraphLayout -> "RadialEmbedding"]Link a number to itself but with the last bit dropped:
GraphPlot[Table[j -> FromDigits[Drop[IntegerDigits[j, 2], -1], 2], {j, 0, 2 ^ 8 - 1}], GraphLayout -> "RadialEmbedding"]Link a number to itself but with the first bit dropped:
GraphPlot[Table[j -> FromDigits[Drop[IntegerDigits[j, 2], 1], 2], {j, 0, 2 ^ 8 - 1}], GraphLayout -> "RadialEmbedding"]Sparse Test Matrices (3)
A sparse test matrix related to a structure from NASA's Langley Research Center:
GraphPlot[ExampleData[{"Matrix", "Boeing/nasa1824"}, "Matrix"]]A sparse test matrix related to a finite element model of a geodesic dome:
GraphPlot[ExampleData[{"Matrix", "HB/blckhole"}, "Matrix"], VertexShapeFunction -> None]Use ArrayPlot or MatrixPlot to display sparse matrices:
g = ExampleData[{"Matrix", "Boeing/nasa1824"}, "Matrix"]{ArrayPlot[g, MaxPlotPoints -> 100], MatrixPlot[g]}Finite State Diagrams (2)
A finite state diagram describing the C preprocessor:
GraphPlot[{"start" -> "none", Labeled["none" -> "none", "other"], Labeled["none" -> "slash", "/"], Labeled["slash" -> "none", "other"], Labeled["slash" -> "C++", "/"], Labeled["slash" -> "C", "*"], Labeled["C++" -> "C++", "other"], Labeled["C++" -> "none", "end-of-line"], Labeled["C" -> "C", "other"], Labeled["C" -> "star", "*"], Labeled["star" -> "star", "*"], Labeled["star" -> "C", "other"], Labeled["star" -> "none", "/"]}, DirectedEdges -> True, PlotTheme -> "DiagramBlue"]A finite state diagram for string matching:
GraphPlot[{"start" -> "empty", Labeled["empty" -> "empty", "other"], Labeled["empty" -> "n", "n"], Labeled["n" -> "n", "n"], Labeled["n" -> "empty", "other"], Labeled["n" -> "na", "a"], Labeled["na" -> "nan", "n"], Labeled["na" -> "empty", "other"], Labeled["nan" -> "na", "a"], Labeled["nan" -> "na", "a"], Labeled["nan" -> "nano", "o"], Labeled["nan" -> "empty", "other"], Labeled["nano" -> "nano", "any"]}, PlotTheme -> "DiagramBlue", DirectedEdges -> True]Properties & Relations (8)
Use LayeredGraphPlot for hierarchical-style drawing of directed graphs:
LayeredGraphPlot[{Labeled["main" -> "fun1", "fun1[a,b]"], Labeled["main" -> "fun2", "fun2[1,2,3]"], Labeled["fun2" -> "fun3", "fun3[0.5]"], Labeled["main" -> "fun3", "fun3[0.6]"]}, PlotTheme -> "DiagramGreen"]Use TreePlot for different types of tree drawing:
TreePlot[Flatten[Table[{i -> 2i + j - 1}, {j, 2}, {i, 7}]]]Use GraphPlot3D to draw graphs in 3D:
GraphPlot3D[Table[i -> Mod[i ^ 2, 200], {i, 200}]]GraphPlot3D[PolyhedronData["Dodecahedron", "Skeleton", "Rule"]]Use GraphData for an extensive collection of predefined graphs and properties:
Short[GraphData[], 3]Get the connectivity and plot it:
GraphData["DesarguesGraph", "EdgeRules"]GraphPlot[%]Use VertexCoordinates to use the embedding provided by GraphData:
GraphPlot[GraphData["DesarguesGraph", "Edges", "Rule"], VertexCoordinates -> GraphData["DesarguesGraph", "VertexCoordinates"], PlotTheme -> "SmallNetwork"]Use PolyhedronData for a large collection of polyhedra and properties:
PolyhedronData["Dodecahedron", "Skeleton", "Rule"]GraphPlot[%]Compare to a predefined embedding:
PolyhedronData["Dodecahedron", "Skeleton"]Use ExampleData for a large collection of sparse matrices:
GraphPlot[ExampleData[{"Matrix", "HB/can_292"}, "Matrix"]]Use GeoGraphValuePlot to show the values on geographic networks:
GeoGraphValuePlot[{{Entity["City", {"Rome", "Lazio", "Italy"}], Entity["City", {"Milan", "Lombardy", "Italy"}], 2.2}, {Entity["City", {"Milan", "Lombardy", "Italy"}], Entity["City", {"Paris", "IleDeFrance", "France"}], 2.4}, {Entity["City", {"Milan", "Lombardy", "Italy"}], Entity["City", {"Frankfurt", "Hesse", "Germany"}], 5}, {Entity["City", {"Paris", "IleDeFrance", "France"}], Entity["City", {"Frankfurt", "Hesse", "Germany"}], 3.2}, {Entity["City", {"Paris", "IleDeFrance", "France"}], Entity["City", {"Madrid", "Madrid", "Spain"}], 4.3}, {Entity["City", {"Paris", "IleDeFrance", "France"}], Entity["City", {"London", "GreaterLondon", "UnitedKingdom"}], 3.3}, {Entity["City", {"Madrid", "Madrid", "Spain"}], Entity["City", {"Seville", "Seville", "Spain"}], 3.6}, {Entity["City", {"Madrid", "Madrid", "Spain"}], Entity["City", {"Barcelona", "Barcelona", "Spain"}], 1.8}}]Use GeoGraphPlot to plot relationships between geographic locations on a map:
GeoGraphPlot[IconizedObject[«nearest US cities»]]Text
Wolfram Research (2007), GraphPlot, Wolfram Language function, https://reference.wolfram.com/language/ref/GraphPlot.html (updated 2019).
CMS
Wolfram Language. 2007. "GraphPlot." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2019. https://reference.wolfram.com/language/ref/GraphPlot.html.
APA
Wolfram Language. (2007). GraphPlot. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/GraphPlot.html