Add files using upload-large-folder tool

testbed/matplotlib__matplotlib/ci/check_version_number.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+
+"""
+Check that the version number of the install Matplotlib does not start with 0
+
+To run:
+    $ python3 -m build .
+    $ pip install dist/matplotlib*.tar.gz for sdist
+    $ pip install dist/matplotlib*.whl for wheel
+    $ ./ci/check_version_number.py
+"""
+import sys
+
+import matplotlib
+
+
+print(f"Version {matplotlib.__version__} installed")
+if matplotlib.__version__[0] == "0":
+    sys.exit("Version incorrectly starts with 0")

testbed/matplotlib__matplotlib/ci/check_wheel_licenses.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+
+"""
+Check that all specified .whl files have the correct LICENSE files included.
+
+To run:
+    $ python3 -m build --wheel
+    $ ./ci/check_wheel_licenses.py dist/*.whl
+"""
+
+from pathlib import Path
+import sys
+import zipfile
+
+
+if len(sys.argv) <= 1:
+    sys.exit('At least one wheel must be specified in command-line arguments.')
+
+project_dir = Path(__file__).parent.resolve().parent
+license_dir = project_dir / 'LICENSE'
+
+license_file_names = {path.name for path in sorted(license_dir.glob('*'))}
+for wheel in sys.argv[1:]:
+    print(f'Checking LICENSE files in: {wheel}')
+    with zipfile.ZipFile(wheel) as f:
+        wheel_license_file_names = {Path(path).name
+                                    for path in sorted(f.namelist())
+                                    if '.dist-info/LICENSE' in path}
+        if not (len(wheel_license_file_names) and
+                wheel_license_file_names.issuperset(license_file_names)):
+            sys.exit(f'LICENSE file(s) missing:\n'
+                     f'{wheel_license_file_names} !=\n'
+                     f'{license_file_names}')

testbed/matplotlib__matplotlib/ci/codespell-ignore-words.txt

@@ -0,0 +1,23 @@
+ans
+axises
+ba
+cannotation
+ccompiler
+coo
+curvelinear
+dedented
+falsy
+flate
+fpt
+hax
+hist
+inh
+inout
+ment
+nd
+oly
+resizeable
+te
+thisy
+whis
+wit

testbed/matplotlib__matplotlib/ci/export_sdist_name.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+
+"""
+Determine the name of the sdist and export to GitHub output named SDIST_NAME.
+
+To run:
+    $ python3 -m build --sdist
+    $ ./ci/determine_sdist_name.py
+"""
+import os
+from pathlib import Path
+import sys
+
+
+paths = [p.name for p in Path("dist").glob("*.tar.gz")]
+if len(paths) != 1:
+    sys.exit(f"Only a single sdist is supported, but found: {paths}")
+
+print(paths[0])
+with open(os.environ["GITHUB_OUTPUT"], "a") as f:
+    f.write(f"SDIST_NAME={paths[0]}\n")

testbed/matplotlib__matplotlib/ci/mypy-stubtest-allowlist.txt

@@ -0,0 +1,166 @@
+# Non-typed (and private) modules/functions
+matplotlib.backends.*
+matplotlib.tests.*
+matplotlib.pylab.*
+matplotlib._.*
+matplotlib.rcsetup._listify_validator
+matplotlib.rcsetup._validate_linestyle
+matplotlib.ft2font.Glyph
+matplotlib.testing.jpl_units.*
+matplotlib.sphinxext.*
+
+# set methods have heavy dynamic usage of **kwargs, with differences for subclasses
+# which results in technically inconsistent signatures, but not actually a problem
+matplotlib.*\.set$
+
+# Typed inline, inconsistencies largely due to imports
+matplotlib.pyplot.*
+matplotlib.typing.*
+
+# Other decorator modifying signature
+# Runtime picks up  *args **kwargs, but only decorated by a decorator that uses @wraps so?
+matplotlib.axis.Axis.draw
+# Backcompat decorator which does not modify runtime reported signature
+matplotlib.offsetbox.*Offset[Bb]ox.get_offset
+
+# Inconsistent super/sub class parameter name (maybe rename for consistency)
+matplotlib.projections.polar.RadialLocator.nonsingular
+matplotlib.ticker.LogLocator.nonsingular
+matplotlib.ticker.LogitLocator.nonsingular
+
+# Stdlib/Enum considered inconsistent (no fault of ours, I don't think)
+matplotlib.backend_bases._Mode.__new__
+matplotlib.units.Number.__hash__
+
+# Property read-write vs read-only weirdness, fix if possible
+matplotlib.offsetbox.DraggableBase.canvas
+matplotlib.offsetbox.DraggableBase.cids
+matplotlib.transforms.BboxTransform.is_separable
+matplotlib.transforms.BboxTransformFrom.is_separable
+matplotlib.transforms.BboxTransformTo.is_separable
+matplotlib.transforms.BlendedAffine2D.is_separable
+matplotlib.transforms.CompositeGenericTransform.is_separable
+matplotlib.transforms.TransformWrapper.input_dims
+matplotlib.transforms.TransformWrapper.is_separable
+matplotlib.transforms.TransformWrapper.output_dims
+
+# 3.6 Pending deprecations
+matplotlib.figure.Figure.set_constrained_layout
+matplotlib.figure.Figure.set_constrained_layout_pads
+matplotlib.figure.Figure.set_tight_layout
+
+# 3.7 deprecations
+matplotlib.cm.register_cmap
+matplotlib.cm.unregister_cmap
+matplotlib.collections.PolyCollection.span_where
+matplotlib.gridspec.GridSpecBase.get_grid_positions
+matplotlib.widgets.MultiCursor.needclear
+
+# 3.8 deprecations
+matplotlib.cbook.get_sample_data
+matplotlib.contour.ContourSet.allkinds
+matplotlib.contour.ContourSet.allsegs
+matplotlib.contour.ContourSet.tcolors
+matplotlib.contour.ContourSet.tlinewidths
+matplotlib.ticker.LogLocator.__init__
+matplotlib.ticker.LogLocator.set_params
+
+# positional-only argument name lacking leading underscores
+matplotlib.axes._base._AxesBase.axis
+
+# Aliases (dynamically generated, not type hinted)
+matplotlib.collections.Collection.get_aa
+matplotlib.collections.Collection.get_antialiaseds
+matplotlib.collections.Collection.get_dashes
+matplotlib.collections.Collection.get_ec
+matplotlib.collections.Collection.get_edgecolors
+matplotlib.collections.Collection.get_facecolors
+matplotlib.collections.Collection.get_fc
+matplotlib.collections.Collection.get_linestyles
+matplotlib.collections.Collection.get_linewidths
+matplotlib.collections.Collection.get_ls
+matplotlib.collections.Collection.get_lw
+matplotlib.collections.Collection.get_transOffset
+matplotlib.collections.Collection.set_aa
+matplotlib.collections.Collection.set_antialiaseds
+matplotlib.collections.Collection.set_dashes
+matplotlib.collections.Collection.set_ec
+matplotlib.collections.Collection.set_edgecolors
+matplotlib.collections.Collection.set_facecolors
+matplotlib.collections.Collection.set_fc
+matplotlib.collections.Collection.set_linestyles
+matplotlib.collections.Collection.set_linewidths
+matplotlib.collections.Collection.set_ls
+matplotlib.collections.Collection.set_lw
+matplotlib.collections.Collection.set_transOffset
+matplotlib.lines.Line2D.get_aa
+matplotlib.lines.Line2D.get_c
+matplotlib.lines.Line2D.get_ds
+matplotlib.lines.Line2D.get_ls
+matplotlib.lines.Line2D.get_lw
+matplotlib.lines.Line2D.get_mec
+matplotlib.lines.Line2D.get_mew
+matplotlib.lines.Line2D.get_mfc
+matplotlib.lines.Line2D.get_mfcalt
+matplotlib.lines.Line2D.get_ms
+matplotlib.lines.Line2D.set_aa
+matplotlib.lines.Line2D.set_c
+matplotlib.lines.Line2D.set_ds
+matplotlib.lines.Line2D.set_ls
+matplotlib.lines.Line2D.set_lw
+matplotlib.lines.Line2D.set_mec
+matplotlib.lines.Line2D.set_mew
+matplotlib.lines.Line2D.set_mfc
+matplotlib.lines.Line2D.set_mfcalt
+matplotlib.lines.Line2D.set_ms
+matplotlib.patches.Patch.get_aa
+matplotlib.patches.Patch.get_ec
+matplotlib.patches.Patch.get_fc
+matplotlib.patches.Patch.get_ls
+matplotlib.patches.Patch.get_lw
+matplotlib.patches.Patch.set_aa
+matplotlib.patches.Patch.set_ec
+matplotlib.patches.Patch.set_fc
+matplotlib.patches.Patch.set_ls
+matplotlib.patches.Patch.set_lw
+matplotlib.text.Text.get_c
+matplotlib.text.Text.get_family
+matplotlib.text.Text.get_font
+matplotlib.text.Text.get_font_properties
+matplotlib.text.Text.get_ha
+matplotlib.text.Text.get_name
+matplotlib.text.Text.get_size
+matplotlib.text.Text.get_style
+matplotlib.text.Text.get_va
+matplotlib.text.Text.get_variant
+matplotlib.text.Text.get_weight
+matplotlib.text.Text.set_c
+matplotlib.text.Text.set_family
+matplotlib.text.Text.set_font
+matplotlib.text.Text.set_font_properties
+matplotlib.text.Text.set_ha
+matplotlib.text.Text.set_ma
+matplotlib.text.Text.set_name
+matplotlib.text.Text.set_size
+matplotlib.text.Text.set_stretch
+matplotlib.text.Text.set_style
+matplotlib.text.Text.set_va
+matplotlib.text.Text.set_variant
+matplotlib.text.Text.set_weight
+matplotlib.axes._base._AxesBase.get_fc
+matplotlib.axes._base._AxesBase.set_fc
+
+# Other dynamic python behaviors not type hinted
+matplotlib.rcsetup.defaultParams
+
+# Maybe should be abstractmethods, required for subclasses, stubs define once
+matplotlib.tri.*TriInterpolator.__call__
+matplotlib.tri.*TriInterpolator.gradient
+
+# Functionally a method call, but actually a class instance, type hinted as former
+matplotlib.rcsetup.validate_fillstyle
+
+# TypeVar used only in type hints
+matplotlib.backend_bases.FigureCanvasBase._T
+matplotlib.backend_managers.ToolManager._T
+matplotlib.spines.Spine._T

testbed/matplotlib__matplotlib/galleries/examples/README.txt

@@ -0,0 +1,16 @@
+
+.. _examples-index:
+
+.. _gallery:
+
+========
+Examples
+========
+For an overview of the plotting methods we provide, see :ref:`plot_types`
+
+This page contains example plots. Click on any image to see the full image
+and source code.
+
+For longer tutorials, see our :ref:`tutorials page <tutorials>`.
+You can also find :ref:`external resources <resources-index>` and
+a :ref:`FAQ <faq-index>` in our :ref:`user guide <users-guide-index>`.

testbed/matplotlib__matplotlib/galleries/examples/animation/README.txt

@@ -0,0 +1,6 @@
+.. _animation_examples:
+
+.. _animation-examples-index:
+
+Animation
+=========

testbed/matplotlib__matplotlib/galleries/examples/animation/animate_decay.py

