graphics_test

graphics_test, a Python code which illustrates how various kinds of data can be displayed and analyzed graphically.

Graphics are created with packages including graphviz, matplotlib, and pydotplus.

Some common plot types include:

• animation, a sequential display of images which are meant to suggest motion or evolution.
• bar, a display of values y(1:n) in which every value y(i) is represented by a bar of that height.
• bar3d, a display of values z(1:m,1:n) over a 2D grid, in which every value z(i,j) is represented by a bar of that height.
• barh, a display of values x(1:n) in which every value x(i) is represented by a horizontal bar of that length. The horizontal format can be more suitable for labeling bars when there are many of them.
• between, a line plot of a curve, and a filled plot of the area between the curve and the x-axis. Alternatively, a filled plot of the area between two curves.
• binary_tree, a connected directed graph with no circuits, in which each node has no more than 2 descendants.
• contour fill, a display of values z(x,y) in which the values of z are suggested by regions filled with color.
• contour line, a display of values z(x,y) in which the values of z are suggested by colored contour lines.
• decision_tree, a connected directed graph with no circuits, in which labeled nodes represent current states to be tested, and edges represent the choice or decision to move from one state to another.
• dendrogram, a connected directed graph with no circuits, which generally has a single root node, and illustrates the genealogy or relatedness of a set of objects.
• digraph, a "directed graph", nodes (possibly with defined locations, labels or colors), connected by directed edges (possibly with defined weights, labels, colors or linestyles).
• fill, a shape composed of polygons, each of which is filled with a particular color.
• graph, nodes (possibly with defined locations, labels or colors), connected by undirected edges (possibly with defined weights, labels, colors or linestyles).
• histogram, a display of values x in which the x range is divided into intervals, and the value y(i) represents the number of x values in the i-th interval, and a bar plot of intervals versus count is displayed.
• plot, a display of a single curve defined by a sequence of functional pairs (x,y(x)), or a function y=f(x) sampled over an interval, or a sequence of related pairs (x,y).
• plot3d, a 3D display of a single curve defined by a sequence of triples (x(i),y(i),z(i)), or a parametric function (x(t),y(t),z(t)) sampled over an interval.
• plots, several curves on a single display.
• scatter, a display of unconnected pairs (x,y), whose positions are indicated by markers.
• scatter3d, a 3D display of unconnected triples (x,y,z), whose positions are indicated by markers.
• scatters, a scatter plot involving several distinct sets of (x,y) pairs are displayed, distinguished by markers of different size, shape or color.
• subplots, a display involving two or more separate plots, shown as a single figure.
• surface, a 3D display of values z(x,y), represented as a surface.
• vector, a 2D display of vectors (u,v)(x,y), representing a gradient field, an ODE direction field, or a flow of some kind.

Licensing:

The computer code and data files described and made available on this web page are distributed under the MIT license

Languages:

graphics_test is available in a C/dislin() version and a C/gnuplot() version and a C++/dislin() version and a C++/gnuplot() version and a FORTRAN90/dislin() version and a FORTRAN90/gnuplot() version and a MATLAB version and an Octave version and a Python version and an R version.

Related:

animation_test, a Python code which computes a sequence of solutions to a partial differential equation, using matplotlib, displaying each solution to the screen WITHOUT requiring the user to hit RETURN to see the next image.

graphviz_test, a Python code which illustrates how the graphviz() code can be used to create plots of mathematical graphs and directed graphs.

movie_test, a Python code which creates a movie file from a sequence of solutions to a partial differential equation, using matplotlib.

Source Code:

• graphics_test.py, calls all the tests;
• graphics_test.sh, runs all the tests;
• graphics_test.txt, the output file;

album_bar lists the year, and total number of music albums (LP's, cassettes, CD's and downloads) sold each year from 2007 to 2017. This data is plotted as a bar graph.

• album_data.txt, a data file
• album_bar.py, reads and plots the data.
• album_bar.sh, runs the test.
• album_bar.txt, the output file.
• album_bar.png, the plot.

alphabet_binary_tree describes a binary tree that could be used to alphabetize letters. This plot is made using graphviz() and pydotplus().

