import matplotlib.testing.jpl_units as units

units.register()

# This should affect the tick size. (Tests issue #543)

matplotlib.rcParams['lines.markeredgewidth'] = 30

# This essentially test to see if user specified labels get overwritten

# by the auto labeler functionality of the axes.

xdata = [x*units.sec for x in range(10)]

ydata1 = [(1.5*y - 0.5)*units.km for y in range(10)]

ydata2 = [(1.75*y - 1.0)*units.km for y in range(10)]

fig = plt.figure()

ax = plt.subplot(111)

ax.set_xlabel("x-label 001")

fig = plt.figure()

ax = plt.subplot(111)

ax.set_xlabel("x-label 001")

ax.plot(xdata, ydata1, color='blue', xunits="sec")

fig = plt.figure()

ax = plt.subplot(111)

ax.set_xlabel("x-label 001")

ax.plot(xdata, ydata1, color='blue', xunits="sec")

ax.set_xlabel("x-label 003")

fig = plt.figure()

ax = plt.subplot(111)

ax.plot(xdata, ydata1, color='blue', xunits="sec")

ax.plot(xdata, ydata2, color='green', xunits="hour")

ax.set_xlabel("x-label 004")

# See SF bug 2846058

# https://sourceforge.net/tracker/?func=detail&aid=2846058&group_id=80706&atid=560720

fig = plt.figure()

ax = plt.subplot(111)

ax.plot(xdata, ydata1, color='blue', xunits="sec")

ax.plot(xdata, ydata2, color='green', xunits="hour")

ax.set_xlabel("x-label 005")

# github issue #617, pull #619

if LooseVersion(np.__version__) >= LooseVersion('1.11.0'):

pytest.skip("Fall out from a fixed numpy bug")

fig, ax = plt.subplots(1)

x = [0.500000001, 0.500000002]

y = [1e64, 1.1e64]

vals = np.linspace(0, 1, num=5, endpoint=True)

locs = np.sin(np.pi * vals / 2.0)

majl = plt.FixedLocator(locs)

minl = plt.FixedLocator([0.1, 0.2, 0.3])

fig = plt.figure()

ax1 = fig.add_subplot(1, 1, 1)

ax1.plot([0.1, 100], [0, 1])

ax1.yaxis.set_major_locator(majl)

ax1.yaxis.set_minor_locator(minl)

ax1.yaxis.set_major_formatter(plt.FormatStrFormatter('%08.2lf'))

ax1.yaxis.set_minor_formatter(plt.FixedFormatter(['tricks', 'mind',

'jedi']))

ax1.xaxis.set_major_locator(plt.LinearLocator())

ax1.xaxis.set_minor_locator(plt.FixedLocator([15, 35, 55, 75]))

ax1.xaxis.set_major_formatter(plt.FormatStrFormatter('%05.2lf'))

ax1.xaxis.set_minor_formatter(plt.FixedFormatter(['c', '3', 'p', 'o']))

ax2 = ax1.twiny()

fig, ax = plt.subplots()

ax2 = ax.twinx()

ax3 = ax2.twiny()

plt.draw()

assert not ax2.xaxis.get_visible()

assert not ax2.patch.get_visible()

ax2.cla()

ax3.cla()

assert not ax2.xaxis.get_visible()

assert not ax2.patch.get_visible()

assert ax2.yaxis.get_visible()

assert ax3.xaxis.get_visible()

assert not ax3.patch.get_visible()

assert not ax3.yaxis.get_visible()

assert ax.xaxis.get_visible()

assert ax.patch.get_visible()

x = np.array([0, 0.5, 1])

y = 0.5 * x

x2 = np.array([0, 1, 2])

y2 = 2 * x2

fig = plt.figure()

ax = fig.add_axes((0, 0, 1, 1), autoscalex_on=False, autoscaley_on=False)

ax.plot(x, y, color='blue', lw=10)

ax2 = plt.twinx(ax)

ax2.plot(x2, y2, 'r--', lw=5)

ax.margins(0, 0)

fig, ax = plt.subplots()

ax_x_on = ax.twinx()

ax.set_autoscalex_on(False)

ax_x_off = ax.twinx()