@@ -0,0 +1,59 @@
+"""
+=====
+Decay
+=====
+
+This example showcases:
+
+- using a generator to drive an animation,
+- changing axes limits during an animation.
+
+Output generated via `matplotlib.animation.Animation.to_jshtml`.
+"""
+
+import itertools
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import matplotlib.animation as animation
+
+
+def data_gen():
+    for cnt in itertools.count():
+        t = cnt / 10
+        yield t, np.sin(2*np.pi*t) * np.exp(-t/10.)
+
+
+def init():
+    ax.set_ylim(-1.1, 1.1)
+    ax.set_xlim(0, 1)
+    del xdata[:]
+    del ydata[:]
+    line.set_data(xdata, ydata)
+    return line,
+
+fig, ax = plt.subplots()
+line, = ax.plot([], [], lw=2)
+ax.grid()
+xdata, ydata = [], []
+
+
+def run(data):
+    # update the data
+    t, y = data
+    xdata.append(t)
+    ydata.append(y)
+    xmin, xmax = ax.get_xlim()
+
+    if t >= xmax:
+        ax.set_xlim(xmin, 2*xmax)
+        ax.figure.canvas.draw()
+    line.set_data(xdata, ydata)
+
+    return line,
+
+# Only save last 100 frames, but run forever
+ani = animation.FuncAnimation(fig, run, data_gen, interval=100, init_func=init,
+                              save_count=100)
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/animation/animated_histogram.py

@@ -0,0 +1,57 @@
+"""
+==================
+Animated histogram
+==================
+
+Use histogram's `.BarContainer` to draw a bunch of rectangles for an animated
+histogram.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import matplotlib.animation as animation
+
+# Fixing random state for reproducibility
+np.random.seed(19680801)
+# Fixing bin edges
+HIST_BINS = np.linspace(-4, 4, 100)
+
+# histogram our data with numpy
+data = np.random.randn(1000)
+n, _ = np.histogram(data, HIST_BINS)
+
+# %%
+# To animate the histogram, we need an ``animate`` function, which generates
+# a random set of numbers and updates the heights of rectangles. We utilize a
+# python closure to track an instance of `.BarContainer` whose `.Rectangle`
+# patches we shall update.
+
+
+def prepare_animation(bar_container):
+
+    def animate(frame_number):
+        # simulate new data coming in
+        data = np.random.randn(1000)
+        n, _ = np.histogram(data, HIST_BINS)
+        for count, rect in zip(n, bar_container.patches):
+            rect.set_height(count)
+        return bar_container.patches
+    return animate
+
+# %%
+# Using :func:`~matplotlib.pyplot.hist` allows us to get an instance of
+# `.BarContainer`, which is a collection of `.Rectangle` instances. Calling
+# ``prepare_animation`` will define ``animate`` function working with supplied
+# `.BarContainer`, all this is used to setup `.FuncAnimation`.
+
+# Output generated via `matplotlib.animation.Animation.to_jshtml`.
+
+fig, ax = plt.subplots()
+_, _, bar_container = ax.hist(data, HIST_BINS, lw=1,
+                              ec="yellow", fc="green", alpha=0.5)
+ax.set_ylim(top=55)  # set safe limit to ensure that all data is visible.
+
+ani = animation.FuncAnimation(fig, prepare_animation(bar_container), 50,
+                              repeat=False, blit=True)
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/animation/animation_demo.py

@@ -0,0 +1,30 @@
+"""
+================
+pyplot animation
+================
+
+Generating an animation by calling `~.pyplot.pause` between plotting commands.
+
+The method shown here is only suitable for simple, low-performance use.  For
+more demanding applications, look at the :mod:`.animation` module and the
+examples that use it.
+
+Note that calling `time.sleep` instead of `~.pyplot.pause` would *not* work.
+
+Output generated via `matplotlib.animation.Animation.to_jshtml`.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+np.random.seed(19680801)
+data = np.random.random((50, 50, 50))
+
+fig, ax = plt.subplots()
+
+for i, img in enumerate(data):
+    ax.clear()
+    ax.imshow(img)
+    ax.set_title(f"frame {i}")
+    # Note that using time.sleep does *not* work here!
+    plt.pause(0.1)

testbed/matplotlib__matplotlib/galleries/examples/animation/bayes_update.py

@@ -0,0 +1,66 @@
+"""
+================
+The Bayes update
+================
+
+This animation displays the posterior estimate updates as it is refitted when
+new data arrives.
+The vertical line represents the theoretical value to which the plotted
+distribution should converge.
+
+Output generated via `matplotlib.animation.Animation.to_jshtml`.
+"""
+
+import math
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from matplotlib.animation import FuncAnimation
+
+
+def beta_pdf(x, a, b):
+    return (x**(a-1) * (1-x)**(b-1) * math.gamma(a + b)
+            / (math.gamma(a) * math.gamma(b)))
+
+
+class UpdateDist:
+    def __init__(self, ax, prob=0.5):
+        self.success = 0
+        self.prob = prob
+        self.line, = ax.plot([], [], 'k-')
+        self.x = np.linspace(0, 1, 200)
+        self.ax = ax
+
+        # Set up plot parameters
+        self.ax.set_xlim(0, 1)
+        self.ax.set_ylim(0, 10)
+        self.ax.grid(True)
+
+        # This vertical line represents the theoretical value, to
+        # which the plotted distribution should converge.
+        self.ax.axvline(prob, linestyle='--', color='black')
+
+    def __call__(self, i):
+        # This way the plot can continuously run and we just keep
+        # watching new realizations of the process
+        if i == 0:
+            self.success = 0
+            self.line.set_data([], [])
+            return self.line,
+
+        # Choose success based on exceed a threshold with a uniform pick
+        if np.random.rand() < self.prob:
+            self.success += 1
+        y = beta_pdf(self.x, self.success + 1, (i - self.success) + 1)
+        self.line.set_data(self.x, y)
+        return self.line,
+
+# Fixing random state for reproducibility
+np.random.seed(19680801)
+
+
+fig, ax = plt.subplots()
+ud = UpdateDist(ax, prob=0.7)
+anim = FuncAnimation(fig, ud, frames=100, interval=100, blit=True)
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/animation/double_pendulum.py

@@ -0,0 +1,117 @@
+"""
+===========================
+The double pendulum problem
+===========================
+
+This animation illustrates the double pendulum problem.
+
+Double pendulum formula translated from the C code at
+http://www.physics.usyd.edu.au/~wheat/dpend_html/solve_dpend.c
+
+Output generated via `matplotlib.animation.Animation.to_jshtml`.
+"""
+
+from collections import deque
+
+import matplotlib.pyplot as plt
+import numpy as np
+from numpy import cos, sin
+
+import matplotlib.animation as animation
+
+G = 9.8  # acceleration due to gravity, in m/s^2
+L1 = 1.0  # length of pendulum 1 in m
+L2 = 1.0  # length of pendulum 2 in m
+L = L1 + L2  # maximal length of the combined pendulum
+M1 = 1.0  # mass of pendulum 1 in kg
+M2 = 1.0  # mass of pendulum 2 in kg
+t_stop = 2.5  # how many seconds to simulate
+history_len = 500  # how many trajectory points to display
+
+
+def derivs(t, state):
+    dydx = np.zeros_like(state)
+
+    dydx[0] = state[1]
+
+    delta = state[2] - state[0]
+    den1 = (M1+M2) * L1 - M2 * L1 * cos(delta) * cos(delta)
+    dydx[1] = ((M2 * L1 * state[1] * state[1] * sin(delta) * cos(delta)
+                + M2 * G * sin(state[2]) * cos(delta)
+                + M2 * L2 * state[3] * state[3] * sin(delta)
+                - (M1+M2) * G * sin(state[0]))
+               / den1)
+
+    dydx[2] = state[3]
+
+    den2 = (L2/L1) * den1
+    dydx[3] = ((- M2 * L2 * state[3] * state[3] * sin(delta) * cos(delta)
+                + (M1+M2) * G * sin(state[0]) * cos(delta)
+                - (M1+M2) * L1 * state[1] * state[1] * sin(delta)
+                - (M1+M2) * G * sin(state[2]))
+               / den2)
+
+    return dydx
+
+# create a time array from 0..t_stop sampled at 0.02 second steps
+dt = 0.01
+t = np.arange(0, t_stop, dt)
+
+# th1 and th2 are the initial angles (degrees)
+# w10 and w20 are the initial angular velocities (degrees per second)
+th1 = 120.0
+w1 = 0.0
+th2 = -10.0
+w2 = 0.0
+
+# initial state
+state = np.radians([th1, w1, th2, w2])
+
+# integrate the ODE using Euler's method
+y = np.empty((len(t), 4))
+y[0] = state
+for i in range(1, len(t)):
+    y[i] = y[i - 1] + derivs(t[i - 1], y[i - 1]) * dt
+
+# A more accurate estimate could be obtained e.g. using scipy:
+#
+#   y = scipy.integrate.solve_ivp(derivs, t[[0, -1]], state, t_eval=t).y.T
+
+x1 = L1*sin(y[:, 0])
+y1 = -L1*cos(y[:, 0])
+
+x2 = L2*sin(y[:, 2]) + x1
+y2 = -L2*cos(y[:, 2]) + y1
+
+fig = plt.figure(figsize=(5, 4))
+ax = fig.add_subplot(autoscale_on=False, xlim=(-L, L), ylim=(-L, 1.))
+ax.set_aspect('equal')
+ax.grid()
+
+line, = ax.plot([], [], 'o-', lw=2)
+trace, = ax.plot([], [], '.-', lw=1, ms=2)
+time_template = 'time = %.1fs'
+time_text = ax.text(0.05, 0.9, '', transform=ax.transAxes)
+history_x, history_y = deque(maxlen=history_len), deque(maxlen=history_len)
+
+
+def animate(i):
+    thisx = [0, x1[i], x2[i]]
+    thisy = [0, y1[i], y2[i]]
+
+    if i == 0:
+        history_x.clear()
+        history_y.clear()
+
+    history_x.appendleft(thisx[2])
+    history_y.appendleft(thisy[2])
+
+    line.set_data(thisx, thisy)
+    trace.set_data(history_x, history_y)
+    time_text.set_text(time_template % (i*dt))
+    return line, trace, time_text
+
+
+ani = animation.FuncAnimation(
+    fig, animate, len(y), interval=dt*1000, blit=True)
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/animation/dynamic_image.py