• alphabet_binary_tree.py, sets up the graph and makes a plot.
• alphabet_binary_tree.sh, runs the test.
• alphabet_binary_tree.txt, the output file.
• alphabet_binary_tree.dot, a dot version of the plot.
• alphabet_binary_tree.dot.png, the plot.

automobile_scatter contains prices and weights of cars available in 1985. A scatter plot is to be made.

• automobile_data.txt, a data file.
• automobile_scatter.py, reads the data and creates a scatter plot of curb weight versus price.
• automobile_scatter.sh, runs the test.
• automobile_scatter.txt, the output file.
• automobile_scatter.png, the plot.

basketball_barh displays the sponsorship dollars for each of 30 basketball players, against their names. A horizontal bar graph is used, which makes it easier to display the name next to the bar. Numpy's genfromtxt() command is needed in order to handle the data file, which contains a mixture of text and numeric data.

• basketball_data.csv, a CSV file that contains information about 30 players.
• basketball_barh.py, reads the data and makes a plot.
• basketball_barh.sh, runs the test.
• basketball_barh.txt, the output file.
• basketball_barh.png, the plot.

brownian_2d_plot plots data representing 1000 steps of Brownian motion in two dimensions. Unlike a typical y=f(x) plot, this data wanders around the page.

• brownian_2d_data.txt, the data file.
• brownian_2d_plot.py, plots the data
• brownian_2d_plot.sh, runs the test.
• brownian_2d_plot.txt, the output file.
• brownian_2d_plot.png, the plot.

brownian_animation animates Brownian motion by drawing one more step every 1/4 second of viewing time.

• brownian_animation.py, simulates Brownian motion and displays the path in an animated way.
• brownian_animation.png, the final plot, showing the history of the motion.

bulgaria_plot records the year and population of Bulgaria for various census polls.

• bulgaria_data.txt, the data.
• bulgaria_plot.py, reads the data and makes a plot.
• bulgaria_plot.sh, runs the test.
• bulgaria_plot.txt, the output file.
• bulgaria_plot.png, a PNG image of the plot.

caffeine_scatter seeks a relationship between the percentage of blindness due to cataracts, and the daily intake of caffeine, in a number of countries. A scatter plot is produced.

• caffeine_data.txt, cataract percentage, and milligrams of caffeine.
• caffeine_scatter.py, reads and plots the data.
• caffeine_scatter.sh, runs the test.
• caffeine_scatter.txt, the output file.
• caffeine_scatter.png, the plot.

chain_letter_dendrogram considers the relatedness of 11 chain letters by using a distance matrix to construct a dendrogram.

• chain_letter_data.txt, a data file.
• chain_letter_dendrogram.py, reads the data and makes a plot.
• chain_letter_dendrogram.sh, runs the test.
• chain_letter_dendrogram.txt, the output file.
• chain_letter_dendrogram.png, the plot.

circle_scatters depicts 500 pairs of (X,Y) data points in the unit square, 395 of which lie inside the unit circle, and 105 outside. If possible, the "inside" points should be blue, the "outside" points red, and the circle itself should also be drawn.

• circle1_data.txt, the coordinates of points inside the circle.
• circle2_data.txt, the coordinates of points outside the circle.
• circle_scatters.py, reads the data and makes a plot.
• circle_scatters.sh, runs the test.
• circle_scatters.txt, the output file.
• circle_scatters.png, a PNG image of the plot.

corkscrew_plot3d generates (X,Y,Z) points on a curve, and makes a 3D line plot. When the plot is displayed, it can be rotated and zoomed in on. The PNG file is just a static snapshot.

• corkscrew_plot3d.py, generates data, saves it to a file, and makes a 3D plot.
• corkscrew_data.txt, a list of the (x,y,z) data values.
• corkscrew_plot3d.sh, runs the test.
• corkscrew_plot3d.txt, the output file.
• corkscrew_plot3d.png, a snapshop of the plot.

corvette_scatter considers the resale price for Corvettes by model year, displaying the results as a scatter plot.

• corvette_data.txt, a data file; each line is a model year and asking price.
• corvette_scatter.py, reads and plots the data.
• corvette_scatter.sh, runs the test.
• corvette_scatter.txt, the output file.
• corvette_scatter.png, the plot.

