{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Making Plots with Julia\n",
"\n",
"## Introduction\n",
"\n",
"There are several ways to make plots in Julia. The two most widely-used\n",
"graphing ecosystems are:\n",
"\n",
"- [`Plots.jl`](https://docs.juliaplots.org/stable/) — a high-level\n",
" interface that can target many different rendering **backends**. You\n",
" write the same `Plots.jl` code regardless of which backend you choose.\n",
"- [`Makie.jl`](https://docs.makie.org/stable/) — a modern,\n",
" GPU-accelerated plotting system that gives you very fine control over\n",
" every visual element. Its most popular backend for publication-quality\n",
" vector output is\n",
" [`CairoMakie.jl`](https://docs.makie.org/stable/explanations/backends/cairomakie).\n",
"\n",
"Other notable libraries include\n",
"[`VegaLite.jl`](https://github.com/queryverse/VegaLite.jl) (a\n",
"declarative grammar-of-graphics inspired by ggplot2) and\n",
"[`Gadfly.jl`](https://gadflyjl.org/stable/).\n",
"\n",
"### `Plots.jl` and Its Backends\n",
"\n",
"`Plots.jl` itself does not draw anything — it hands off the rendering to\n",
"a backend. Several backends are available: [1]\n",
"\n",
"- **[GR](https://github.com/jheinen/GR.jl)** — the default backend.\n",
" Fast, simple, and works out of the box.\n",
"- **[PythonPlot](https://github.com/JuliaPy/PythonPlot.jl)** — uses\n",
" Python’s `matplotlib` via `PythonCall.jl`. If you already know\n",
" `matplotlib`, this backend may feel the most familiar.\n",
"- **[PlotlyJS](https://github.com/JuliaPlots/PlotlyJS.jl)** —\n",
" interactive, web-based plots using plotly.js.\n",
"- **[PGFPlotsX](https://github.com/JuliaTeX/PGFPlotsX.jl)** —\n",
" high-quality LaTeX/TikZ output for publications.\n",
"- **[UnicodePlots](https://github.com/JuliaPlots/UnicodePlots.jl)** —\n",
" plots directly in the terminal using Unicode characters.\n",
"\n",
"This tutorial will give examples of making plots using `Plots.jl` (with\n",
"the `GR` backend), and will show how the `PythonPlot` backend and\n",
"`Makie.jl` produce equivalent results. Relevant documentation resources\n",
"are listed below.\n",
"\n",
"## Some Resources\n",
"\n",
"### `Plots.jl`\n",
"\n",
"- [Useful tips](https://docs.juliaplots.org/latest/basics/#Useful-Tips)\n",
"- [Examples](https://docs.juliaplots.org/latest/generated/gr/)\n",
"- [Plot\n",
" attributes](http://docs.juliaplots.org/latest/generated/attributes_plot/)\n",
"- [Axis\n",
" attributes](http://docs.juliaplots.org/latest/generated/attributes_axis/#Axis)\n",
"\n",
"### `Makie.jl`\n",
"\n",
"- [Documentation](https://docs.makie.org/stable/)\n",
"- [Plotting function\n",
" reference](https://docs.makie.org/stable/reference/plots)\n",
"- [Beautiful Makie (gallery)](https://beautiful.makie.org)\n",
"\n",
"### `PythonPlot`\n",
"\n",
"- [GitHub repository](https://github.com/JuliaPy/PythonPlot.jl)\n",
"\n",
"### Color and styling\n",
"\n",
"- [Color\n",
" names](http://juliagraphics.github.io/Colors.jl/stable/namedcolors/)\n",
"- [Colors.jl colormaps and\n",
" scales](https://juliagraphics.github.io/Colors.jl/stable/colormapsandcolorscales/)\n",
"\n",
"## Setup\n",
"\n",
"Since we’ll be generating random numbers, load the packages and set a\n",
"seed for reproducibility.\n",
"\n",
"[1] This tutorial focuses on GR and PythonPlot; see the [Plots.jl\n",
"backend gallery](https://docs.juliaplots.org/latest/backends/) for the\n",
"full list."
],
"id": "27ca1972-81ee-457f-9908-4e7039e2d637"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"using Plots\n",
"using StatsPlots # for distribution plots; re-exports Plots\n",
"using CairoMakie # the vector-graphics Makie backend\n",
"using LaTeXStrings\n",
"using Measures\n",
"using Random\n",
"Random.seed!(1);"
],
"id": "6"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"> **`Plots.jl` Backends and Makie**\n",
">\n",
"> `Plots.jl` is more of a common interface for several different\n",
"> plotting ecosystems (called **backends**) than a self-contained\n",
"> plotting package. By default, `Plots.jl` uses the `GR` backend, which\n",
"> is pretty basic and fast; I will use this in class for simplicity. You\n",
"> switch backends at any time by calling their name, e.g. `gr()` or\n",
"> `pythonplot()`.\n",
">\n",
"> You can and should feel free to use [other\n",
"> backends](https://docs.juliaplots.org/latest/backends/) if you find\n",
"> them more intuitive or useful for the plot(s) you are trying to make.\n",
"> In particular, you might find `PythonPlot` simple to use if you feel\n",
"> comfortable with `matplotlib` in Python. The downside to `PythonPlot`\n",
"> is that it relies on Python to render the plots; if you don’t have\n",
"> Python installed,\n",
"> [`CondaPkg.jl`](https://github.com/JuliaPy/CondaPkg.jl) will install a\n",
"> private copy automatically (which can take a few minutes the first\n",
"> time).\n",
">\n",
"> Below, each plot example is shown in a tabset for three approaches:\n",
"> the `GR` backend, the `PythonPlot` backend, and `Makie.jl`.\n",
"\n",
"> **Makie Function Names in This Tutorial**\n",
">\n",
"> Because this document has both `Plots.jl` and `Makie` loaded at once,\n",
"> a few function names that exist in both packages (such as `scatter`\n",
"> and `heatmap`) are written as `Makie.scatter` and `Makie.heatmap` in\n",
"> the Makie tabs. In your own scripts, where you would normally load\n",
"> only one of the two, you can drop the `Makie.` prefix.\n",
"\n",
"## Making a Basic Plot\n",
"\n",
"Let’s walk through making a basic line plot.\n",
"\n",
"First, to generate a basic line plot, use `plot()`:"
],
"id": "b37dc2b0-67f9-4577-9bc8-5b1d8cc54334"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/html": [
"\n",
""
]
}
}
],
"source": [
"x = 1:5\n",
"y = rand(length(x))\n",
"plot(x, y, label=\"Original Data\", legend=:topleft)"
],
"id": "10"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here, we explicitly passed in `x` to provide the $x$ coordinates for the\n",
"plotted values. If only one array is passed[1], `Plots.jl` will\n",
"interpret the values as $y$ coordinates and use their indices for the\n",
"$x$ positions.\n",
"\n",
"Now add more series and axis labels.\n",
"\n",
"> **Mutating Function**\n",
">\n",
"> The exclamation mark says that `plot!()` is a **mutating function**,\n",
"> which changes an existing plot instead of creating a new one. Try\n",
"> removing the `!` — you will get a new plot that no longer contains the\n",
"> old elements.\n",
"\n",
"[1] This syntax might look like `plot(y, ...)` instead of\n",
"`plot(x, y, ...)`."
],
"id": "b486424b-c81b-4999-a896-6f45cf314b5e"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/plain": [
"5-element Vector{Float64}:\n",
" 0.5710874493423871\n",
" 0.4528085872833483\n",
" 0.30232547191787174\n",
" 0.0013502779247226426\n",
" 0.5670236732404312"
]
}
}
],
"source": [
"y2 = rand(5)\n",
"y3 = rand(5)"
],
"id": "12"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## GR (Plots.jl)\n",
"\n",
"``` julia\n",
"gr()\n",
"plot(x, y, label=\"Original Data\")\n",
"plot!(x, y2, color=:red, linewidth=2, linestyle=:dot, label=\"New Data\")\n",
"scatter!(x, y3, markercolor=:black, markershape=:square, markersize=5, label=\"Point Data\")\n",
"xlabel!(\"Regular String (days)\")\n",
"ylabel!(L\"LaTeX String $x_2$ (m$^3$)\")\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"## PythonPlot (Plots.jl)\n",
"\n",
"``` julia\n",
"pythonplot()\n",
"plot(x, y, label=\"Original Data\")\n",
"plot!(x, y2, color=:red, linewidth=2, linestyle=:dot, label=\"New Data\")\n",
"scatter!(x, y3, markercolor=:black, markershape=:square, markersize=5, label=\"Point Data\")\n",
"xlabel!(\"Regular String (days)\")\n",
"ylabel!(L\"LaTeX String $x_2$ (m$^3$)\")\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"## Makie.jl\n",
"\n",
"``` julia\n",
"fig = Figure()\n",
"ax = Axis(fig[1, 1], xlabel=\"Regular String (days)\", ylabel=L\"LaTeX String $x_2$ (m$^3$)\")\n",
"lines!(ax, x, y, label=\"Original Data\")\n",
"lines!(ax, x, y2, color=:red, linewidth=2, linestyle=:dot, label=\"New Data\")\n",
"Makie.scatter!(ax, x, y3, color=:black, marker=:rect, markersize=10, label=\"Point Data\")\n",
"axislegend(ax, position=:lt)\n",
"fig\n",
"```\n",
"\n",
"![](\"data:image/png;base64,)
\n",
"\n",
"### Removing Plot Elements\n",
"\n",
"Sometimes we want to remove legends, axes, grid lines, and/or ticks."
],
"id": "14e7dd5c-bdab-4e68-8dd0-f57fe5247f93"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/html": [
"\n",
"\n",
""
]
}
}
],
"source": [
"plot!(legend=false, axis=false, grid=false, ticks=false)"
],
"id": "20"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Notice that this unintentionally modified the image dimensions to move\n",
"the axis labels off the page. If we wanted to keep them, we could modify\n",
"the dimensions with `plot!(size=...)`."
],
"id": "d06fa07e-0421-4e13-baa1-3d99b6a27952"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/html": [
"\n",
"\n",
""
]
}
}
],
"source": [
"plot!(size=(400, 400))"
],
"id": "22"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The lesson is that sometimes the `Plots.jl` defaults don’t look ideal,\n",
"and we need to adjust sizes and margins. Don’t shy away from these\n",
"tweaks if they make your figures easier to read or interpret!\n",
"\n",
"### Aspect Ratio\n",
"\n",
"For a square aspect ratio, `Plots.jl` uses `ratio = 1`; `Makie.jl` uses\n",
"`aspect = AxisAspect(1)`."
],
"id": "bacfbd1f-413a-487c-a920-6aa6e3841648"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/plain": [
"5-element Vector{Float64}:\n",
" 0.6159379234562881\n",
" 0.19573857852575793\n",
" 0.012461945950411835\n",
" 0.3119923865097316\n",
" 0.11479916823306191"
]
}
}
],
"source": [
"v = rand(5)"
],
"id": "24"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## GR (Plots.jl)\n",
"\n",
"``` julia\n",
"gr()\n",
"plot(v, ratio=1, legend=false)\n",
"scatter!(v)\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"## PythonPlot (Plots.jl)\n",
"\n",
"``` julia\n",
"pythonplot()\n",
"plot(v, ratio=1, legend=false)\n",
"scatter!(v)\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"## Makie.jl\n",
"\n",
"``` julia\n",
"fig = Figure()\n",
"ax = Axis(fig[1, 1], aspect=AxisAspect(1))\n",
"lines!(ax, v)\n",
"Makie.scatter!(ax, v)\n",
"fig\n",
"```\n",
"\n",
"\n",
"\n",
"## Plot Demos\n",
"\n",
"This section includes some examples of how to make other types of plots.\n",
"\n",
"### Heatmaps\n",
"\n",
"A heatmap is a plotted matrix whose cells are colored by value. Use\n",
"`clim` (Plots) or `colorrange` (Makie) to fix the color scale."
],
"id": "67c12862-2b93-4b08-8732-19f4f7265f1a"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/plain": [
"10×10 Matrix{Float64}:\n",
" 0.742414 0.108674 0.0909513 0.818597 … 0.239896 0.96551 0.229329\n",
" 0.65913 0.265374 0.914553 0.859535 0.327377 0.81217 0.575938\n",
" 0.360275 0.699443 0.590472 0.375186 0.109344 0.430081 0.243464\n",
" 0.892222 0.036808 0.967915 0.947293 0.51529 0.599123 0.342309\n",
" 0.337329 0.633275 0.673935 0.373811 0.0913972 0.82805 0.835509\n",
" 0.671766 0.295391 0.228969 0.0223076 … 0.585548 0.592562 0.0590473\n",
" 0.534097 0.348069 0.46191 0.110385 0.120938 0.982151 0.551654\n",
" 0.655354 0.427535 0.577283 0.226571 0.628025 0.439115 0.139791\n",
" 0.404693 0.60398 0.139681 0.857178 0.59816 0.938309 0.540769\n",
" 0.703556 0.641963 0.129069 0.0568809 0.717561 0.593831 0.775324"
]
}
}
],
"source": [
"A = rand(10, 10)"
],
"id": "32"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## GR (Plots.jl)\n",
"\n",
"``` julia\n",
"gr()\n",
"heatmap(A, clim=(0, 1))\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"## PythonPlot (Plots.jl)\n",
"\n",
"``` julia\n",
"pythonplot()\n",
"heatmap(A, clim=(0, 1))\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"## Makie.jl\n",
"\n",
"``` julia\n",
"fig = Figure()\n",
"ax = Axis(fig[1, 1])\n",
"hm = Makie.heatmap!(ax, A, colorrange=(0, 1))\n",
"Colorbar(fig[1, 2], hm)\n",
"fig\n",
"```\n",
"\n",
""
],
"id": "f9cb4ea2-c225-4e2a-828f-9b07019fa072"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/html": [
"\n",
"\n",
""
]
}
}
],
"source": [
"M = [ 0 1 0; 0 0 0; 1 0 0]\n",
"whiteblack = [RGBA(1,1,1,0), RGB(0,0,0)]\n",
"heatmap(M, c=whiteblack, aspect_ratio = 1, ticks=.5:3.5, lims=(.5,3.5), gridalpha=1, legend=false, axis=false, ylabel=\"i\", xlabel=\"j\")"
],
"id": "40"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Custom Colormaps\n",
"\n",
"Use a custom set of colors instead of the default gradients."
],
"id": "fef9acec-e92c-42cc-b1d7-5d8478c08980"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/plain": [
"251×100 Matrix{Int64}:\n",
" 50 50 50 50 50 50 50 50 … 50 50 50 50 50 50 50\n",
" 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51\n",
" 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52\n",
" 53 53 53 53 53 53 53 53 53 53 53 53 53 53 53\n",
" 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54\n",
" 55 55 55 55 55 55 55 55 … 55 55 55 55 55 55 55\n",
" 56 56 56 56 56 56 56 56 56 56 56 56 56 56 56\n",
" 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57\n",
" 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58\n",
" 59 59 59 59 59 59 59 59 59 59 59 59 59 59 59\n",
" ⋮ ⋮ ⋱ ⋮ \n",
" 292 292 292 292 292 292 292 292 292 292 292 292 292 292 292\n",
" 293 293 293 293 293 293 293 293 293 293 293 293 293 293 293\n",
" 294 294 294 294 294 294 294 294 294 294 294 294 294 294 294\n",
" 295 295 295 295 295 295 295 295 … 295 295 295 295 295 295 295\n",
" 296 296 296 296 296 296 296 296 296 296 296 296 296 296 296\n",
" 297 297 297 297 297 297 297 297 297 297 297 297 297 297 297\n",
" 298 298 298 298 298 298 298 298 298 298 298 298 298 298 298\n",
" 299 299 299 299 299 299 299 299 299 299 299 299 299 299 299\n",
" 300 300 300 300 300 300 300 300 … 300 300 300 300 300 300 300"
]
}
}
],
"source": [
"using Colors\n",
"\n",
"mycolors = [colorant\"lightslateblue\",colorant\"limegreen\",colorant\"red\"]\n",
"A2 = [i for i=50:300, j=1:100]"
],
"id": "42"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## GR (Plots.jl)\n",
"\n",
"``` julia\n",
"gr()\n",
"heatmap(A2, c=mycolors, clim=(50, 300))\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"## PythonPlot (Plots.jl)\n",
"\n",
"``` julia\n",
"pythonplot()\n",
"heatmap(A2, c=mycolors, clim=(50, 300))\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"## Makie.jl\n",
"\n",
"``` julia\n",
"fig = Figure()\n",
"ax = Axis(fig[1, 1])\n",
"hm = Makie.heatmap!(ax, A2, colormap=mycolors, colorrange=(50, 300))\n",
"Colorbar(fig[1, 2], hm)\n",
"fig\n",
"```\n",
"\n",
"\n",
"\n",
"### Area Under a Curve\n",
"\n",
"`areaplot()` fills the region between a curve and the x-axis. The Makie\n",
"equivalent is `band!` with a zero lower bound."
],
"id": "17bfb1ff-f59d-4efe-9189-864207cdb15a"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/plain": [
"601-element Vector{Float64}:\n",
" 0.0044318484119380075\n",
" 0.004566589954670145\n",
" 0.004704957526933979\n",
" 0.004847032905978945\n",
" 0.004992899213612376\n",
" 0.005142640923053939\n",
" 0.00529634386531102\n",
" 0.005454095235056545\n",
" 0.005615983595990969\n",
" 0.005782098885669473\n",
" ⋮\n",
" 0.005615983595990969\n",
" 0.005454095235056545\n",
" 0.00529634386531102\n",
" 0.005142640923053939\n",
" 0.004992899213612376\n",
" 0.004847032905978945\n",
" 0.004704957526933979\n",
" 0.004566589954670145\n",
" 0.0044318484119380075"
]
}
}
],
"source": [
"xa = -3:0.01:3\n",
"fa = exp.(-xa.^2/2) / √(2π)"
],
"id": "50"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## GR (Plots.jl)\n",
"\n",
"``` julia\n",
"gr()\n",
"areaplot(xa, fa, alpha=0.25, legend=false)\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"## PythonPlot (Plots.jl)\n",
"\n",
"``` julia\n",
"pythonplot()\n",
"areaplot(xa, fa, alpha=0.25, legend=false)\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"## Makie.jl\n",
"\n",
"``` julia\n",
"fig = Figure()\n",
"ax = Axis(fig[1, 1])\n",
"band!(ax, xa, fill(0.0, length(xa)), fa, color=(:blue, 0.25))\n",
"fig\n",
"```\n",
"\n",
"\n",
"\n",
"#### Stacked Area Plots\n",
"\n",
"We can stack multiple area series on top of each other by passing a\n",
"matrix to `areaplot()`, where each column (or row) represents one layer.\n",
"The layers are stacked cumulatively. A practical example: visualize the\n",
"monthly energy use of four sources over three years."
],
"id": "78bb0ac0-224c-4f0b-881c-fa470713c415"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/html": [
"\n",
"\n",
""
]
}
}
],
"source": [
"years = [\"2021\", \"2022\", \"2023\"]\n",
"# Each row is a source; each column is a year.\n",
"# Sources: Solar, Wind, Hydro, Coal (values in GWh)\n",
"energy = [\n",
" 120 180 260; # Solar (growing)\n",
" 200 220 240; # Wind\n",
" 150 140 130; # Hydro (declining)\n",
" 80 60 40 # Coal (declining)\n",
"]\n",
"sources = [\"Solar\", \"Wind\", \"Hydro\", \"Coal\"]\n",
"\n",
"p = areaplot(1:3, energy', # transpose so each column = layer\n",
" seriescolor = [:orange :skyblue :steelblue :gray],\n",
" fillalpha = [0.6, 0.5, 0.4, 0.5],\n",
" labels = reshape(sources, 1, :), # one label per layer\n",
" legend = :topleft,\n",
" xticks = (1:3, years),\n",
" xlabel = \"Year\",\n",
" ylabel = \"Energy Use (GWh)\"\n",
")"
],
"id": "58"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"When you pass a matrix, each column becomes its own stacked layer. The\n",
"`seriescolor` and `fillalpha` vectors control the color and transparency\n",
"per layer. The `labels` must be a row matrix (`reshape(sources, 1, :)`)\n",
"to match the matrix orientation. Try experimenting — change the values\n",
"or colors to see how the plot adjusts.\n",
"\n",
"The `fillrange` option lets us color the area between two arbitrary\n",
"lines/curves if we only want to treat one of those curves as a boundary.\n",
"`fillcolor` and `fillalpha` let you change the color and transparency of\n",
"the filled area."
],
"id": "c78ea86a-1f97-4cb7-ab87-9a50b1a89ec7"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/html": [
"\n",
"\n",
""
]
}
}
],
"source": [
"y = rand(10)\n",
"plot(y, fillrange= y.*0 .+ .5, label= \"above/below 1/2\", fillcolor=:red, legend =:top)"
],
"id": "60"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Confidence Band\n",
"\n",
"Use `fillrange` to color the region between two curves, e.g. to show a\n",
"confidence band."
],
"id": "68694bf0-d18f-4b14-b078-efb237828671"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/plain": [
"100-element Vector{Float64}:\n",
" 1.0\n",
" 1.0266105279586968\n",
" 1.0539291761156344\n",
" 1.0819747879231458\n",
" 1.1107667082677797\n",
" 1.1403247968137291\n",
" 1.1706694417013364\n",
" 1.2018215736101217\n",
" 1.233802680196039\n",
" 1.2666348209129108\n",
" ⋮\n",
" 10.912391625589951\n",
" 11.20277612803896\n",
" 11.500887915409168\n",
" 11.806932614831997\n",
" 12.121121325285433\n",
" 12.443670763202702\n",
" 12.774803411955727\n",
" 13.11474767531643\n",
" 13.463738035001692"
]
}
}
],
"source": [
"xb = LinRange(0, 2, 100)\n",
"y1 = exp.(xb)\n",
"y2 = exp.(1.3 .* xb)"
],
"id": "62"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## GR (Plots.jl)\n",
"\n",
"``` julia\n",
"gr()\n",
"plot(xb, y1, fillrange=y2, fillalpha=0.35, c=1, label=\"Confidence band\", legend=:topleft)\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"## PythonPlot (Plots.jl)\n",
"\n",
"``` julia\n",
"pythonplot()\n",
"plot(xb, y1, fillrange=y2, fillalpha=0.35, c=1, label=\"Confidence band\", legend=:topleft)\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"## Makie.jl\n",
"\n",
"``` julia\n",
"fig = Figure()\n",
"ax = Axis(fig[1, 1])\n",
"band!(ax, xb, y1, y2, color=(:blue, 0.35), label=\"Confidence band\")\n",
"lines!(ax, xb, y1, label=\"Estimate\")\n",
"axislegend(ax, position=:lt)\n",
"fig\n",
"```\n",
"\n",
"\n",
"\n",
"We can also get more creative and color different parts of a curve\n",
"differently. Here, we divide a normal distribution into 100 quantiles\n",
"and alternate red and blue stripes. We’ll do this using the `erfinv()`\n",
"function from `SpecialFunctions.jl` to calculate the quantiles using the\n",
"inverse cumulative distribution function, but there are other approaches\n",
"using `Distributions.jl`."
],
"id": "b2230e09-6558-4455-9c12-8223fa9f2b69"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/html": [
"\n",
"\n",
""
]
}
}
],
"source": [
"using SpecialFunctions\n",
"\n",
"# write a function for the normal distribution density\n",
"f(x) = exp(-x^2/2)/√(2π) \n",
"# get the edges of the quantiles\n",
"δ = .01\n",
"x = √2 .* erfinv.(2 .* (δ/2 : δ : 1) .- 1)\n",
"# make the plot and draw the density line in black\n",
"areaplot(x, f.(x), seriescolor=[ :red,:blue], legend=false)\n",
"plot!(x, f.(x),c=:black)"
],
"id": "70"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Plotting Shapes\n",
"\n",
"We can also draw shapes more directly, such as rectangles and circles."
],
"id": "f3fb0f10-b5d3-4dd6-bd20-d8a0efdcf8f9"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/html": [
"\n",
"\n",
""
]
}
}
],
"source": [
"rectangle(w, h, x, y) = Shape(x .+ [0,w,w,0], y .+ [0,0,h,h])\n",
"circle(r,x,y) = (θ = LinRange(0,2π,500); (x.+r.*cos.(θ), y.+r.*sin.(θ)))\n",
"plot(circle(5,0,0), ratio=1, c=:red, fill=true)\n",
"plot!(rectangle(5*√2,5*√2,-2.5*√2,-2.5*√2),c=:white,fill=true,legend=false)"
],
"id": "72"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Plotting Distributions\n",
"\n",
"[`StatsPlots.jl`](https://github.com/JuliaPlots/StatsPlots.jl) adds\n",
"distribution-plotting recipes. `Makie.jl` requires computing the PDF\n",
"explicitly with `Distributions.jl`."
],
"id": "0aa8cd95-445e-4370-b7fc-070135b4b003"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/plain": [
"-15.0:0.11705685618729098:20.0"
]
}
}
],
"source": [
"using Distributions\n",
"d = Normal(2, 5)\n",
"xs_dist = range(-15, 20, length=300)"
],
"id": "74"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## GR (Plots.jl)\n",
"\n",
"``` julia\n",
"gr()\n",
"plot(d)\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"## PythonPlot (Plots.jl)\n",
"\n",
"``` julia\n",
"pythonplot()\n",
"plot(d)\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"## Makie.jl\n",
"\n",
"``` julia\n",
"fig = Figure()\n",
"ax = Axis(fig[1, 1], xlabel=\"x\", ylabel=\"pdf(x)\")\n",
"lines!(ax, xs_dist, pdf.(d, xs_dist))\n",
"fig\n",
"```\n",
"\n",
"\n",
"\n",
"#### Kernel Density Estimate"
],
"id": "964d0254-e21c-42ce-8256-6b6cb4f73879"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/plain": [
"2000-element Vector{Float64}:\n",
" 1.5245899213514686\n",
" 4.24310012818435\n",
" 3.4922212945438504\n",
" 4.857580339253022\n",
" -1.0847650373991686\n",
" 0.34742627716202557\n",
" -3.8740430084774573\n",
" 0.6981636365869883\n",
" -1.7086625454229645\n",
" 0.5531704345757209\n",
" ⋮\n",
" 2.519087067670294\n",
" 0.2482312995844831\n",
" 9.895844005945166\n",
" 6.946334488918343\n",
" 9.527402479478546\n",
" 3.6776118640373947\n",
" 9.825093587382582\n",
" 3.1282935080762977\n",
" -1.4111479173941746"
]
}
}
],
"source": [
"samples = rand(d, 2000)"
],
"id": "82"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## GR (Plots.jl)\n",
"\n",
"``` julia\n",
"gr()\n",
"density(samples, label=\"KDE\", legend=:topleft)\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"## PythonPlot (Plots.jl)\n",
"\n",
"``` julia\n",
"pythonplot()\n",
"density(samples, label=\"KDE\", legend=:topleft)\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"## Makie.jl\n",
"\n",
"``` julia\n",
"fig = Figure()\n",
"ax = Axis(fig[1, 1], xlabel=\"Value\", ylabel=\"Density\")\n",
"Makie.density!(ax, samples)\n",
"fig\n",
"```\n",
"\n",
"\n",
"\n",
"#### DataFrame Density\n",
"\n",
"`StatsPlots.jl` also integrates with `DataFrames.jl`:"
],
"id": "2e0aada6-a30a-4ec6-9768-2de656874ecf"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/html": [
"\n",
"\n",
""
]
}
}
],
"source": [
"using DataFrames\n",
"dat = DataFrame(a = 1:10, b = 10 .+ rand(10), c = 10 .* rand(10))\n",
"@df dat density([:b :c], color=[:black :red])"
],
"id": "90"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Log-Scaled Axes"
],
"id": "61449302-fc40-4ee2-8104-a2269bad9d6e"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/plain": [
"0.1:0.1:10.0"
]
}
}
],
"source": [
"xx = 0.1:0.1:10"
],
"id": "92"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## GR (Plots.jl)\n",
"\n",
"``` julia\n",
"gr()\n",
"plot(xx, xx.^2, xaxis=:log, yaxis=:log, legend=false)\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"## PythonPlot (Plots.jl)\n",
"\n",
"``` julia\n",
"pythonplot()\n",
"plot(xx, xx.^2, xaxis=:log, yaxis=:log, legend=false)\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"## Makie.jl\n",
"\n",
"``` julia\n",
"fig = Figure()\n",
"ax = Axis(fig[1, 1], xscale=log10, yscale=log10)\n",
"lines!(ax, xx, xx .^ 2)\n",
"fig\n",
"```\n",
"\n",
""
],
"id": "3731b9f5-aa2d-43bd-92cc-3f38156343c9"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/html": [
"\n",
"\n",
""
]
}
}
],
"source": [
"plot(exp.(x), yaxis=:log)"
],
"id": "100"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Editing Plots Manually\n",
"\n",
"Now let’s look at how to modify plot attributes directly."
],
"id": "bed295bb-c462-40d8-bdd2-dcec39df8dad"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/html": [
"\n",
"\n",
""
]
}
}
],
"source": [
"pl = plot(1:4,[1, 4, 9, 16])"
],
"id": "102"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To get a list of properties we can modify, use `p.attr`:"
],
"id": "31adb4a5-dae9-414b-9be9-3b0b5bb8b852"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/plain": [
"RecipesPipeline.DefaultsDict with 30 entries:\n",
" :dpi => 96\n",
" :background_color_outside => :match\n",
" :plot_titlefontvalign => :vcenter\n",
" :warn_on_unsupported => true\n",
" :background_color => RGBA{Float64}(1.0, 1.0, 1.0, 1.0)\n",
" :inset_subplots => nothing\n",
" :size => (672, 480)\n",
" :display_type => :auto\n",
" :overwrite_figure => true\n",
" :html_output_format => :auto\n",
" :plot_titlefontfamily => :match\n",
" :plot_titleindex => 0\n",
" :foreground_color => RGB{N0f8}(0.0, 0.0, 0.0)\n",
" :window_title => \"Plots.jl\"\n",
" :plot_titlefontrotation => 0.0\n",
" :extra_plot_kwargs => Dict{Any, Any}()\n",
" :pos => (0, 0)\n",
" :plot_titlefonthalign => :hcenter\n",
" :tex_output_standalone => false\n",
" ⋮ => ⋮"
]
}
}
],
"source": [
"pl.attr"
],
"id": "104"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can also directly access properties of the plotted series."
],
"id": "988b94e2-3968-4908-a3a5-2773b857eb3a"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/plain": [
"Plots.Series(RecipesPipeline.DefaultsDict(:plot_object => Plot{Plots.PythonPlotBackend() n=1}, :subplot => Subplot{1}, :label => \"y1\", :serieshandle => Any[]>], :fillalpha => nothing, :linealpha => nothing, :linecolor => RGBA{Float64}(0.0, 0.6056031704619725, 0.9786801190138923, 1.0), :x_extrema => (NaN, NaN), :series_index => 1, :markerstrokealpha => nothing…))"
]
}
}
],
"source": [
"pl.series_list[1]"
],
"id": "106"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/plain": [
"(300, 200)"
]
}
}
],
"source": [
"pl[:size]=(300,200)"
],
"id": "108"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "display_data",
"metadata": {},
"data": {
"text/html": [
"\n",
"\n",
""
]
}
}
],
"source": [
"pl"
],
"id": "110"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Saving Plots\n",
"\n",
"To save plots to a file for inclusion in a report writeup:\n",
"\n",
"``` julia\n",
"save(\"figure.png\", p)\n",
"```"
],
"id": "a54e46e5-c919-4d72-bbad-884dc6be9f3d"
}
],
"nbformat": 4,
"nbformat_minor": 5,
"metadata": {
"kernel_info": {
"name": "julia"
},
"kernelspec": {
"name": "julia",
"display_name": "Julia",
"language": "julia"
},
"language_info": {
"name": "julia",
"codemirror_mode": "julia",
"version": "1.11.5"
}
}
}