@@ -0,0 +1,48 @@
+"""
+=================================================
+Animated image using a precomputed list of images
+=================================================
+
+Output generated via `matplotlib.animation.Animation.to_jshtml`.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import matplotlib.animation as animation
+
+fig, ax = plt.subplots()
+
+
+def f(x, y):
+    return np.sin(x) + np.cos(y)
+
+x = np.linspace(0, 2 * np.pi, 120)
+y = np.linspace(0, 2 * np.pi, 100).reshape(-1, 1)
+
+# ims is a list of lists, each row is a list of artists to draw in the
+# current frame; here we are just animating one artist, the image, in
+# each frame
+ims = []
+for i in range(60):
+    x += np.pi / 15
+    y += np.pi / 30
+    im = ax.imshow(f(x, y), animated=True)
+    if i == 0:
+        ax.imshow(f(x, y))  # show an initial one first
+    ims.append([im])
+
+ani = animation.ArtistAnimation(fig, ims, interval=50, blit=True,
+                                repeat_delay=1000)
+
+# To save the animation, use e.g.
+#
+# ani.save("movie.mp4")
+#
+# or
+#
+# writer = animation.FFMpegWriter(
+#     fps=15, metadata=dict(artist='Me'), bitrate=1800)
+# ani.save("movie.mp4", writer=writer)
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/animation/frame_grabbing_sgskip.py

@@ -0,0 +1,43 @@
+"""
+==============
+Frame grabbing
+==============
+
+Use a MovieWriter directly to grab individual frames and write them to a
+file.  This avoids any event loop integration, and thus works even with the Agg
+backend.  This is not recommended for use in an interactive setting.
+
+Output generated via `matplotlib.animation.Animation.to_jshtml`.
+"""
+
+import numpy as np
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+from matplotlib.animation import FFMpegWriter
+
+# Fixing random state for reproducibility
+np.random.seed(19680801)
+
+
+metadata = dict(title='Movie Test', artist='Matplotlib',
+                comment='Movie support!')
+writer = FFMpegWriter(fps=15, metadata=metadata)
+
+fig = plt.figure()
+l, = plt.plot([], [], 'k-o')
+
+plt.xlim(-5, 5)
+plt.ylim(-5, 5)
+
+x0, y0 = 0, 0
+
+with writer.saving(fig, "writer_test.mp4", 100):
+    for i in range(100):
+        x0 += 0.1 * np.random.randn()
+        y0 += 0.1 * np.random.randn()
+        l.set_data(x0, y0)
+        writer.grab_frame()

testbed/matplotlib__matplotlib/galleries/examples/animation/multiple_axes.py

@@ -0,0 +1,82 @@
+"""
+=======================
+Multiple axes animation
+=======================
+
+This example showcases:
+
+- how animation across multiple subplots works,
+- using a figure artist in the animation.
+
+Output generated via `matplotlib.animation.Animation.to_jshtml`.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import matplotlib.animation as animation
+from matplotlib.patches import ConnectionPatch
+
+fig, (axl, axr) = plt.subplots(
+    ncols=2,
+    sharey=True,
+    figsize=(6, 2),
+    gridspec_kw=dict(width_ratios=[1, 3], wspace=0),
+)
+axl.set_aspect(1)
+axr.set_box_aspect(1 / 3)
+axr.yaxis.set_visible(False)
+axr.xaxis.set_ticks([0, np.pi, 2 * np.pi], ["0", r"$\pi$", r"$2\pi$"])
+
+# draw circle with initial point in left Axes
+x = np.linspace(0, 2 * np.pi, 50)
+axl.plot(np.cos(x), np.sin(x), "k", lw=0.3)
+point, = axl.plot(0, 0, "o")
+
+# draw full curve to set view limits in right Axes
+sine, = axr.plot(x, np.sin(x))
+
+# draw connecting line between both graphs
+con = ConnectionPatch(
+    (1, 0),
+    (0, 0),
+    "data",
+    "data",
+    axesA=axl,
+    axesB=axr,
+    color="C0",
+    ls="dotted",
+)
+fig.add_artist(con)
+
+
+def animate(i):
+    x = np.linspace(0, i, int(i * 25 / np.pi))
+    sine.set_data(x, np.sin(x))
+    x, y = np.cos(i), np.sin(i)
+    point.set_data([x], [y])
+    con.xy1 = x, y
+    con.xy2 = i, y
+    return point, sine, con
+
+
+ani = animation.FuncAnimation(
+    fig,
+    animate,
+    interval=50,
+    blit=False,  # blitting can't be used with Figure artists
+    frames=x,
+    repeat_delay=100,
+)
+
+plt.show()
+
+# %%
+#
+# .. admonition:: References
+#
+#    The use of the following functions, methods, classes and modules is shown
+#    in this example:
+#
+#    - `matplotlib.patches.ConnectionPatch`
+#    - `matplotlib.animation.FuncAnimation`

testbed/matplotlib__matplotlib/galleries/examples/animation/pause_resume.py

@@ -0,0 +1,59 @@
+"""
+=================================
+Pausing and Resuming an Animation
+=================================
+
+This example showcases:
+
+- using the Animation.pause() method to pause an animation.
+- using the Animation.resume() method to resume an animation.
+
+.. note::
+    This example exercises the interactive capabilities of Matplotlib, and this
+    will not appear in the static documentation. Please run this code on your
+    machine to see the interactivity.
+
+    You can copy and paste individual parts, or download the entire example
+    using the link at the bottom of the page.
+
+Output generated via `matplotlib.animation.Animation.to_jshtml`.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import matplotlib.animation as animation
+
+
+class PauseAnimation:
+    def __init__(self):
+        fig, ax = plt.subplots()
+        ax.set_title('Click to pause/resume the animation')
+        x = np.linspace(-0.1, 0.1, 1000)
+
+        # Start with a normal distribution
+        self.n0 = (1.0 / ((4 * np.pi * 2e-4 * 0.1) ** 0.5)
+                   * np.exp(-x ** 2 / (4 * 2e-4 * 0.1)))
+        self.p, = ax.plot(x, self.n0)
+
+        self.animation = animation.FuncAnimation(
+            fig, self.update, frames=200, interval=50, blit=True)
+        self.paused = False
+
+        fig.canvas.mpl_connect('button_press_event', self.toggle_pause)
+
+    def toggle_pause(self, *args, **kwargs):
+        if self.paused:
+            self.animation.resume()
+        else:
+            self.animation.pause()
+        self.paused = not self.paused
+
+    def update(self, i):
+        self.n0 += i / 100 % 5
+        self.p.set_ydata(self.n0 % 20)
+        return (self.p,)
+
+
+pa = PauseAnimation()
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/animation/rain.py

@@ -0,0 +1,74 @@
+"""
+===============
+Rain simulation
+===============
+
+Simulates rain drops on a surface by animating the scale and opacity
+of 50 scatter points.
+
+Author: Nicolas P. Rougier
+
+Output generated via `matplotlib.animation.Animation.to_jshtml`.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from matplotlib.animation import FuncAnimation
+
+# Fixing random state for reproducibility
+np.random.seed(19680801)
+
+
+# Create new Figure and an Axes which fills it.
+fig = plt.figure(figsize=(7, 7))
+ax = fig.add_axes([0, 0, 1, 1], frameon=False)
+ax.set_xlim(0, 1), ax.set_xticks([])
+ax.set_ylim(0, 1), ax.set_yticks([])
+
+# Create rain data
+n_drops = 50
+rain_drops = np.zeros(n_drops, dtype=[('position', float, (2,)),
+                                      ('size',     float),
+                                      ('growth',   float),
+                                      ('color',    float, (4,))])
+
+# Initialize the raindrops in random positions and with
+# random growth rates.
+rain_drops['position'] = np.random.uniform(0, 1, (n_drops, 2))
+rain_drops['growth'] = np.random.uniform(50, 200, n_drops)
+
+# Construct the scatter which we will update during animation
+# as the raindrops develop.
+scat = ax.scatter(rain_drops['position'][:, 0], rain_drops['position'][:, 1],
+                  s=rain_drops['size'], lw=0.5, edgecolors=rain_drops['color'],
+                  facecolors='none')
+
+
+def update(frame_number):
+    # Get an index which we can use to re-spawn the oldest raindrop.
+    current_index = frame_number % n_drops
+
+    # Make all colors more transparent as time progresses.
+    rain_drops['color'][:, 3] -= 1.0/len(rain_drops)
+    rain_drops['color'][:, 3] = np.clip(rain_drops['color'][:, 3], 0, 1)
+
+    # Make all circles bigger.
+    rain_drops['size'] += rain_drops['growth']
+
+    # Pick a new position for oldest rain drop, resetting its size,
+    # color and growth factor.
+    rain_drops['position'][current_index] = np.random.uniform(0, 1, 2)
+    rain_drops['size'][current_index] = 5
+    rain_drops['color'][current_index] = (0, 0, 0, 1)
+    rain_drops['growth'][current_index] = np.random.uniform(50, 200)
+
+    # Update the scatter collection, with the new colors, sizes and positions.
+    scat.set_edgecolors(rain_drops['color'])
+    scat.set_sizes(rain_drops['size'])
+    scat.set_offsets(rain_drops['position'])
+
+
+# Construct the animation, using the update function as the animation director.
+animation = FuncAnimation(fig, update, interval=10, save_count=100)
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/animation/random_walk.py

@@ -0,0 +1,54 @@
+"""
+=======================
+Animated 3D random walk
+=======================
+
+Output generated via `matplotlib.animation.Animation.to_jshtml`.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import matplotlib.animation as animation
+
+# Fixing random state for reproducibility
+np.random.seed(19680801)
+
+
+def random_walk(num_steps, max_step=0.05):
+    """Return a 3D random walk as (num_steps, 3) array."""
+    start_pos = np.random.random(3)
+    steps = np.random.uniform(-max_step, max_step, size=(num_steps, 3))
+    walk = start_pos + np.cumsum(steps, axis=0)
+    return walk
+
+
+def update_lines(num, walks, lines):
+    for line, walk in zip(lines, walks):
+        # NOTE: there is no .set_data() for 3 dim data...
+        line.set_data(walk[:num, :2].T)
+        line.set_3d_properties(walk[:num, 2])
+    return lines
+
+
+# Data: 40 random walks as (num_steps, 3) arrays
+num_steps = 30
+walks = [random_walk(num_steps) for index in range(40)]
+
+# Attaching 3D axis to the figure
+fig = plt.figure()
+ax = fig.add_subplot(projection="3d")
+
+# Create lines initially without data
+lines = [ax.plot([], [], [])[0] for _ in walks]
+
+# Setting the axes properties
+ax.set(xlim3d=(0, 1), xlabel='X')
+ax.set(ylim3d=(0, 1), ylabel='Y')
+ax.set(zlim3d=(0, 1), zlabel='Z')
+
+# Creating the Animation object
+ani = animation.FuncAnimation(
+    fig, update_lines, num_steps, fargs=(walks, lines), interval=100)
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/animation/simple_anim.py

@@ -0,0 +1,38 @@
+"""
+==================
+Animated line plot
+==================
+
+Output generated via `matplotlib.animation.Animation.to_jshtml`.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import matplotlib.animation as animation
+
+fig, ax = plt.subplots()
+
+x = np.arange(0, 2*np.pi, 0.01)
+line, = ax.plot(x, np.sin(x))
+
+
+def animate(i):
+    line.set_ydata(np.sin(x + i / 50))  # update the data.
+    return line,
+
+
+ani = animation.FuncAnimation(
+    fig, animate, interval=20, blit=True, save_count=50)
+
+# To save the animation, use e.g.
+#
+# ani.save("movie.mp4")
+#
+# or
+#
+# writer = animation.FFMpegWriter(
+#     fps=15, metadata=dict(artist='Me'), bitrate=1800)
+# ani.save("movie.mp4", writer=writer)
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/animation/simple_scatter.py

@@ -0,0 +1,33 @@
+"""
+=============================
+Animated scatter saved as GIF
+=============================
+
+Output generated via `matplotlib.animation.Animation.to_jshtml`.
+"""
+import matplotlib.pyplot as plt
+import numpy as np
+
+import matplotlib.animation as animation
+
+fig, ax = plt.subplots()
+ax.set_xlim([0, 10])
+
+scat = ax.scatter(1, 0)
+x = np.linspace(0, 10)
+
+
+def animate(i):
+    scat.set_offsets((x[i], 0))
+    return scat,
+
+ani = animation.FuncAnimation(fig, animate, repeat=True,
+                                    frames=len(x) - 1, interval=50)
+
+# To save the animation using Pillow as a gif
+# writer = animation.PillowWriter(fps=15,
+#                                 metadata=dict(artist='Me'),
+#                                 bitrate=1800)
+# ani.save('scatter.gif', writer=writer)
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/animation/strip_chart.py