drug_dosage_plots depicts measurements over 48 hours of the blood level concentration of a medicinal drug. The drug needs to reach a certain level to have an effect, but must not exceed the toxic level. A graphic is created which shows, on one plot, the concentration over time, the minimal effective level, and the maximum nonlethal leval.

• drug_dosage_data.txt, a record of times and concentrations;
• drug_dosage_plots.py, reads the data and makes a plot.
• drug_dosage_plots.sh, runs the test.
• drug_dosage_plots.txt, the output file.
• drug_dosage_plots.png, a PNG image of the plot.

flow_vector creates a vector plot of a velocity field.

• flow_vector.py, makes a plot.
• flow_vector.sh, runs the test.
• flow_vector.txt, the output file.
• flow_vector.png, the plot.

genealogy_tree uses graphviz() and pydotplus() to create a tree diagram of a genealogy.

• genealogy_tree.py, sets up the data and makes a plot.
• genealogy_tree.sh, runs the test.
• genealogy_tree.txt, the output file.
• genealogy_tree.dot, a dot version of the plot.
• genealogy_tree.dot.png, the plot.

geyser_bar works with measurements of the waiting time in minutes between successive eruptions of the Old Faithful geyser. The data has been grouped into bins. The bin counts are displayed as a bar chart.

• geyser_bar_data.txt, bin centers, and occupancy counts, for waiting times.
• geyser_bar.py, reads the data and makes a plot.
• geyser_bar.sh, runs the test.
• geyser_bar.txt, the output file.
• geyser_bar.png, a PNG image of the plot.

geyser_histogram works with measurements of the waiting time in minutes between successive eruptions of the Old Faithful geyser.

• geyser_data.txt, pairs of eruption length and pause length;
• geyser_histogram.py, reads the data and makes a plot.
• geyser_histogram.sh, runs the test.
• geyser_histogram.txt, the output file.
• geyser_histogram.png, a PNG image of the plot.

geyser_scatter looks for relations between the duration in minutes of the eruption and following waiting times for the Old Faithful geyser.

• geyser_data.txt, waiting times and eruption durations.
• geyser_scatter.py, reads the data and makes a plot.
• geyser_scatter.sh, runs the test.
• geyser_scatter.txt, the output file.
• geyser_scatter.png, the plot.

gradient_vector plots the contours and negative gradient vectors of a function f(x,y), which has three local minima within the plotting region.

• gradient_vector.py, makes a plot.
• gradient_vector.sh, runs the test.
• gradient_vector.txt, the output file.
• gradient_vector.png, the plot.

grid_fill_contour records, on a 41x41 grid over [-2,2]x[-2,+2], the values z = exp(-(x^2+y^2)) * cos(0.25*x) * sin(y) * cos(2*(x^2+y^2)). The data is to be plotted as a filled color contour plot.

• grid_data.txt, the data.
• grid_fill_contour.py, reads the data and makes a plot.
• grid_fill_contour.sh, runs the test.
• grid_fill_contour.txt, the output file.
• grid_fill_contour.png, a PNG image of the plot.

grid_line_contour records, on a 41x41 grid over [-2,2]x[-2,+2], the values z = exp(-(x^2+y^2)) * cos(0.25*x) * sin(y) * cos(2*(x^2+y^2)). The data is to be plotted as a contour line plot.

• grid_data.txt, the data.
• grid_line_contour.py, reads the data and makes a plot.
• grid_line_contour.sh, runs the test.
• grid_line_contour.txt, the output file.
• grid_line_contour.png, a PNG image of the plot.

grid_surface records, on a 41x41 grid over [-2,2]x[-2,+2], the values z = exp(-(x^2+y^2)) * cos(0.25*x) * sin(y) * cos(2*(x^2+y^2)). The data is to be plotted as a surface.

• grid_data.txt, the data.
• grid_surface.py, reads the data and makes a plot.
• grid_surface.sh, runs the test.
• grid_surface.txt, the output file.
• grid_surface.png, a PNG image of the plot.

insect_scatter3d involves 3 data sets, each containing 10 measurements of 3 quantities for each of 3 species of insect. The quantities are first tarsus width, second tarsus width, and maximum width of the aedeagus. It is of interest to know whether these three measurements are enough to differentiate between members of the three species. A 3D scatter plot is created.