assert ax_x_on.get_autoscalex_on()

assert not ax_x_off.get_autoscalex_on()

ax_y_on = ax.twiny()

ax.set_autoscaley_on(False)

ax_y_off = ax.twiny()

assert ax_y_on.get_autoscaley_on()

# Github PR #5450. Setting autoscale should reset

# axes to be non-inverted.

# plotting an image, then 1d graph, axis is now down

fig = plt.figure(0)

ax = fig.gca()

# 1. test that a new axis is not inverted per default

assert not(ax.xaxis_inverted())

assert not(ax.yaxis_inverted())

img = np.random.random((100, 100))

ax.imshow(img)

# 2. test that a image axis is inverted

assert not(ax.xaxis_inverted())

assert ax.yaxis_inverted()

# 3. test that clearing and plotting a line, axes are

# not inverted

ax.cla()

x = np.linspace(0, 2*np.pi, 100)

ax.plot(x, np.cos(x))

assert not(ax.xaxis_inverted())

assert not(ax.yaxis_inverted())

# 4. autoscaling should not bring back axes to normal

ax.cla()

ax.imshow(img)

plt.autoscale()

assert not(ax.xaxis_inverted())

assert ax.yaxis_inverted()

# 5. two shared axes. Clearing the master axis should bring axes in shared

# axes back to normal

ax0 = plt.subplot(211)

ax1 = plt.subplot(212, sharey=ax0)

ax0.imshow(img)

ax1.plot(x, np.cos(x))

ax0.cla()

assert not(ax1.yaxis_inverted())

ax1.cla()

# 6. clearing the nonmaster should not touch limits

ax0.imshow(img)

ax1.plot(x, np.cos(x))

ax1.cla()

assert ax.yaxis_inverted()

# clean up

fig = plt.figure()

matplotlib.rcParams['xtick.minor.visible'] = True

matplotlib.rcParams['ytick.minor.visible'] = True

plt.plot([0, 1], [0, 1])

# github pull #904

fig, ax = plt.subplots(2, 2)

ax = ax.flatten()

for i in xrange(4):

y1 = 10**(-11 - i)

fig, ax = plt.subplots(1, 1)

ax.plot([1, 2, 3, 4])

ax.autoscale(enable=True, axis='x', tight=False)

ax.autoscale(enable=True, axis='y', tight=True)

assert_allclose(ax.get_xlim(), (-0.15, 3.15))

# related to github #7587

# array starts at zero to trigger _minpos handling

x = np.arange(100, dtype=float)

fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)

ax1.loglog(x, x)

ax2.semilogx(x, x)

ax1.autoscale(tight=True)

ax2.autoscale(tight=True)

plt.draw()

lims = (x[1], x[-1])

assert_allclose(ax1.get_xlim(), lims)

assert_allclose(ax1.get_ylim(), lims)

assert_allclose(ax2.get_xlim(), lims)

fig, ax = plt.subplots()

ax.imshow([[0, 1], [2, 3]], origin='lower')

assert_allclose(ax.get_xlim(), (-0.5, 1.5))

assert_allclose(ax.get_ylim(), (-0.5, 1.5))

ax.use_sticky_edges = False

ax.autoscale()

xlim = (-0.5 - 2 * ax._xmargin, 1.5 + 2 * ax._xmargin)

ylim = (-0.5 - 2 * ax._ymargin, 1.5 + 2 * ax._ymargin)

assert_allclose(ax.get_xlim(), xlim)

assert_allclose(ax.get_ylim(), ylim)

# Make sure it is reversible:

ax.use_sticky_edges = True

ax.autoscale()

assert_allclose(ax.get_xlim(), (-0.5, 1.5))

# Setup some data

t = np.arange(0.0, 5.0, 0.01)

s = np.cos(2.0*np.pi * t)

# Offset Points

fig = plt.figure()

ax = fig.add_subplot(111, autoscale_on=False, xlim=(-1, 5), ylim=(-3, 5))

line, = ax.plot(t, s, lw=3, color='purple')