@@ -0,0 +1,69 @@
+"""
+============
+Oscilloscope
+============
+
+Emulates an oscilloscope.
+
+Output generated via `matplotlib.animation.Animation.to_jshtml`.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import matplotlib.animation as animation
+from matplotlib.lines import Line2D
+
+
+class Scope:
+    def __init__(self, ax, maxt=2, dt=0.02):
+        self.ax = ax
+        self.dt = dt
+        self.maxt = maxt
+        self.tdata = [0]
+        self.ydata = [0]
+        self.line = Line2D(self.tdata, self.ydata)
+        self.ax.add_line(self.line)
+        self.ax.set_ylim(-.1, 1.1)
+        self.ax.set_xlim(0, self.maxt)
+
+    def update(self, y):
+        lastt = self.tdata[-1]
+        if lastt >= self.tdata[0] + self.maxt:  # reset the arrays
+            self.tdata = [self.tdata[-1]]
+            self.ydata = [self.ydata[-1]]
+            self.ax.set_xlim(self.tdata[0], self.tdata[0] + self.maxt)
+            self.ax.figure.canvas.draw()
+
+        # This slightly more complex calculation avoids floating-point issues
+        # from just repeatedly adding `self.dt` to the previous value.
+        t = self.tdata[0] + len(self.tdata) * self.dt
+
+        self.tdata.append(t)
+        self.ydata.append(y)
+        self.line.set_data(self.tdata, self.ydata)
+        return self.line,
+
+
+def emitter(p=0.1):
+    """Return a random value in [0, 1) with probability p, else 0."""
+    while True:
+        v = np.random.rand()
+        if v > p:
+            yield 0.
+        else:
+            yield np.random.rand()
+
+
+# Fixing random state for reproducibility
+np.random.seed(19680801 // 10)
+
+
+fig, ax = plt.subplots()
+scope = Scope(ax)
+
+# pass a generator in "emitter" to produce data for the update func
+ani = animation.FuncAnimation(fig, scope.update, emitter, interval=50,
+                              blit=True, save_count=100)
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/animation/unchained.py

@@ -0,0 +1,76 @@
+"""
+========================
+MATPLOTLIB **UNCHAINED**
+========================
+
+Comparative path demonstration of frequency from a fake signal of a pulsar
+(mostly known because of the cover for Joy Division's Unknown Pleasures).
+
+Author: Nicolas P. Rougier
+
+Output generated via `matplotlib.animation.Animation.to_jshtml`.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import matplotlib.animation as animation
+
+# Fixing random state for reproducibility
+np.random.seed(19680801)
+
+
+# Create new Figure with black background
+fig = plt.figure(figsize=(8, 8), facecolor='black')
+
+# Add a subplot with no frame
+ax = plt.subplot(frameon=False)
+
+# Generate random data
+data = np.random.uniform(0, 1, (64, 75))
+X = np.linspace(-1, 1, data.shape[-1])
+G = 1.5 * np.exp(-4 * X ** 2)
+
+# Generate line plots
+lines = []
+for i in range(len(data)):
+    # Small reduction of the X extents to get a cheap perspective effect
+    xscale = 1 - i / 200.
+    # Same for linewidth (thicker strokes on bottom)
+    lw = 1.5 - i / 100.0
+    line, = ax.plot(xscale * X, i + G * data[i], color="w", lw=lw)
+    lines.append(line)
+
+# Set y limit (or first line is cropped because of thickness)
+ax.set_ylim(-1, 70)
+
+# No ticks
+ax.set_xticks([])
+ax.set_yticks([])
+
+# 2 part titles to get different font weights
+ax.text(0.5, 1.0, "MATPLOTLIB ", transform=ax.transAxes,
+        ha="right", va="bottom", color="w",
+        family="sans-serif", fontweight="light", fontsize=16)
+ax.text(0.5, 1.0, "UNCHAINED", transform=ax.transAxes,
+        ha="left", va="bottom", color="w",
+        family="sans-serif", fontweight="bold", fontsize=16)
+
+
+def update(*args):
+    # Shift all data to the right
+    data[:, 1:] = data[:, :-1]
+
+    # Fill-in new values
+    data[:, 0] = np.random.uniform(0, 1, len(data))
+
+    # Update data
+    for i in range(len(data)):
+        lines[i].set_ydata(i + G * data[i])
+
+    # Return modified artists
+    return lines
+
+# Construct the animation, using the update function as the animation director.
+anim = animation.FuncAnimation(fig, update, interval=10, save_count=100)
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/README.txt

@@ -0,0 +1,6 @@
+.. _axes_grid_examples:
+
+.. _axes_grid1-examples-index:
+
+Module - axes_grid1
+===================

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/demo_anchored_direction_arrows.py

@@ -0,0 +1,82 @@
+"""
+========================
+Anchored Direction Arrow
+========================
+
+"""
+import matplotlib.pyplot as plt
+import numpy as np
+
+import matplotlib.font_manager as fm
+from mpl_toolkits.axes_grid1.anchored_artists import AnchoredDirectionArrows
+
+# Fixing random state for reproducibility
+np.random.seed(19680801)
+
+fig, ax = plt.subplots()
+ax.imshow(np.random.random((10, 10)))
+
+# Simple example
+simple_arrow = AnchoredDirectionArrows(ax.transAxes, 'X', 'Y')
+ax.add_artist(simple_arrow)
+
+# High contrast arrow
+high_contrast_part_1 = AnchoredDirectionArrows(
+                            ax.transAxes,
+                            '111', r'11$\overline{2}$',
+                            loc='upper right',
+                            arrow_props={'ec': 'w', 'fc': 'none', 'alpha': 1,
+                                         'lw': 2}
+                            )
+ax.add_artist(high_contrast_part_1)
+
+high_contrast_part_2 = AnchoredDirectionArrows(
+                            ax.transAxes,
+                            '111', r'11$\overline{2}$',
+                            loc='upper right',
+                            arrow_props={'ec': 'none', 'fc': 'k'},
+                            text_props={'ec': 'w', 'fc': 'k', 'lw': 0.4}
+                            )
+ax.add_artist(high_contrast_part_2)
+
+# Rotated arrow
+fontprops = fm.FontProperties(family='serif')
+
+rotated_arrow = AnchoredDirectionArrows(
+                    ax.transAxes,
+                    '30', '120',
+                    loc='center',
+                    color='w',
+                    angle=30,
+                    fontproperties=fontprops
+                    )
+ax.add_artist(rotated_arrow)
+
+# Altering arrow directions
+a1 = AnchoredDirectionArrows(
+        ax.transAxes, 'A', 'B', loc='lower center',
+        length=-0.15,
+        sep_x=0.03, sep_y=0.03,
+        color='r'
+    )
+ax.add_artist(a1)
+
+a2 = AnchoredDirectionArrows(
+        ax.transAxes, 'A', ' B', loc='lower left',
+        aspect_ratio=-1,
+        sep_x=0.01, sep_y=-0.02,
+        color='orange'
+        )
+ax.add_artist(a2)
+
+
+a3 = AnchoredDirectionArrows(
+        ax.transAxes, ' A', 'B', loc='lower right',
+        length=-0.15,
+        aspect_ratio=-1,
+        sep_y=-0.1, sep_x=0.04,
+        color='cyan'
+        )
+ax.add_artist(a3)
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/demo_axes_divider.py

@@ -0,0 +1,109 @@
+"""
+============
+Axes divider
+============
+
+Axes divider to calculate location of axes and
+create a divider for them using existing axes instances.
+"""
+
+import matplotlib.pyplot as plt
+
+from matplotlib import cbook
+
+
+def get_demo_image():
+    z = cbook.get_sample_data("axes_grid/bivariate_normal.npy")  # 15x15 array
+    return z, (-3, 4, -4, 3)
+
+
+def demo_simple_image(ax):
+    Z, extent = get_demo_image()
+
+    im = ax.imshow(Z, extent=extent)
+    cb = plt.colorbar(im)
+    cb.ax.yaxis.set_tick_params(labelright=False)
+
+
+def demo_locatable_axes_hard(fig):
+    from mpl_toolkits.axes_grid1 import Size, SubplotDivider
+
+    divider = SubplotDivider(fig, 2, 2, 2, aspect=True)
+
+    # axes for image
+    ax = fig.add_subplot(axes_locator=divider.new_locator(nx=0, ny=0))
+    # axes for colorbar
+    ax_cb = fig.add_subplot(axes_locator=divider.new_locator(nx=2, ny=0))
+
+    divider.set_horizontal([
+        Size.AxesX(ax),  # main axes
+        Size.Fixed(0.05),  # padding, 0.1 inch
+        Size.Fixed(0.2),  # colorbar, 0.3 inch
+    ])
+    divider.set_vertical([Size.AxesY(ax)])
+
+    Z, extent = get_demo_image()
+
+    im = ax.imshow(Z, extent=extent)
+    plt.colorbar(im, cax=ax_cb)
+    ax_cb.yaxis.set_tick_params(labelright=False)
+
+
+def demo_locatable_axes_easy(ax):
+    from mpl_toolkits.axes_grid1 import make_axes_locatable
+
+    divider = make_axes_locatable(ax)
+
+    ax_cb = divider.append_axes("right", size="5%", pad=0.05)
+    fig = ax.get_figure()
+    fig.add_axes(ax_cb)
+
+    Z, extent = get_demo_image()
+    im = ax.imshow(Z, extent=extent)
+
+    plt.colorbar(im, cax=ax_cb)
+    ax_cb.yaxis.tick_right()
+    ax_cb.yaxis.set_tick_params(labelright=False)
+
+
+def demo_images_side_by_side(ax):
+    from mpl_toolkits.axes_grid1 import make_axes_locatable
+
+    divider = make_axes_locatable(ax)
+
+    Z, extent = get_demo_image()
+    ax2 = divider.append_axes("right", size="100%", pad=0.05)
+    fig1 = ax.get_figure()
+    fig1.add_axes(ax2)
+
+    ax.imshow(Z, extent=extent)
+    ax2.imshow(Z, extent=extent)
+    ax2.yaxis.set_tick_params(labelleft=False)
+
+
+def demo():
+    fig = plt.figure(figsize=(6, 6))
+
+    # PLOT 1
+    # simple image & colorbar
+    ax = fig.add_subplot(2, 2, 1)
+    demo_simple_image(ax)
+
+    # PLOT 2
+    # image and colorbar with draw-time positioning -- a hard way
+    demo_locatable_axes_hard(fig)
+
+    # PLOT 3
+    # image and colorbar with draw-time positioning -- an easy way
+    ax = fig.add_subplot(2, 2, 3)
+    demo_locatable_axes_easy(ax)
+
+    # PLOT 4
+    # two images side by side with fixed padding.
+    ax = fig.add_subplot(2, 2, 4)
+    demo_images_side_by_side(ax)
+
+    plt.show()
+
+
+demo()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/demo_axes_grid.py

@@ -0,0 +1,72 @@
+"""
+==============
+Demo Axes Grid
+==============
+
+Grid of 2x2 images with a single colorbar or with one colorbar per axes.
+"""
+
+import matplotlib.pyplot as plt
+
+from matplotlib import cbook
+from mpl_toolkits.axes_grid1 import ImageGrid
+
+fig = plt.figure(figsize=(10.5, 2.5))
+Z = cbook.get_sample_data("axes_grid/bivariate_normal.npy")  # 15x15 array
+extent = (-3, 4, -4, 3)
+
+
+# A grid of 2x2 images with 0.05 inch pad between images and only the
+# lower-left axes is labeled.
+grid = ImageGrid(
+    fig, 141,  # similar to fig.add_subplot(141).
+     nrows_ncols=(2, 2), axes_pad=0.05, label_mode="1")
+for ax in grid:
+    ax.imshow(Z, extent=extent)
+# This only affects axes in first column and second row as share_all=False.
+grid.axes_llc.set(xticks=[-2, 0, 2], yticks=[-2, 0, 2])
+
+
+# A grid of 2x2 images with a single colorbar.
+grid = ImageGrid(
+    fig, 142,  # similar to fig.add_subplot(142).
+    nrows_ncols=(2, 2), axes_pad=0.0, label_mode="L", share_all=True,
+    cbar_location="top", cbar_mode="single")
+for ax in grid:
+    im = ax.imshow(Z, extent=extent)
+grid.cbar_axes[0].colorbar(im)
+for cax in grid.cbar_axes:
+    cax.tick_params(labeltop=False)
+# This affects all axes as share_all = True.
+grid.axes_llc.set(xticks=[-2, 0, 2], yticks=[-2, 0, 2])
+
+
+# A grid of 2x2 images. Each image has its own colorbar.
+grid = ImageGrid(
+    fig, 143,  # similar to fig.add_subplot(143).
+    nrows_ncols=(2, 2), axes_pad=0.1, label_mode="1", share_all=True,
+    cbar_location="top", cbar_mode="each", cbar_size="7%", cbar_pad="2%")
+for ax, cax in zip(grid, grid.cbar_axes):
+    im = ax.imshow(Z, extent=extent)
+    cax.colorbar(im)
+    cax.tick_params(labeltop=False)
+# This affects all axes as share_all = True.
+grid.axes_llc.set(xticks=[-2, 0, 2], yticks=[-2, 0, 2])
+
+
+# A grid of 2x2 images. Each image has its own colorbar.
+grid = ImageGrid(
+    fig, 144,  # similar to fig.add_subplot(144).
+    nrows_ncols=(2, 2), axes_pad=(0.45, 0.15), label_mode="1", share_all=True,
+    cbar_location="right", cbar_mode="each", cbar_size="7%", cbar_pad="2%")
+# Use a different colorbar range every time
+limits = ((0, 1), (-2, 2), (-1.7, 1.4), (-1.5, 1))
+for ax, cax, vlim in zip(grid, grid.cbar_axes, limits):
+    im = ax.imshow(Z, extent=extent, vmin=vlim[0], vmax=vlim[1])
+    cb = cax.colorbar(im)
+    cb.set_ticks((vlim[0], vlim[1]))
+# This affects all axes as share_all = True.
+grid.axes_llc.set(xticks=[-2, 0, 2], yticks=[-2, 0, 2])
+
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/demo_axes_grid2.py

@@ -0,0 +1,69 @@
+"""
+==========
+Axes Grid2
+==========
+
+Grid of images with shared xaxis and yaxis.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from matplotlib import cbook
+from mpl_toolkits.axes_grid1 import ImageGrid
+
+
+def add_inner_title(ax, title, loc, **kwargs):
+    from matplotlib.offsetbox import AnchoredText
+    from matplotlib.patheffects import withStroke
+    prop = dict(path_effects=[withStroke(foreground='w', linewidth=3)],
+                size=plt.rcParams['legend.fontsize'])
+    at = AnchoredText(title, loc=loc, prop=prop,
+                      pad=0., borderpad=0.5,
+                      frameon=False, **kwargs)
+    ax.add_artist(at)
+    return at
+
+
+fig = plt.figure(figsize=(6, 6))
+
+# Prepare images
+Z = cbook.get_sample_data("axes_grid/bivariate_normal.npy")
+extent = (-3, 4, -4, 3)
+ZS = [Z[i::3, :] for i in range(3)]
+extent = extent[0], extent[1]/3., extent[2], extent[3]
+
+# *** Demo 1: colorbar at each axes ***
+grid = ImageGrid(
+    # 211 = at the position of fig.add_subplot(211)
+    fig, 211, nrows_ncols=(1, 3), axes_pad=0.05, label_mode="1", share_all=True,
+    cbar_location="top", cbar_mode="each", cbar_size="7%", cbar_pad="1%")
+grid[0].set(xticks=[-2, 0], yticks=[-2, 0, 2])
+
+for i, (ax, z) in enumerate(zip(grid, ZS)):
+    im = ax.imshow(z, origin="lower", extent=extent)
+    cb = ax.cax.colorbar(im)
+    # Changing the colorbar ticks
+    if i in [1, 2]:
+        cb.set_ticks([-1, 0, 1])
+
+for ax, im_title in zip(grid, ["Image 1", "Image 2", "Image 3"]):
+    add_inner_title(ax, im_title, loc='lower left')
+
+# *** Demo 2: shared colorbar ***
+grid2 = ImageGrid(
+    fig, 212, nrows_ncols=(1, 3), axes_pad=0.05, label_mode="1", share_all=True,
+    cbar_location="right", cbar_mode="single", cbar_size="10%", cbar_pad=0.05)
+grid2[0].set(xlabel="X", ylabel="Y", xticks=[-2, 0], yticks=[-2, 0, 2])
+
+clim = (np.min(ZS), np.max(ZS))
+for ax, z in zip(grid2, ZS):
+    im = ax.imshow(z, clim=clim, origin="lower", extent=extent)
+
+# With cbar_mode="single", cax attribute of all axes are identical.
+ax.cax.colorbar(im)
+
+for ax, im_title in zip(grid2, ["(a)", "(b)", "(c)"]):
+    add_inner_title(ax, im_title, loc='upper left')
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/demo_axes_hbox_divider.py

@@ -0,0 +1,54 @@
+"""
+================================
+HBoxDivider and VBoxDivider demo
+================================
+
+Using an `.HBoxDivider` to arrange subplots.
+
+Note that both axes' location are adjusted so that they have
+equal heights while maintaining their aspect ratios.
+
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from mpl_toolkits.axes_grid1.axes_divider import HBoxDivider, VBoxDivider
+import mpl_toolkits.axes_grid1.axes_size as Size
+
+arr1 = np.arange(20).reshape((4, 5))
+arr2 = np.arange(20).reshape((5, 4))
+
+fig, (ax1, ax2) = plt.subplots(1, 2)
+ax1.imshow(arr1)
+ax2.imshow(arr2)
+
+pad = 0.5  # pad in inches
+divider = HBoxDivider(
+    fig, 111,
+    horizontal=[Size.AxesX(ax1), Size.Fixed(pad), Size.AxesX(ax2)],
+    vertical=[Size.AxesY(ax1), Size.Scaled(1), Size.AxesY(ax2)])
+ax1.set_axes_locator(divider.new_locator(0))
+ax2.set_axes_locator(divider.new_locator(2))
+
+plt.show()
+
+# %%
+# Using a `.VBoxDivider` to arrange subplots.
+#
+# Note that both axes' location are adjusted so that they have
+# equal widths while maintaining their aspect ratios.
+
+fig, (ax1, ax2) = plt.subplots(2, 1)
+ax1.imshow(arr1)
+ax2.imshow(arr2)
+
+divider = VBoxDivider(
+    fig, 111,
+    horizontal=[Size.AxesX(ax1), Size.Scaled(1), Size.AxesX(ax2)],
+    vertical=[Size.AxesY(ax1), Size.Fixed(pad), Size.AxesY(ax2)])
+
+ax1.set_axes_locator(divider.new_locator(0))
+ax2.set_axes_locator(divider.new_locator(2))
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/demo_axes_rgb.py

@@ -0,0 +1,70 @@
+"""
+==================================
+Showing RGB channels using RGBAxes
+==================================
+
+`~.axes_grid1.axes_rgb.RGBAxes` creates a layout of 4 Axes for displaying RGB
+channels: one large Axes for the RGB image and 3 smaller Axes for the R, G, B
+channels.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from matplotlib import cbook
+from mpl_toolkits.axes_grid1.axes_rgb import RGBAxes, make_rgb_axes
+
+
+def get_rgb():
+    Z = cbook.get_sample_data("axes_grid/bivariate_normal.npy")
+    Z[Z < 0] = 0.
+    Z = Z / Z.max()
+
+    R = Z[:13, :13]
+    G = Z[2:, 2:]
+    B = Z[:13, 2:]
+
+    return R, G, B
+
+
+def make_cube(r, g, b):
+    ny, nx = r.shape
+    R = np.zeros((ny, nx, 3))
+    R[:, :, 0] = r
+    G = np.zeros_like(R)
+    G[:, :, 1] = g
+    B = np.zeros_like(R)
+    B[:, :, 2] = b
+
+    RGB = R + G + B
+
+    return R, G, B, RGB
+
+
+def demo_rgb1():
+    fig = plt.figure()
+    ax = RGBAxes(fig, [0.1, 0.1, 0.8, 0.8], pad=0.0)
+    r, g, b = get_rgb()
+    ax.imshow_rgb(r, g, b)
+
+
+def demo_rgb2():
+    fig, ax = plt.subplots()
+    ax_r, ax_g, ax_b = make_rgb_axes(ax, pad=0.02)
+
+    r, g, b = get_rgb()
+    im_r, im_g, im_b, im_rgb = make_cube(r, g, b)
+    ax.imshow(im_rgb)
+    ax_r.imshow(im_r)
+    ax_g.imshow(im_g)
+    ax_b.imshow(im_b)
+
+    for ax in fig.axes:
+        ax.tick_params(direction='in', color='w')
+        ax.spines[:].set_color("w")
+
+
+demo_rgb1()
+demo_rgb2()
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/demo_colorbar_of_inset_axes.py

@@ -0,0 +1,33 @@
+"""
+===============================
+Adding a colorbar to inset axes
+===============================
+"""
+
+import matplotlib.pyplot as plt
+
+from matplotlib import cbook
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes, zoomed_inset_axes
+
+fig, ax = plt.subplots(figsize=[5, 4])
+ax.set(aspect=1, xlim=(-15, 15), ylim=(-20, 5))
+
+Z = cbook.get_sample_data("axes_grid/bivariate_normal.npy")
+extent = (-3, 4, -4, 3)
+
+axins = zoomed_inset_axes(ax, zoom=2, loc='upper left')
+axins.set(xticks=[], yticks=[])
+im = axins.imshow(Z, extent=extent, origin="lower")
+
+# colorbar
+cax = inset_axes(axins,
+                 width="5%",  # width = 10% of parent_bbox width
+                 height="100%",  # height : 50%
+                 loc='lower left',
+                 bbox_to_anchor=(1.05, 0., 1, 1),
+                 bbox_transform=axins.transAxes,
+                 borderpad=0,
+                 )
+fig.colorbar(im, cax=cax)
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/demo_colorbar_with_axes_divider.py

@@ -0,0 +1,35 @@
+"""
+=========================
+Colorbar with AxesDivider
+=========================
+
+The `.axes_divider.make_axes_locatable` function takes an existing axes, adds
+it to a new `.AxesDivider` and returns the `.AxesDivider`.  The `.append_axes`
+method of the `.AxesDivider` can then be used to create a new axes on a given
+side ("top", "right", "bottom", or "left") of the original axes. This example
+uses `.append_axes` to add colorbars next to axes.
+"""
+
+import matplotlib.pyplot as plt
+
+from mpl_toolkits.axes_grid1.axes_divider import make_axes_locatable
+
+fig, (ax1, ax2) = plt.subplots(1, 2)
+fig.subplots_adjust(wspace=0.5)
+
+im1 = ax1.imshow([[1, 2], [3, 4]])
+ax1_divider = make_axes_locatable(ax1)
+# Add an Axes to the right of the main Axes.
+cax1 = ax1_divider.append_axes("right", size="7%", pad="2%")
+cb1 = fig.colorbar(im1, cax=cax1)
+
+im2 = ax2.imshow([[1, 2], [3, 4]])
+ax2_divider = make_axes_locatable(ax2)
+# Add an Axes above the main Axes.
+cax2 = ax2_divider.append_axes("top", size="7%", pad="2%")
+cb2 = fig.colorbar(im2, cax=cax2, orientation="horizontal")
+# Change tick position to top (with the default tick position "bottom", ticks
+# overlap the image).
+cax2.xaxis.set_ticks_position("top")
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/demo_colorbar_with_inset_locator.py

@@ -0,0 +1,43 @@
+"""
+==============================================================
+Controlling the position and size of colorbars with Inset Axes
+==============================================================
+
+This example shows how to control the position, height, and width of
+colorbars using `~mpl_toolkits.axes_grid1.inset_locator.inset_axes`.
+
+Inset axes placement is controlled as for legends: either by providing a *loc*
+option ("upper right", "best", ...), or by providing a locator with respect to
+the parent bbox.  Parameters such as *bbox_to_anchor* and *borderpad* likewise
+work in the same way, and are also demonstrated here.
+"""
+
+import matplotlib.pyplot as plt
+
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+
+fig, (ax1, ax2) = plt.subplots(1, 2, figsize=[6, 3])
+
+im1 = ax1.imshow([[1, 2], [2, 3]])
+axins1 = inset_axes(
+    ax1,
+    width="50%",  # width: 50% of parent_bbox width
+    height="5%",  # height: 5%
+    loc="upper right",
+)
+axins1.xaxis.set_ticks_position("bottom")
+fig.colorbar(im1, cax=axins1, orientation="horizontal", ticks=[1, 2, 3])
+
+im = ax2.imshow([[1, 2], [2, 3]])
+axins = inset_axes(
+    ax2,
+    width="5%",  # width: 5% of parent_bbox width
+    height="50%",  # height: 50%
+    loc="lower left",
+    bbox_to_anchor=(1.05, 0., 1, 1),
+    bbox_transform=ax2.transAxes,
+    borderpad=0,
+)
+fig.colorbar(im, cax=axins, ticks=[1, 2, 3])
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/demo_edge_colorbar.py

@@ -0,0 +1,86 @@
+"""
+===============================
+Per-row or per-column colorbars
+===============================
+
+This example shows how to use one common colorbar for each row or column
+of an image grid.
+"""
+
+import matplotlib.pyplot as plt
+
+from matplotlib import cbook
+from mpl_toolkits.axes_grid1 import AxesGrid
+
+
+def get_demo_image():
+    z = cbook.get_sample_data("axes_grid/bivariate_normal.npy")  # 15x15 array
+    return z, (-3, 4, -4, 3)
+
+
+def demo_bottom_cbar(fig):
+    """
+    A grid of 2x2 images with a colorbar for each column.
+    """
+    grid = AxesGrid(fig, 121,  # similar to subplot(121)
+                    nrows_ncols=(2, 2),
+                    axes_pad=0.10,
+                    share_all=True,
+                    label_mode="1",
+                    cbar_location="bottom",
+                    cbar_mode="edge",
+                    cbar_pad=0.25,
+                    cbar_size="15%",
+                    direction="column"
+                    )
+
+    Z, extent = get_demo_image()
+    cmaps = ["autumn", "summer"]
+    for i in range(4):
+        im = grid[i].imshow(Z, extent=extent, cmap=cmaps[i//2])
+        if i % 2:
+            grid.cbar_axes[i//2].colorbar(im)
+
+    for cax in grid.cbar_axes:
+        cax.axis[cax.orientation].set_label("Bar")
+
+    # This affects all axes as share_all = True.
+    grid.axes_llc.set_xticks([-2, 0, 2])
+    grid.axes_llc.set_yticks([-2, 0, 2])
+
+
+def demo_right_cbar(fig):
+    """
+    A grid of 2x2 images. Each row has its own colorbar.
+    """
+    grid = AxesGrid(fig, 122,  # similar to subplot(122)
+                    nrows_ncols=(2, 2),
+                    axes_pad=0.10,
+                    label_mode="1",
+                    share_all=True,
+                    cbar_location="right",
+                    cbar_mode="edge",
+                    cbar_size="7%",
+                    cbar_pad="2%",
+                    )
+    Z, extent = get_demo_image()
+    cmaps = ["spring", "winter"]
+    for i in range(4):
+        im = grid[i].imshow(Z, extent=extent, cmap=cmaps[i//2])
+        if i % 2:
+            grid.cbar_axes[i//2].colorbar(im)
+
+    for cax in grid.cbar_axes:
+        cax.axis[cax.orientation].set_label('Foo')
+
+    # This affects all axes because we set share_all = True.
+    grid.axes_llc.set_xticks([-2, 0, 2])
+    grid.axes_llc.set_yticks([-2, 0, 2])
+
+
+fig = plt.figure()
+
+demo_bottom_cbar(fig)
+demo_right_cbar(fig)
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/demo_fixed_size_axes.py

@@ -0,0 +1,50 @@
+"""
+===============================
+Axes with a fixed physical size
+===============================
+
+Note that this can be accomplished with the main library for
+Axes on Figures that do not change size: :ref:`fixed_size_axes`
+"""
+
+import matplotlib.pyplot as plt
+
+from mpl_toolkits.axes_grid1 import Divider, Size
+
+# %%
+
+
+fig = plt.figure(figsize=(6, 6))
+
+# The first items are for padding and the second items are for the axes.
+# sizes are in inch.
+h = [Size.Fixed(1.0), Size.Fixed(4.5)]
+v = [Size.Fixed(0.7), Size.Fixed(5.)]
+
+divider = Divider(fig, (0, 0, 1, 1), h, v, aspect=False)
+# The width and height of the rectangle are ignored.
+
+ax = fig.add_axes(divider.get_position(),
+                  axes_locator=divider.new_locator(nx=1, ny=1))
+
+ax.plot([1, 2, 3])
+
+# %%
+
+
+fig = plt.figure(figsize=(6, 6))
+
+# The first & third items are for padding and the second items are for the
+# axes. Sizes are in inches.
+h = [Size.Fixed(1.0), Size.Scaled(1.), Size.Fixed(.2)]
+v = [Size.Fixed(0.7), Size.Scaled(1.), Size.Fixed(.5)]
+
+divider = Divider(fig, (0, 0, 1, 1), h, v, aspect=False)
+# The width and height of the rectangle are ignored.
+
+ax = fig.add_axes(divider.get_position(),
+                  axes_locator=divider.new_locator(nx=1, ny=1))
+
+ax.plot([1, 2, 3])
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/demo_imagegrid_aspect.py

@@ -0,0 +1,23 @@
+"""
+=========================================
+Setting a fixed aspect on ImageGrid cells
+=========================================
+"""
+
+import matplotlib.pyplot as plt
+
+from mpl_toolkits.axes_grid1 import ImageGrid
+
+fig = plt.figure()
+
+grid1 = ImageGrid(fig, 121, (2, 2), axes_pad=0.1,
+                  aspect=True, share_all=True)
+for i in [0, 1]:
+    grid1[i].set_aspect(2)
+
+grid2 = ImageGrid(fig, 122, (2, 2), axes_pad=0.1,
+                  aspect=True, share_all=True)
+for i in [1, 3]:
+    grid2[i].set_aspect(2)
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/inset_locator_demo.py

@@ -0,0 +1,145 @@
+"""
+==================
+Inset locator demo
+==================
+
+"""
+
+# %%
+# The `.inset_locator`'s `~.inset_locator.inset_axes` allows
+# easily placing insets in the corners of the axes by specifying a width and
+# height and optionally a location (loc) that accepts locations as codes,
+# similar to `~matplotlib.axes.Axes.legend`.
+# By default, the inset is offset by some points from the axes,
+# controlled via the *borderpad* parameter.
+
+import matplotlib.pyplot as plt
+
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+
+fig, (ax, ax2) = plt.subplots(1, 2, figsize=[5.5, 2.8])
+
+# Create inset of width 1.3 inches and height 0.9 inches
+# at the default upper right location
+axins = inset_axes(ax, width=1.3, height=0.9)
+
+# Create inset of width 30% and height 40% of the parent axes' bounding box
+# at the lower left corner (loc=3)
+axins2 = inset_axes(ax, width="30%", height="40%", loc=3)
+
+# Create inset of mixed specifications in the second subplot;
+# width is 30% of parent axes' bounding box and
+# height is 1 inch at the upper left corner (loc=2)
+axins3 = inset_axes(ax2, width="30%", height=1., loc=2)
+
+# Create an inset in the lower right corner (loc=4) with borderpad=1, i.e.
+# 10 points padding (as 10pt is the default fontsize) to the parent axes
+axins4 = inset_axes(ax2, width="20%", height="20%", loc=4, borderpad=1)
+
+# Turn ticklabels of insets off
+for axi in [axins, axins2, axins3, axins4]:
+    axi.tick_params(labelleft=False, labelbottom=False)
+
+plt.show()
+
+
+# %%
+# The parameters *bbox_to_anchor* and *bbox_transform* can be used for a more
+# fine-grained control over the inset position and size or even to position
+# the inset at completely arbitrary positions.
+# The *bbox_to_anchor* sets the bounding box in coordinates according to the
+# *bbox_transform*.
+#
+
+fig = plt.figure(figsize=[5.5, 2.8])
+ax = fig.add_subplot(121)
+
+# We use the axes transform as bbox_transform. Therefore, the bounding box
+# needs to be specified in axes coordinates ((0, 0) is the lower left corner
+# of the axes, (1, 1) is the upper right corner).
+# The bounding box (.2, .4, .6, .5) starts at (.2, .4) and ranges to (.8, .9)
+# in those coordinates.
+# Inside this bounding box an inset of half the bounding box' width and
+# three quarters of the bounding box' height is created. The lower left corner
+# of the inset is aligned to the lower left corner of the bounding box (loc=3).
+# The inset is then offset by the default 0.5 in units of the font size.
+
+axins = inset_axes(ax, width="50%", height="75%",
+                   bbox_to_anchor=(.2, .4, .6, .5),
+                   bbox_transform=ax.transAxes, loc=3)
+
+# For visualization purposes we mark the bounding box by a rectangle
+ax.add_patch(plt.Rectangle((.2, .4), .6, .5, ls="--", ec="c", fc="none",
+                           transform=ax.transAxes))
+
+# We set the axis limits to something other than the default, in order to not
+# distract from the fact that axes coordinates are used here.
+ax.set(xlim=(0, 10), ylim=(0, 10))
+
+
+# Note how the two following insets are created at the same positions, one by
+# use of the default parent axes' bbox and the other via a bbox in axes
+# coordinates and the respective transform.
+ax2 = fig.add_subplot(222)
+axins2 = inset_axes(ax2, width="30%", height="50%")
+
+ax3 = fig.add_subplot(224)
+axins3 = inset_axes(ax3, width="100%", height="100%",
+                    bbox_to_anchor=(.7, .5, .3, .5),
+                    bbox_transform=ax3.transAxes)
+
+# For visualization purposes we mark the bounding box by a rectangle
+ax2.add_patch(plt.Rectangle((0, 0), 1, 1, ls="--", lw=2, ec="c", fc="none"))
+ax3.add_patch(plt.Rectangle((.7, .5), .3, .5, ls="--", lw=2,
+                            ec="c", fc="none"))
+
+# Turn ticklabels off
+for axi in [axins2, axins3, ax2, ax3]:
+    axi.tick_params(labelleft=False, labelbottom=False)
+
+plt.show()
+
+
+# %%
+# In the above the axes transform together with 4-tuple bounding boxes has been
+# used as it mostly is useful to specify an inset relative to the axes it is
+# an inset to. However, other use cases are equally possible. The following
+# example examines some of those.
+#
+
+fig = plt.figure(figsize=[5.5, 2.8])
+ax = fig.add_subplot(131)
+
+# Create an inset outside the axes
+axins = inset_axes(ax, width="100%", height="100%",
+                   bbox_to_anchor=(1.05, .6, .5, .4),
+                   bbox_transform=ax.transAxes, loc=2, borderpad=0)
+axins.tick_params(left=False, right=True, labelleft=False, labelright=True)
+
+# Create an inset with a 2-tuple bounding box. Note that this creates a
+# bbox without extent. This hence only makes sense when specifying
+# width and height in absolute units (inches).
+axins2 = inset_axes(ax, width=0.5, height=0.4,
+                    bbox_to_anchor=(0.33, 0.25),
+                    bbox_transform=ax.transAxes, loc=3, borderpad=0)
+
+
+ax2 = fig.add_subplot(133)
+ax2.set_xscale("log")
+ax2.set(xlim=(1e-6, 1e6), ylim=(-2, 6))
+
+# Create inset in data coordinates using ax.transData as transform
+axins3 = inset_axes(ax2, width="100%", height="100%",
+                    bbox_to_anchor=(1e-2, 2, 1e3, 3),
+                    bbox_transform=ax2.transData, loc=2, borderpad=0)
+
+# Create an inset horizontally centered in figure coordinates and vertically
+# bound to line up with the axes.
+from matplotlib.transforms import blended_transform_factory  # noqa
+
+transform = blended_transform_factory(fig.transFigure, ax2.transAxes)
+axins4 = inset_axes(ax2, width="16%", height="34%",
+                    bbox_to_anchor=(0, 0, 1, 1),
+                    bbox_transform=transform, loc=8, borderpad=0)
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/inset_locator_demo2.py

@@ -0,0 +1,73 @@
+"""
+====================
+Inset locator demo 2
+====================
+
+This demo shows how to create a zoomed inset via `.zoomed_inset_axes`.
+In the first subplot an `.AnchoredSizeBar` shows the zoom effect.
+In the second subplot a connection to the region of interest is
+created via `.mark_inset`.
+
+A version of the second subplot, not using the toolkit, is available in
+:doc:`/gallery/subplots_axes_and_figures/zoom_inset_axes`.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from matplotlib import cbook
+from mpl_toolkits.axes_grid1.anchored_artists import AnchoredSizeBar
+from mpl_toolkits.axes_grid1.inset_locator import mark_inset, zoomed_inset_axes
+
+fig, (ax, ax2) = plt.subplots(ncols=2, figsize=[6, 3])
+
+
+# First subplot, showing an inset with a size bar.
+ax.set_aspect(1)
+
+axins = zoomed_inset_axes(ax, zoom=0.5, loc='upper right')
+# fix the number of ticks on the inset axes
+axins.yaxis.get_major_locator().set_params(nbins=7)
+axins.xaxis.get_major_locator().set_params(nbins=7)
+axins.tick_params(labelleft=False, labelbottom=False)
+
+
+def add_sizebar(ax, size):
+    asb = AnchoredSizeBar(ax.transData,
+                          size,
+                          str(size),
+                          loc=8,
+                          pad=0.1, borderpad=0.5, sep=5,
+                          frameon=False)
+    ax.add_artist(asb)
+
+add_sizebar(ax, 0.5)
+add_sizebar(axins, 0.5)
+
+
+# Second subplot, showing an image with an inset zoom and a marked inset
+Z = cbook.get_sample_data("axes_grid/bivariate_normal.npy")  # 15x15 array
+extent = (-3, 4, -4, 3)
+Z2 = np.zeros((150, 150))
+ny, nx = Z.shape
+Z2[30:30+ny, 30:30+nx] = Z
+
+ax2.imshow(Z2, extent=extent, origin="lower")
+
+axins2 = zoomed_inset_axes(ax2, zoom=6, loc=1)
+axins2.imshow(Z2, extent=extent, origin="lower")
+
+# subregion of the original image
+x1, x2, y1, y2 = -1.5, -0.9, -2.5, -1.9
+axins2.set_xlim(x1, x2)
+axins2.set_ylim(y1, y2)
+# fix the number of ticks on the inset axes
+axins2.yaxis.get_major_locator().set_params(nbins=7)
+axins2.xaxis.get_major_locator().set_params(nbins=7)
+axins2.tick_params(labelleft=False, labelbottom=False)
+
+# draw a bbox of the region of the inset axes in the parent axes and
+# connecting lines between the bbox and the inset axes area
+mark_inset(ax2, axins2, loc1=2, loc2=4, fc="none", ec="0.5")
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/make_room_for_ylabel_using_axesgrid.py

@@ -0,0 +1,55 @@
+"""
+====================================
+Make room for ylabel using axes_grid
+====================================
+"""
+
+import matplotlib.pyplot as plt
+
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+from mpl_toolkits.axes_grid1.axes_divider import make_axes_area_auto_adjustable
+
+fig = plt.figure()
+ax = fig.add_axes([0, 0, 1, 1])
+
+ax.set_yticks([0.5], labels=["very long label"])
+
+make_axes_area_auto_adjustable(ax)
+
+# %%
+
+fig = plt.figure()
+ax1 = fig.add_axes([0, 0, 1, 0.5])
+ax2 = fig.add_axes([0, 0.5, 1, 0.5])
+
+ax1.set_yticks([0.5], labels=["very long label"])
+ax1.set_ylabel("Y label")
+
+ax2.set_title("Title")
+
+make_axes_area_auto_adjustable(ax1, pad=0.1, use_axes=[ax1, ax2])
+make_axes_area_auto_adjustable(ax2, pad=0.1, use_axes=[ax1, ax2])
+
+# %%
+
+fig = plt.figure()
+ax1 = fig.add_axes([0, 0, 1, 1])
+divider = make_axes_locatable(ax1)
+
+ax2 = divider.append_axes("right", "100%", pad=0.3, sharey=ax1)
+ax2.tick_params(labelleft=False)
+fig.add_axes(ax2)
+
+divider.add_auto_adjustable_area(use_axes=[ax1], pad=0.1,
+                                 adjust_dirs=["left"])
+divider.add_auto_adjustable_area(use_axes=[ax2], pad=0.1,
+                                 adjust_dirs=["right"])
+divider.add_auto_adjustable_area(use_axes=[ax1, ax2], pad=0.1,
+                                 adjust_dirs=["top", "bottom"])
+
+ax1.set_yticks([0.5], labels=["very long label"])
+
+ax2.set_title("Title")
+ax2.set_xlabel("X - Label")
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/parasite_simple.py

@@ -0,0 +1,26 @@
+"""
+===============
+Parasite Simple
+===============
+"""
+
+import matplotlib.pyplot as plt
+
+from mpl_toolkits.axes_grid1 import host_subplot
+
+host = host_subplot(111)
+par = host.twinx()
+
+host.set_xlabel("Distance")
+host.set_ylabel("Density")
+par.set_ylabel("Temperature")
+
+p1, = host.plot([0, 1, 2], [0, 1, 2], label="Density")
+p2, = par.plot([0, 1, 2], [0, 3, 2], label="Temperature")
+
+host.legend(labelcolor="linecolor")
+
+host.yaxis.get_label().set_color(p1.get_color())
+par.yaxis.get_label().set_color(p2.get_color())
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/parasite_simple2.py

@@ -0,0 +1,45 @@
+"""
+================
+Parasite Simple2
+================
+
+"""
+import matplotlib.pyplot as plt
+
+import matplotlib.transforms as mtransforms
+from mpl_toolkits.axes_grid1.parasite_axes import HostAxes
+
+obs = [["01_S1", 3.88, 0.14, 1970, 63],
+       ["01_S4", 5.6, 0.82, 1622, 150],
+       ["02_S1", 2.4, 0.54, 1570, 40],
+       ["03_S1", 4.1, 0.62, 2380, 170]]
+
+
+fig = plt.figure()
+
+ax_kms = fig.add_subplot(axes_class=HostAxes, aspect=1)
+
+# angular proper motion("/yr) to linear velocity(km/s) at distance=2.3kpc
+pm_to_kms = 1./206265.*2300*3.085e18/3.15e7/1.e5
+
+aux_trans = mtransforms.Affine2D().scale(pm_to_kms, 1.)
+ax_pm = ax_kms.twin(aux_trans)
+
+for n, ds, dse, w, we in obs:
+    time = ((2007 + (10. + 4/30.)/12) - 1988.5)
+    v = ds / time * pm_to_kms
+    ve = dse / time * pm_to_kms
+    ax_kms.errorbar([v], [w], xerr=[ve], yerr=[we], color="k")
+
+
+ax_kms.axis["bottom"].set_label("Linear velocity at 2.3 kpc [km/s]")
+ax_kms.axis["left"].set_label("FWHM [km/s]")
+ax_pm.axis["top"].set_label(r"Proper Motion [$''$/yr]")
+ax_pm.axis["top"].label.set_visible(True)
+ax_pm.axis["right"].major_ticklabels.set_visible(False)
+
+ax_kms.set_xlim(950, 3700)
+ax_kms.set_ylim(950, 3100)
+# xlim and ylim of ax_pms will be automatically adjusted.
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/scatter_hist_locatable_axes.py

@@ -0,0 +1,77 @@
+"""
+==================================
+Scatter Histogram (Locatable Axes)
+==================================
+
+Show the marginal distributions of a scatter plot as histograms at the sides of
+the plot.
+
+For a nice alignment of the main axes with the marginals, the axes positions
+are defined by a ``Divider``, produced via `.make_axes_locatable`.  Note that
+the ``Divider`` API allows setting axes sizes and pads in inches, which is its
+main feature.
+
+If one wants to set axes sizes and pads relative to the main Figure, see the
+:doc:`/gallery/lines_bars_and_markers/scatter_hist` example.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+
+# Fixing random state for reproducibility
+np.random.seed(19680801)
+
+# the random data
+x = np.random.randn(1000)
+y = np.random.randn(1000)
+
+
+fig, ax = plt.subplots(figsize=(5.5, 5.5))
+
+# the scatter plot:
+ax.scatter(x, y)
+
+# Set aspect of the main axes.
+ax.set_aspect(1.)
+
+# create new axes on the right and on the top of the current axes
+divider = make_axes_locatable(ax)
+# below height and pad are in inches
+ax_histx = divider.append_axes("top", 1.2, pad=0.1, sharex=ax)
+ax_histy = divider.append_axes("right", 1.2, pad=0.1, sharey=ax)
+
+# make some labels invisible
+ax_histx.xaxis.set_tick_params(labelbottom=False)
+ax_histy.yaxis.set_tick_params(labelleft=False)
+
+# now determine nice limits by hand:
+binwidth = 0.25
+xymax = max(np.max(np.abs(x)), np.max(np.abs(y)))
+lim = (int(xymax/binwidth) + 1)*binwidth
+
+bins = np.arange(-lim, lim + binwidth, binwidth)
+ax_histx.hist(x, bins=bins)
+ax_histy.hist(y, bins=bins, orientation='horizontal')
+
+# the xaxis of ax_histx and yaxis of ax_histy are shared with ax,
+# thus there is no need to manually adjust the xlim and ylim of these
+# axis.
+
+ax_histx.set_yticks([0, 50, 100])
+ax_histy.set_xticks([0, 50, 100])
+
+plt.show()
+
+# %%
+#
+# .. admonition:: References
+#
+#    The use of the following functions, methods, classes and modules is shown
+#    in this example:
+#
+#    - `mpl_toolkits.axes_grid1.axes_divider.make_axes_locatable`
+#    - `matplotlib.axes.Axes.set_aspect`
+#    - `matplotlib.axes.Axes.scatter`
+#    - `matplotlib.axes.Axes.hist`

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/simple_anchored_artists.py

@@ -0,0 +1,71 @@
+"""
+=======================
+Simple Anchored Artists
+=======================
+
+This example illustrates the use of the anchored helper classes found in
+:mod:`matplotlib.offsetbox` and in :mod:`mpl_toolkits.axes_grid1`.
+An implementation of a similar figure, but without use of the toolkit,
+can be found in :doc:`/gallery/misc/anchored_artists`.
+"""
+
+import matplotlib.pyplot as plt
+
+
+def draw_text(ax):
+    """
+    Draw two text-boxes, anchored by different corners to the upper-left
+    corner of the figure.
+    """
+    from matplotlib.offsetbox import AnchoredText
+    at = AnchoredText("Figure 1a",
+                      loc='upper left', prop=dict(size=8), frameon=True,
+                      )
+    at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2")
+    ax.add_artist(at)
+
+    at2 = AnchoredText("Figure 1(b)",
+                       loc='lower left', prop=dict(size=8), frameon=True,
+                       bbox_to_anchor=(0., 1.),
+                       bbox_transform=ax.transAxes
+                       )
+    at2.patch.set_boxstyle("round,pad=0.,rounding_size=0.2")
+    ax.add_artist(at2)
+
+
+def draw_circle(ax):
+    """
+    Draw a circle in axis coordinates
+    """
+    from matplotlib.patches import Circle
+    from mpl_toolkits.axes_grid1.anchored_artists import AnchoredDrawingArea
+    ada = AnchoredDrawingArea(20, 20, 0, 0,
+                              loc='upper right', pad=0., frameon=False)
+    p = Circle((10, 10), 10)
+    ada.da.add_artist(p)
+    ax.add_artist(ada)
+
+
+def draw_sizebar(ax):
+    """
+    Draw a horizontal bar with length of 0.1 in data coordinates,
+    with a fixed label underneath.
+    """
+    from mpl_toolkits.axes_grid1.anchored_artists import AnchoredSizeBar
+    asb = AnchoredSizeBar(ax.transData,
+                          0.1,
+                          r"1$^{\prime}$",
+                          loc='lower center',
+                          pad=0.1, borderpad=0.5, sep=5,
+                          frameon=False)
+    ax.add_artist(asb)
+
+
+fig, ax = plt.subplots()
+ax.set_aspect(1.)
+
+draw_text(ax)
+draw_circle(ax)
+draw_sizebar(ax)
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/simple_axes_divider1.py

@@ -0,0 +1,69 @@
+"""
+=====================
+Simple Axes Divider 1
+=====================
+
+See also :ref:`axes_grid`.
+"""
+
+import matplotlib.pyplot as plt
+
+from mpl_toolkits.axes_grid1 import Divider, Size
+
+
+def label_axes(ax, text):
+    """Place a label at the center of an Axes, and remove the axis ticks."""
+    ax.text(.5, .5, text, transform=ax.transAxes,
+            horizontalalignment="center", verticalalignment="center")
+    ax.tick_params(bottom=False, labelbottom=False,
+                   left=False, labelleft=False)
+
+
+# %%
+# Fixed axes sizes; fixed paddings.
+
+fig = plt.figure(figsize=(6, 6))
+fig.suptitle("Fixed axes sizes, fixed paddings")
+
+# Sizes are in inches.
+horiz = [Size.Fixed(1.), Size.Fixed(.5), Size.Fixed(1.5), Size.Fixed(.5)]
+vert = [Size.Fixed(1.5), Size.Fixed(.5), Size.Fixed(1.)]
+
+rect = (0.1, 0.1, 0.8, 0.8)
+# Divide the axes rectangle into a grid with sizes specified by horiz * vert.
+div = Divider(fig, rect, horiz, vert, aspect=False)
+
+# The rect parameter will actually be ignored and overridden by axes_locator.
+ax1 = fig.add_axes(rect, axes_locator=div.new_locator(nx=0, ny=0))
+label_axes(ax1, "nx=0, ny=0")
+ax2 = fig.add_axes(rect, axes_locator=div.new_locator(nx=0, ny=2))
+label_axes(ax2, "nx=0, ny=2")
+ax3 = fig.add_axes(rect, axes_locator=div.new_locator(nx=2, ny=2))
+label_axes(ax3, "nx=2, ny=2")
+ax4 = fig.add_axes(rect, axes_locator=div.new_locator(nx=2, nx1=4, ny=0))
+label_axes(ax4, "nx=2, nx1=4, ny=0")
+
+# %%
+# Axes sizes that scale with the figure size; fixed paddings.
+
+fig = plt.figure(figsize=(6, 6))
+fig.suptitle("Scalable axes sizes, fixed paddings")
+
+horiz = [Size.Scaled(1.5), Size.Fixed(.5), Size.Scaled(1.), Size.Scaled(.5)]
+vert = [Size.Scaled(1.), Size.Fixed(.5), Size.Scaled(1.5)]
+
+rect = (0.1, 0.1, 0.8, 0.8)
+# Divide the axes rectangle into a grid with sizes specified by horiz * vert.
+div = Divider(fig, rect, horiz, vert, aspect=False)
+
+# The rect parameter will actually be ignored and overridden by axes_locator.
+ax1 = fig.add_axes(rect, axes_locator=div.new_locator(nx=0, ny=0))
+label_axes(ax1, "nx=0, ny=0")
+ax2 = fig.add_axes(rect, axes_locator=div.new_locator(nx=0, ny=2))
+label_axes(ax2, "nx=0, ny=2")
+ax3 = fig.add_axes(rect, axes_locator=div.new_locator(nx=2, ny=2))
+label_axes(ax3, "nx=2, ny=2")
+ax4 = fig.add_axes(rect, axes_locator=div.new_locator(nx=2, nx1=4, ny=0))
+label_axes(ax4, "nx=2, nx1=4, ny=0")
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/simple_axes_divider3.py

@@ -0,0 +1,44 @@
+"""
+=====================
+Simple axes divider 3
+=====================
+
+See also :ref:`axes_grid`.
+"""
+
+import matplotlib.pyplot as plt
+
+from mpl_toolkits.axes_grid1 import Divider
+import mpl_toolkits.axes_grid1.axes_size as Size
+
+fig = plt.figure(figsize=(5.5, 4))
+
+# the rect parameter will be ignored as we will set axes_locator
+rect = (0.1, 0.1, 0.8, 0.8)
+ax = [fig.add_axes(rect, label="%d" % i) for i in range(4)]
+
+
+horiz = [Size.AxesX(ax[0]), Size.Fixed(.5), Size.AxesX(ax[1])]
+vert = [Size.AxesY(ax[0]), Size.Fixed(.5), Size.AxesY(ax[2])]
+
+# divide the axes rectangle into grid whose size is specified by horiz * vert
+divider = Divider(fig, rect, horiz, vert, aspect=False)
+
+
+ax[0].set_axes_locator(divider.new_locator(nx=0, ny=0))
+ax[1].set_axes_locator(divider.new_locator(nx=2, ny=0))
+ax[2].set_axes_locator(divider.new_locator(nx=0, ny=2))
+ax[3].set_axes_locator(divider.new_locator(nx=2, ny=2))
+
+ax[0].set_xlim(0, 2)
+ax[1].set_xlim(0, 1)
+
+ax[0].set_ylim(0, 1)
+ax[2].set_ylim(0, 2)
+
+divider.set_aspect(1.)
+
+for ax1 in ax:
+    ax1.tick_params(labelbottom=False, labelleft=False)
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/simple_axesgrid.py

@@ -0,0 +1,29 @@
+"""
+================
+Simple ImageGrid
+================
+
+Align multiple images using `~mpl_toolkits.axes_grid1.axes_grid.ImageGrid`.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from mpl_toolkits.axes_grid1 import ImageGrid
+
+im1 = np.arange(100).reshape((10, 10))
+im2 = im1.T
+im3 = np.flipud(im1)
+im4 = np.fliplr(im2)
+
+fig = plt.figure(figsize=(4., 4.))
+grid = ImageGrid(fig, 111,  # similar to subplot(111)
+                 nrows_ncols=(2, 2),  # creates 2x2 grid of axes
+                 axes_pad=0.1,  # pad between axes in inch.
+                 )
+
+for ax, im in zip(grid, [im1, im2, im3, im4]):
+    # Iterating over the grid returns the Axes.
+    ax.imshow(im)
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/simple_axesgrid2.py

@@ -0,0 +1,31 @@
+"""
+==================
+Simple ImageGrid 2
+==================
+
+Align multiple images of different sizes using
+`~mpl_toolkits.axes_grid1.axes_grid.ImageGrid`.
+"""
+
+import matplotlib.pyplot as plt
+
+from matplotlib import cbook
+from mpl_toolkits.axes_grid1 import ImageGrid
+
+fig = plt.figure(figsize=(5.5, 3.5))
+grid = ImageGrid(fig, 111,  # similar to subplot(111)
+                 nrows_ncols=(1, 3),
+                 axes_pad=0.1,
+                 label_mode="L",
+                 )
+
+# demo image
+Z = cbook.get_sample_data("axes_grid/bivariate_normal.npy")
+im1 = Z
+im2 = Z[:, :10]
+im3 = Z[:, 10:]
+vmin, vmax = Z.min(), Z.max()
+for ax, im in zip(grid, [im1, im2, im3]):
+    ax.imshow(im, origin="lower", vmin=vmin, vmax=vmax)
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/simple_axisline4.py

@@ -0,0 +1,24 @@
+"""
+================
+Simple Axisline4
+================
+
+"""
+import matplotlib.pyplot as plt
+import numpy as np
+
+from mpl_toolkits.axes_grid1 import host_subplot
+
+ax = host_subplot(111)
+xx = np.arange(0, 2*np.pi, 0.01)
+ax.plot(xx, np.sin(xx))
+
+ax2 = ax.twin()  # ax2 is responsible for "top" axis and "right" axis
+ax2.set_xticks([0., .5*np.pi, np.pi, 1.5*np.pi, 2*np.pi],
+               labels=["$0$", r"$\frac{1}{2}\pi$",
+                       r"$\pi$", r"$\frac{3}{2}\pi$", r"$2\pi$"])
+
+ax2.axis["right"].major_ticklabels.set_visible(False)
+ax2.axis["top"].major_ticklabels.set_visible(True)
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axes_grid1/simple_colorbar.py

@@ -0,0 +1,22 @@
+"""
+===============
+Simple Colorbar
+===============
+
+"""
+import matplotlib.pyplot as plt
+import numpy as np
+
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+
+ax = plt.subplot()
+im = ax.imshow(np.arange(100).reshape((10, 10)))
+
+# create an Axes on the right side of ax. The width of cax will be 5%
+# of ax and the padding between cax and ax will be fixed at 0.05 inch.
+divider = make_axes_locatable(ax)
+cax = divider.append_axes("right", size="5%", pad=0.05)
+
+plt.colorbar(im, cax=cax)
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/axisartist/README.txt

@@ -0,0 +1,6 @@
+.. _axis_artist_examples:
+
+.. _axisartist-examples-index:
+
+Module - axisartist
+===================

testbed/matplotlib__matplotlib/galleries/examples/axisartist/axis_direction.py

@@ -0,0 +1,68 @@
+"""
+==============
+Axis Direction
+==============
+"""
+
+import matplotlib.pyplot as plt
+
+import mpl_toolkits.axisartist as axisartist
+
+
+def setup_axes(fig, pos):
+    ax = fig.add_subplot(pos, axes_class=axisartist.Axes)
+
+    ax.set_ylim(-0.1, 1.5)
+    ax.set_yticks([0, 1])
+
+    ax.axis[:].set_visible(False)
+
+    ax.axis["x"] = ax.new_floating_axis(1, 0.5)
+    ax.axis["x"].set_axisline_style("->", size=1.5)
+
+    return ax
+
+
+plt.rcParams.update({
+    "axes.titlesize": "medium",
+    "axes.titley": 1.1,
+})
+
+fig = plt.figure(figsize=(10, 4))
+fig.subplots_adjust(bottom=0.1, top=0.9, left=0.05, right=0.95)
+
+ax1 = setup_axes(fig, 251)
+ax1.axis["x"].set_axis_direction("left")
+
+ax2 = setup_axes(fig, 252)
+ax2.axis["x"].label.set_text("Label")
+ax2.axis["x"].toggle(ticklabels=False)
+ax2.axis["x"].set_axislabel_direction("+")
+ax2.set_title("label direction=$+$")
+
+ax3 = setup_axes(fig, 253)
+ax3.axis["x"].label.set_text("Label")
+ax3.axis["x"].toggle(ticklabels=False)
+ax3.axis["x"].set_axislabel_direction("-")
+ax3.set_title("label direction=$-$")
+
+ax4 = setup_axes(fig, 254)
+ax4.axis["x"].set_ticklabel_direction("+")
+ax4.set_title("ticklabel direction=$+$")
+
+ax5 = setup_axes(fig, 255)
+ax5.axis["x"].set_ticklabel_direction("-")
+ax5.set_title("ticklabel direction=$-$")
+
+ax7 = setup_axes(fig, 257)
+ax7.axis["x"].label.set_text("rotation=10")
+ax7.axis["x"].label.set_rotation(10)
+ax7.axis["x"].toggle(ticklabels=False)
+
+ax8 = setup_axes(fig, 258)
+ax8.axis["x"].set_axislabel_direction("-")
+ax8.axis["x"].label.set_text("rotation=10")
+ax8.axis["x"].label.set_rotation(10)
+ax8.axis["x"].toggle(ticklabels=False)
+
+plt.show()