• insect_a_data.txt;
• insect_b_data.txt;
• insect_c_data.txt;
• insect_scatter3d.py, reads the 3 data sets, plots them as a 3D scatter plot, and saves a snapshot of the plot.
• insect_scatter3d.sh, runs the test.
• insect_scatter3d.txt, the output file.
• insect_scatter3d.png, the plot.

iris_decision_tree displays a decision tree for the iris classification process. This plot is made using graphviz() and pydotplus().

• iris_decision_tree.py, sets up the data and makes a plot.
• iris_decision_tree.sh, runs the test.
• iris_decision_tree.txt, the output file.
• iris_decision_tree.dot, a dot version of the plot.
• iris_decision_tree.dot.png, the plot.

iris_subplots demonstrates the use of subplots. In this case, there are three varieties of iris, and for each, several specimens have been collected and measurements recorded for sepal length, sepal width, petal length and petal width. It is desired to create a 4x4 array of plots of each possible pair of variables. Moreover, data is to be color-coded by iris variety.

• iris_setosa_data.txt, data set #1;
• iris_versicolor_data.txt, data set #2;
• iris_virginica_data.txt, data set #3;
• iris_subplots.py, reads the data, and makes the plot.
• iris_subplots.sh, runs the test.
• iris_subplots.txt, the output file.
• iris_subplots.png, the plot.

knight_graph describes a graph derived from a chess puzzle on a fragmentary board in which two black knights must swap positions with two white knights. This plot is made using graphviz() and pydotplus().

• knight_graph.py, sets up the graph and makes a plot.
• knight_graph.sh, runs the test.
• knight_graph.txt, the output file.
• knight_graph.dot, a dot version of the plot.
• knight_graph.dot.png, the plot.

least_squares_plots compares 15 pairs of (x,y) data, the least squares line that approximates their behavior, and a quadratic curve that is much closer to the data.

• least_squares1_data.txt, coordinates of the 15 sample points;
• least_squares2_data.txt, coordinates of two points on the least squares approximating line;
• least_squares3_data.txt, coordinates of points on the exact curve;
• least_squares_plots.py, reads data, makes the plot.
• least_squares_plots.sh, runs the test.
• least_squares_plots.txt, the output file.
• least_squares_plots.png, the plot.

lissajous_plot records 1000 points on a Lissajous curve defined by x=sin(3*t+pi/2), y=sin(4t). The curve is to be plotted and every tenth point marked.

• lissajous_data.txt, the data.
• lissajous_plot.py, reads the data and makes a plot.
• lissajous_plots.sh, runs the test.
• lissajous_plot.txt, the output file.
• lissajous_plot.png, a PNG image of the plot.

lynx_plot records the yearly lynx harvest from 1821 to 1934. The graph should plot the data points as circles, and connect consecutive data points with straight line segments to suggest a curve.

• lynx_data.txt, the data.
• lynx_plot.py, reads the data and makes a plot.
• lynx_plot.sh, runs the test.
• lynx_plot.txt, the output file.
• lynx_plot.png, a PNG image of the plot.

mario_fill makes a simple image of Mario, by constructing a grid of squares filled with color.

• mario_fill.py, makes a plot.
• mario_fill.sh, runs the test.
• mario_fill.txt, the output file.
• mario_fill.png, a PNG image of the plot.

mod_bar3d makes a 3D bar plot of the values of Z(I,J) = mod ( I, J ).

• mod_bar3d.py, makes a plot.
• mod_bar3d.sh, runs the test.
• mod_bar3d.txt, the output file.
• mod_bar3d.png, the plot.

network_graph describes a graph as a set of edges, defined by pairs of nodes. This plot is made using graphviz() and pydotplus().

• network_graph.py, sets up the graph and makes a plot.
• network_graph.sh, runs the test.
• network_graph.txt, the output file.
• network_graph.dot, a dot version of the plot.
• network_graph.dot.png, the plot.

nile_histogram makes a histogram of the yearly measurement of the height of the Nile at maximum flood. By lumping the data into bins, it is easier to see the range of flood heights, and the probability of various values in the range.

• nile_data.txt, a list of index and flood height for each year.
• nile_histogram.py, reads data and makes a histogram.
• nile_histogram.sh, runs the test.
• nile_histogram.txt, the output file.
• nile_histogram.png, the plot.