ax.annotate('local max', xy=(3, 1), xycoords='data',

# Simple image test for ax.arrow

# kwargs that take discrete values

length_includes_head = (True, False)

shape = ('full', 'left', 'right')

head_starts_at_zero = (True, False)

# Create outer product of values

kwargs = list(product(length_includes_head, shape, head_starts_at_zero))

fig, axs = plt.subplots(3, 4)

for i, (ax, kwarg) in enumerate(zip(axs.flatten(), kwargs)):

ax.set_xlim(-2, 2)

ax.set_ylim(-2, 2)

# Unpack kwargs

(length_includes_head, shape, head_starts_at_zero) = kwarg

theta = 2 * np.pi * i / 12

# Draw arrow

ax.arrow(0, 0, np.sin(theta), np.cos(theta),

width=theta/100,

length_includes_head=length_includes_head,

shape=shape,

head_starts_at_zero=head_starts_at_zero,

head_width=theta / 10,

# Check that we can make an annotation arrow with only default properties.

fig, ax = plt.subplots()

ann = ax.annotate("foo", (0, 1), xytext=(2, 3))

assert ann.arrow_patch is None

ann = ax.annotate("foo", (0, 1), xytext=(2, 3), arrowprops={})

# you can specify the xypoint and the xytext in different

# positions and coordinate systems, and optionally turn on a

# connecting line and mark the point with a marker. Annotations

# work on polar axes too. In the example below, the xy point is

# in native coordinates (xycoords defaults to 'data'). For a

# polar axes, this is in (theta, radius) space. The text in this

# example is placed in the fractional figure coordinate system.

# Text keyword args like horizontal and vertical alignment are

# respected

# Setup some data

r = np.arange(0.0, 1.0, 0.001)

theta = 2.0 * 2.0 * np.pi * r

fig = plt.figure()

ax = fig.add_subplot(111, polar=True)

line, = ax.plot(theta, r, color='#ee8d18', lw=3)

line, = ax.plot((0, 0), (0, 1), color="#0000ff", lw=1)

ind = 800

thisr, thistheta = r[ind], theta[ind]

ax.plot([thistheta], [thisr], 'o')

ax.annotate('a polar annotation',

xy=(thistheta, thisr), # theta, radius

xytext=(0.05, 0.05), # fraction, fraction

textcoords='figure fraction',

arrowprops=dict(facecolor='black', shrink=0.05),

horizontalalignment='left',

verticalalignment='baseline',

# You can also use polar notation on a catesian axes. Here the

# native coordinate system ('data') is cartesian, so you need to

# specify the xycoords and textcoords as 'polar' if you want to

# use (theta, radius)

from matplotlib.patches import Ellipse

el = Ellipse((0, 0), 10, 20, facecolor='r', alpha=0.5)

fig = plt.figure()

ax = fig.add_subplot(111, aspect='equal')

ax.add_artist(el)

el.set_clip_box(ax.bbox)

ax.annotate('the top',

xy=(np.pi/2., 10.), # theta, radius

xytext=(np.pi/3, 20.), # theta, radius

xycoords='polar',

textcoords='polar',

arrowprops=dict(facecolor='black', shrink=0.05),

horizontalalignment='left',

verticalalignment='baseline',

clip_on=True, # clip to the axes bounding box

)

ax.set_xlim(-20, 20)

from datetime import datetime

import matplotlib.testing.jpl_units as units

units.register()

# generate some data

t = units.Epoch("ET", dt=datetime(2009, 4, 27))

value = 10.0 * units.deg

day = units.Duration("ET", 24.0 * 60.0 * 60.0)

fig = plt.figure()

# Top-Left

ax1 = fig.add_subplot(221)

ax1.plot([t], [value], yunits='deg', color='red')

ax1.fill([733525.0, 733525.0, 733526.0, 733526.0],

[0.0, 0.0, 90.0, 0.0], 'b')

# Top-Right

ax2 = fig.add_subplot(222)

ax2.plot([t], [value], yunits='deg', color='red')

ax2.fill([t, t, t + day, t + day],

[0.0, 0.0, 90.0, 0.0], 'b')

# Bottom-Left

ax3 = fig.add_subplot(223)

ax3.plot([t], [value], yunits='deg', color='red')

ax3.fill([733525.0, 733525.0, 733526.0, 733526.0],

[0 * units.deg, 0 * units.deg, 90 * units.deg, 0 * units.deg],

'b')

# Bottom-Right

ax4 = fig.add_subplot(224)

ax4.plot([t], [value], yunits='deg', color='red')

ax4.fill([t, t, t + day, t + day],

[0 * units.deg, 0 * units.deg, 90 * units.deg, 0 * units.deg],

facecolor="blue")

# Issue #1796: don't let lines.marker affect the grid

matplotlib.rcParams['lines.marker'] = 'o'

matplotlib.rcParams['axes.grid'] = True

fig = plt.figure()

plt.subplot(211)

plt.plot([0], [0], 'o')

plt.subplot(212)

plt.plot([1], [1], 'o')

# Reuse testcase from above for a labeled data test

data = {'a': [0], 'b': [1]}

fig = plt.figure()

plt.subplot(211)

plt.plot('a', 'a', 'o', data=data)

plt.subplot(212)

time1 = [721964.0]

data1 = [-65.54]

fig = plt.figure()

plt.subplot(211)

plt.plot_date(time1, data1, 'o', color='r')

plt.subplot(212)

xdata = np.array([[0.53295185, 0.23052951, 0.19057629, 0.66724975,

0.96577916, 0.73136095, 0.60823287, 0.01792100,

0.29744742, 0.27164665],

[0.27980120, 0.25814229, 0.02818193, 0.12966456,

0.57446277, 0.58167607, 0.71028245, 0.69112737,

0.89923072, 0.99072476],

[0.81218578, 0.80464528, 0.76071809, 0.85616314,

0.12757994, 0.94324936, 0.73078663, 0.09658102,

0.60703967, 0.77664978],

[0.28332265, 0.81479711, 0.86985333, 0.43797066,

0.32540082, 0.43819229, 0.92230363, 0.49414252,

0.68168256, 0.05922372],

[0.10721335, 0.93904142, 0.79163075, 0.73232848,

0.90283839, 0.68408046, 0.25502302, 0.95976614,

0.59214115, 0.13663711],

[0.28087456, 0.33127607, 0.15530412, 0.76558121,

0.83389773, 0.03735974, 0.98717738, 0.71432229,

0.54881366, 0.86893953],

[0.77995937, 0.99555600, 0.29688434, 0.15646162,

0.05184800, 0.37161935, 0.12998491, 0.09377296,

0.36882507, 0.36583435],

[0.37851836, 0.05315792, 0.63144617, 0.25003433,

0.69586032, 0.11393988, 0.92362096, 0.88045438,

0.93530252, 0.68275072],

[0.86486596, 0.83236675, 0.82960664, 0.57796630,

0.25724233, 0.84841095, 0.90862812, 0.64414887,

0.35652720, 0.71026066],

[0.01383268, 0.34060930, 0.76084285, 0.70800694,

0.87634056, 0.08213693, 0.54655021, 0.98123181,

0.44080053, 0.86815815]])

y1 = np.arange(10).reshape((1, -1))

y2 = np.arange(10).reshape((-1, 1))

fig = plt.figure()

plt.subplot(411)

plt.plot(y1)

plt.subplot(412)

plt.plot(y2)

plt.subplot(413)

with pytest.raises(ValueError):

plt.plot((y1, y2))

plt.subplot(414)

fig = plt.figure()

plt.subplot(311)

plt.plot(np.arange(10), np.ones((10,)))

plt.subplot(312)

plt.plot(np.ones((10,)), np.arange(10))

plt.subplot(313)

D2R = np.pi / 180.0

fig = plt.figure()

plt.subplot(111, polar=True)

plt.polar([179*D2R, -179*D2R], [0.2, 0.1], "b.-")

plt.polar([179*D2R, 181*D2R], [0.2, 0.1], "g.-")

plt.rgrids([0.05, 0.1, 0.15, 0.2, 0.25, 0.3])

assert len(fig.axes) == 1, 'More than one polar axes created.'

fig = plt.figure()

plt.subplot(111, polar=True)

plt.polar([2*D2R, -2*D2R], [0.2, 0.1], "b.-")

plt.polar([2*D2R, 358*D2R], [0.2, 0.1], "g.-")

plt.polar([358*D2R, 2*D2R], [0.2, 0.1], "r.-")

import matplotlib.testing.jpl_units as units

units.register()

pi = np.pi

deg = units.UnitDbl(1.0, "deg")

km = units.UnitDbl(1.0, "km")

x1 = [pi/6.0, pi/4.0, pi/3.0, pi/2.0]

x2 = [30.0*deg, 45.0*deg, 60.0*deg, 90.0*deg]

y1 = [1.0, 2.0, 3.0, 4.0]

y2 = [4.0, 3.0, 2.0, 1.0]

fig = plt.figure()

plt.polar(x2, y1, color="blue")

# polar(x2, y1, color = "red", xunits="rad")

# polar(x2, y2, color = "green")

fig = plt.figure()

# make sure runits and theta units work

y1 = [y*km for y in y1]

plt.polar(x2, y1, color="blue", thetaunits="rad", runits="km")

assert isinstance(plt.gca().get_xaxis().get_major_formatter(),

r = np.arange(0, 3.0, 0.01)

theta = 2*np.pi*r

fig = plt.figure()

ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)

ax.plot(theta, r)

ax.set_rmax(2.0)

r = np.arange(0, 3.0, 0.01)

theta = 2*np.pi*r

fig = plt.figure()

ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)

ax.plot(theta, r)

ax.set_theta_zero_location("NW")

from datetime import datetime

import matplotlib.testing.jpl_units as units

units.register()

# generate some data

t0 = units.Epoch("ET", dt=datetime(2009, 1, 20))

tf = units.Epoch("ET", dt=datetime(2009, 1, 21))

dt = units.Duration("ET", units.day.convert("sec"))

fig = plt.figure()

plt.axvspan(t0, tf, facecolor="blue", alpha=0.25)

ax = plt.gca()

from datetime import datetime

import matplotlib.testing.jpl_units as units

units.register()

# generate some data

t0 = units.Epoch("ET", dt=datetime(2009, 1, 20))

tf = units.Epoch("ET", dt=datetime(2009, 1, 21))

dt = units.Duration("ET", units.day.convert("sec"))

fig = plt.figure()

plt.axhspan(t0, tf, facecolor="blue", alpha=0.25)

ax = plt.gca()

# this test exposes sf bug 2856228

fig = plt.figure()

ax = fig.add_subplot(111)

data = (np.arange(2000) / 2000).reshape((2, 1000))

x, y = data

ax.hexbin(x, y, extent=[.1, .3, .6, .7])

# Reuse testcase from above for a labeled data test

data = {"x": x, "y": y}

fig = plt.figure()

ax = fig.add_subplot(111)

# From #1973: Test that picking a hexbin collection works

class FauxMouseEvent:

def __init__(self, x, y):

self.x = x

self.y = y

fig = plt.figure()

ax = fig.add_subplot(111)

data = (np.arange(200) / 200).reshape((2, 100))

x, y = data

hb = ax.hexbin(x, y, extent=[.1, .3, .6, .7], picker=-1)

# Issue #1636

fig = plt.figure()

np.random.seed(0)

n = 100000

x = np.random.standard_normal(n)

y = 2.0 + 3.0 * x + 4.0 * np.random.standard_normal(n)

y = np.power(2, y * 0.5)

ax = fig.add_subplot(111)

# Test gh:1553

# Calling invert_xaxis prior to plotting should not disable autoscaling

# while still maintaining the inverted direction

fig = plt.figure()

ax = fig.gca()

ax.invert_xaxis()

ax.plot([-5, -3, 2, 4], [1, 2, -3, 5])

assert ax.get_xlim() == (4, -5)

assert ax.get_ylim() == (-3, 5)

plt.close()

fig = plt.figure()

ax = fig.gca()

ax.invert_yaxis()

ax.plot([-5, -3, 2, 4], [1, 2, -3, 5])

assert ax.get_xlim() == (-5, 4)

assert ax.get_ylim() == (5, -3)

x = np.arange(0., np.e, 0.01)

# silence divide by zero warning from log(0)

olderr = np.seterr(divide='ignore')

try:

y = np.log(x)

finally:

np.seterr(**olderr)

x[len(x)//2] = np.nan

fig = plt.figure()

ax = fig.add_subplot(111)

# Create a NxN image

N = 100

(x, y) = np.indices((N, N))

x -= N//2

y -= N//2

r = np.sqrt(x**2+y**2-x*y)

# Create a contour plot at N/4 and extract both the clip path and transform

fig = plt.figure()

ax = fig.add_subplot(111)

ax.imshow(r)

# Reuse testcase from above for a labeled data test

data = {"r": r}

fig = plt.figure()

ax = fig.add_subplot(111)

# As originally reported by Gellule Xg <gellule.xg@free.fr>

# Create a NxN image

N = 100

(x, y) = np.indices((N, N))

x -= N//2

y -= N//2

r = np.sqrt(x**2+y**2-x*y)

# Create a contour plot at N/4 and extract both the clip path and transform

fig = plt.figure()

ax = fig.add_subplot(111)

c = ax.contour(r, [N/4])

x = c.collections[0]

clipPath = x.get_paths()[0]

clipTransform = x.get_transform()

from matplotlib.transforms import TransformedPath

clip_path = TransformedPath(clipPath, clipTransform)

# Plot the image clipped by the contour

# Bug #2890979 reported by Matthew West

from matplotlib import collections as mcoll

fig = plt.figure()

ax = fig.add_subplot(111)

verts = np.array([[1, 1], [1, 2], [2, 2], [2, 1]])

c = mcoll.PolyCollection([verts], linewidths=40)

ax.add_collection(c)

ax.set_xbound(0, 3)

fig = plt.figure()

ax = fig.add_subplot(211)

with pytest.raises(ValueError):

fig = plt.figure()

ax = fig.add_subplot(211)

with pytest.raises(ValueError):

x = np.arange(0.0, 2, 0.02)

y1 = np.sin(2*np.pi*x)

y2 = 1.2*np.sin(4*np.pi*x)

fig = plt.figure()

ax = fig.add_subplot(211)

ax.plot(x, y1, x, y2, color='black')

ax.fill_between(x, y1, y2, where=y2 >= y1, facecolor='white', hatch='/',

interpolate=True)

ax.fill_between(x, y1, y2, where=y2 <= y1, facecolor='red',

interpolate=True)

# Test support for masked arrays.

y2 = np.ma.masked_greater(y2, 1.0)

# Test that plotting works for masked arrays with the first element masked

y2[0] = np.ma.masked

ax1 = fig.add_subplot(212, sharex=ax)

ax1.plot(x, y1, x, y2, color='black')

ax1.fill_between(x, y1, y2, where=y2 >= y1, facecolor='green',

interpolate=True)

ax1.fill_between(x, y1, y2, where=y2 <= y1, facecolor='red',

x = np.array([0, 1, 2, 4, 6, 9, 12, 24])

y = np.array([1000000, 500000, 100000, 100, 5, 0, 0, 0])

fig = plt.figure()

ax = fig.add_subplot(111)

ax.plot(x, y)

ax.set_yscale('symlog')

ax.set_xscale('linear')

# Numbers from -50 to 50, with 0.1 as step

x = np.arange(-50, 50, 0.001)

fig = plt.figure()

ax = fig.add_subplot(511)

# Plots a simple linear function 'f(x) = x'

ax.plot(x, x)

ax.set_xscale('symlog', linthreshx=20.0)

ax.grid(True)

ax = fig.add_subplot(512)

# Plots a simple linear function 'f(x) = x'

ax.plot(x, x)

ax.set_xscale('symlog', linthreshx=2.0)

ax.grid(True)

ax = fig.add_subplot(513)

# Plots a simple linear function 'f(x) = x'

ax.plot(x, x)

ax.set_xscale('symlog', linthreshx=1.0)

ax.grid(True)

ax = fig.add_subplot(514)

# Plots a simple linear function 'f(x) = x'

ax.plot(x, x)

ax.set_xscale('symlog', linthreshx=0.1)

ax.grid(True)

ax = fig.add_subplot(515)

# Plots a simple linear function 'f(x) = x'

ax.plot(x, x)

ax.set_xscale('symlog', linthreshx=0.01)

ax.grid(True)

# Smoketest to catch issue found in gh:5205

x = [-1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5]