nile_plot makes a line plot of the yearly measurement of the height of the Nile at maximum flood.

• nile_data.txt, a list of index and flood height for each year.
• nile_plot.py, reads data and makes a line plot.
• nile_plot.sh, runs the test.
• nile_plot.txt, the output file.
• nile_plot.png, the plot.

ninety_histogram considers 90 numeric values. We create a histogram, to see how the data spreads out across its range. We spot outliers as histogram bins of low occupancy that are far from the rest of the data.

• ninety_data.txt, a text file containing a list of 90 numbers.
• ninety_histogram.py, reads the data and creates a histogram.
• ninety_histogram.sh, runs the test.
• ninety_histogram.txt, the output file.
• ninety_histogram.png, the plot.

orbital_fill_contour records, on a 101x101 grid over [0,4*pi]x[0,4*pi], the minimum distance between two planets given a pair of orbital angles. The data is presented as a filled color contour plot.

• orbital_data.txt, the data.
• orbital_fill_contour.py, reads the data and makes a plot.
• orbital_fill_contour.sh, runs the test.
• orbital_fill_contour.txt, the output file.
• orbital_fill_contour.png, a PNG image of the plot.

polygon_fill makes a plot of three polygons, each filled with a different color.

• polygon_fill.py, makes a plot.
• polygon_fill.sh, runs the test.
• polygon_fill.txt, the output file.
• polygon_fill.png, a PNG image of the plot.

predator_plot3d generates values of time, prey, and predator populations, writes them to a file, and displays them in a 3D plot. A 3D plot of (time, rabbits, foxes) is created.

• predator_data.txt, a list of the data values.
• predator_plot3d.py, generates data, saves it to a file, and makes a 3D plot.
• predator_plot3d.sh, runs the test.
• predator_plot3d.txt, the output file.
• predator_plot3d.png, a snapshop of the plot.

president_heights_bar plots the heights of US presidents in inches, as a bar plot.

• president_heights_data.txt, a data file;
• president_heights_bar.py, reads the data and makes a plot.
• president_heights_bar.sh, runs the test.
• president_heights_bar.txt, the output file.
• president_heights_bar.png, the plot.

president_heights_barh plots the heights of US presidents in inches, as a horizontal bar plot, with names as the y-tick labels.

• president_heights_data.csv, a data file containing names and heights.
• president_heights_barh.py, reads the data and makes a plot.
• president_heights_barh.sh, runs the test.
• president_heights_barh.txt, the output file.
• president_heights_barh.png, the plot.

president_heights_histogram plots the heights of US presidents in inches, as a histogram. By grouping the data by height, we lose the ability to identify specific cases, but we are better able to see the range of heights, and to judge the frequency of various heights.

• president_heights_data.csv, a data file;
• president_heights_histogram.py, reads the data and makes a plot.
• president_heights_histogram.sh, runs the test.
• president_heights_histogram.txt, the output file.
• president_heights_histogram.png, the plot.

price_plots reads a table of average monthly prices for 11 consumer products, between February 2008 and February 2018, as compiled by the Bureau of Labor Statistics, and plots together the prices of three of the items.

• price_data.csv, the month, the year, and average monthly prices for 11 consumer products, between February 2008 and February 2018.
• price_plots.py. commands to read the data and make plots of some of it.
• price_plots.sh, runs the test.
• price_plots.txt, the output file.
• price_plots.png, the plot.

price_subplots reads a table of average monthly prices for 11 consumer products, between February 2008 and February 2018, as compiled by the Bureau of Labor Statistics, and makes 6 separate subplots of the first six items in the data.

• price_data.txt, the month, the year, and average monthly prices for 11 consumer products, between February 2008 and February 2018.
• price_subplots.py. commands to read the data and make plots of some of it.
• price_subplots.sh, runs the test.
• price_subplots.txt, the output file.
• price_subplots.png, the plot.

random_scatter generates 500 pairs of (X,Y) data, which lie in the unit square, and tend to cluster around (0.5,0.5).

• random_data.txt, the data file
• random_scatter.py, creates the data and displays a scatter plot.
• random_scatter.sh, runs the test.
• random_scatter.txt, the output file.
• random_scatter.png, a PNG image of the plot.

schoolyear_barh displays the variation in the length of the school year across various countries. A horizontal bar graph is used, which makes it easier to display the country name next to the bar.

• schoolyear_data.csv, a CSV file that defines the country names and school year lengths in days.
• schoolyear_barh.py, reads the data and makes a plot.
• schoolyear_barh.sh, runs the test.
• schoolyear_barh.txt, the output file.
• schoolyear_barh.png, the plot.

snowfall_histogram makes a histogram of the yearly snowfall totals at Michigan Tech.

• snowfall_data.txt, snowfall measurements at Michigan Tech.
• snowfall_histogram.py, reads the data and makes a histogram.
• snowfall_histogram.sh, runs the test.
• snowfall_histogram.txt, the output file.
• snowfall_histogram.png, the plot.

snowfall_plot makes a line plot of the snowfall at Michigan Tech.

• snowfall_data.txt, snowfall measurements at Michigan Tech.
• snowfall_plot.py, reads the data and makes a plot.
• snowfall_plot.sh, runs the test.
• snowfall_plot.txt, the output file.
• snowfall_plot.png, the plot.

snowfall_smoothed_plot computes a 10 year moving average of the snowfall at Michigan Tech, and plots the smoothed data.

• snowfall_data.txt, the data.
• snowfall_smoothed_plot.py, reads the data, smooths it, and makes a plot.
• snowfall_smoothed_plot.sh, runs the test.
• snowfall_smoothed_plot.txt, the output file.
• snowfall_smoothed_plot.png, the plot.

sombrero_surface plots the function z=sin(r)/r as a 3d surface.

• sombrero_surface.py, makes a plot.
• sombrero_surface.sh, runs the test.
• sombrero_surface.txt, the output file.
• sombrero_surface.png, the plot.

temperature_scatter shows locations in the US where the January temperature was recorded.

• temperature_data.txt, January temperature, -longitude, latitude.
• temperature_scatter.py, reads and plots the data.
• temperature_scatter.sh, runs the test.
• temperature_scatter.txt, the output file.
• temperature_scatter.png, the plot.

temperature_scatter3d shows temperatures and locations in the US where the January temperature was recorded.

• temperature_data.txt, the data file, containing temperature, -longitude and latitude.
• temperature_scatter3d.py, creates the data and displays a 3d scatter plot.
• temperature_scatter3d.sh, runs the test.
• temperature_scatter3d.txt, the output file.
• temperature_scatter3d.png, the plot.

track_bar considers an eye-tracking experiment in which the eye was focused on different regions for different durations. Each region has a text label. A bar graph is desired, in which the bar for each duration is given the appropriate label.

• track_data.txt, a data file;
• track_bar.py, reads the data and makes a plot.
• track_bar.sh, runs the test.
• track_bar.txt, the output file.
• track_bar.png, the plot.

volcano_fill_contour creates a filled color contour plot from an 87x61 array of Z values representing the elevation of a volcano over an equally spaced (X,Y) grid.

• volcano_data.txt, the data file.
• volcano_fill_contour.py, creates the plot.
• volcano_fill_contour.sh, runs the test.
• volcano_fill_contour.txt, the output file.
• volcano_fill_contour.png, a PNG image of the plot.

volcano_line_contour creates a line color contour plot from an 87x61 array of Z values representing the elevation of a volcano over an equally spaced (X,Y) grid.

• volcano_data.txt, the data file.
• volcano_line_contour.py, creates the plot.
• volcano_line_contour.sh, runs the test.
• volcano_line_contour.txt, the output file.
• volcano_line_contour.png, a PNG image of the plot.

volcano_surface creates a surface plot from an 87x61 array of Z values representing the elevation of a volcano over an equally spaced (X,Y) grid.

• volcano_data.txt, the data file.
• volcano_surface.py, creates the plot.
• volcano_surface.sh, runs the test.
• volcano_surface.txt, the output file.
• volcano_surface.png, a PNG image of the plot.

web_digraph displays a set of directed connections as a digraph. This plot is made using graphviz() and pydotplus().

• web_digraph.py, sets up the graph and makes a plot.
• web_digraph.sh, runs the test.
• web_digraph.txt, the output file.
• web_digraph.dot, a dot version of the plot.
• web_digraph.dot.png, the plot.