1772 lines
64 KiB
Python
1772 lines
64 KiB
Python
from sympy import (
|
|
latex, exp, symbols, I, pi, sin, cos, tan, log, sqrt,
|
|
re, im, arg, frac, Sum, S, Abs, lambdify,
|
|
Function, dsolve, Eq, floor, Tuple
|
|
)
|
|
from sympy.external import import_module
|
|
from sympy.plotting.series import (
|
|
LineOver1DRangeSeries, Parametric2DLineSeries, Parametric3DLineSeries,
|
|
SurfaceOver2DRangeSeries, ContourSeries, ParametricSurfaceSeries,
|
|
ImplicitSeries, _set_discretization_points, List2DSeries
|
|
)
|
|
from sympy.testing.pytest import raises, warns, XFAIL, skip, ignore_warnings
|
|
|
|
np = import_module('numpy')
|
|
|
|
|
|
def test_adaptive():
|
|
# verify that adaptive-related keywords produces the expected results
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, y = symbols("x, y")
|
|
|
|
s1 = LineOver1DRangeSeries(sin(x), (x, -10, 10), "", adaptive=True,
|
|
depth=2)
|
|
x1, _ = s1.get_data()
|
|
s2 = LineOver1DRangeSeries(sin(x), (x, -10, 10), "", adaptive=True,
|
|
depth=5)
|
|
x2, _ = s2.get_data()
|
|
s3 = LineOver1DRangeSeries(sin(x), (x, -10, 10), "", adaptive=True)
|
|
x3, _ = s3.get_data()
|
|
assert len(x1) < len(x2) < len(x3)
|
|
|
|
s1 = Parametric2DLineSeries(cos(x), sin(x), (x, 0, 2*pi),
|
|
adaptive=True, depth=2)
|
|
x1, _, _, = s1.get_data()
|
|
s2 = Parametric2DLineSeries(cos(x), sin(x), (x, 0, 2*pi),
|
|
adaptive=True, depth=5)
|
|
x2, _, _ = s2.get_data()
|
|
s3 = Parametric2DLineSeries(cos(x), sin(x), (x, 0, 2*pi),
|
|
adaptive=True)
|
|
x3, _, _ = s3.get_data()
|
|
assert len(x1) < len(x2) < len(x3)
|
|
|
|
|
|
def test_detect_poles():
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, u = symbols("x, u")
|
|
|
|
s1 = LineOver1DRangeSeries(tan(x), (x, -pi, pi),
|
|
adaptive=False, n=1000, detect_poles=False)
|
|
xx1, yy1 = s1.get_data()
|
|
s2 = LineOver1DRangeSeries(tan(x), (x, -pi, pi),
|
|
adaptive=False, n=1000, detect_poles=True, eps=0.01)
|
|
xx2, yy2 = s2.get_data()
|
|
# eps is too small: doesn't detect any poles
|
|
s3 = LineOver1DRangeSeries(tan(x), (x, -pi, pi),
|
|
adaptive=False, n=1000, detect_poles=True, eps=1e-06)
|
|
xx3, yy3 = s3.get_data()
|
|
s4 = LineOver1DRangeSeries(tan(x), (x, -pi, pi),
|
|
adaptive=False, n=1000, detect_poles="symbolic")
|
|
xx4, yy4 = s4.get_data()
|
|
|
|
assert np.allclose(xx1, xx2) and np.allclose(xx1, xx3) and np.allclose(xx1, xx4)
|
|
assert not np.any(np.isnan(yy1))
|
|
assert not np.any(np.isnan(yy3))
|
|
assert np.any(np.isnan(yy2))
|
|
assert np.any(np.isnan(yy4))
|
|
assert len(s2.poles_locations) == len(s3.poles_locations) == 0
|
|
assert len(s4.poles_locations) == 2
|
|
assert np.allclose(np.abs(s4.poles_locations), np.pi / 2)
|
|
|
|
with warns(
|
|
UserWarning,
|
|
match="NumPy is unable to evaluate with complex numbers some of",
|
|
test_stacklevel=False,
|
|
):
|
|
s1 = LineOver1DRangeSeries(frac(x), (x, -10, 10),
|
|
adaptive=False, n=1000, detect_poles=False)
|
|
s2 = LineOver1DRangeSeries(frac(x), (x, -10, 10),
|
|
adaptive=False, n=1000, detect_poles=True, eps=0.05)
|
|
s3 = LineOver1DRangeSeries(frac(x), (x, -10, 10),
|
|
adaptive=False, n=1000, detect_poles="symbolic")
|
|
xx1, yy1 = s1.get_data()
|
|
xx2, yy2 = s2.get_data()
|
|
xx3, yy3 = s3.get_data()
|
|
assert np.allclose(xx1, xx2) and np.allclose(xx1, xx3)
|
|
assert not np.any(np.isnan(yy1))
|
|
assert np.any(np.isnan(yy2)) and np.any(np.isnan(yy2))
|
|
assert not np.allclose(yy1, yy2, equal_nan=True)
|
|
# The poles below are actually step discontinuities.
|
|
assert len(s3.poles_locations) == 21
|
|
|
|
s1 = LineOver1DRangeSeries(tan(u * x), (x, -pi, pi), params={u: 1},
|
|
adaptive=False, n=1000, detect_poles=False)
|
|
xx1, yy1 = s1.get_data()
|
|
s2 = LineOver1DRangeSeries(tan(u * x), (x, -pi, pi), params={u: 1},
|
|
adaptive=False, n=1000, detect_poles=True, eps=0.01)
|
|
xx2, yy2 = s2.get_data()
|
|
# eps is too small: doesn't detect any poles
|
|
s3 = LineOver1DRangeSeries(tan(u * x), (x, -pi, pi), params={u: 1},
|
|
adaptive=False, n=1000, detect_poles=True, eps=1e-06)
|
|
xx3, yy3 = s3.get_data()
|
|
s4 = LineOver1DRangeSeries(tan(u * x), (x, -pi, pi), params={u: 1},
|
|
adaptive=False, n=1000, detect_poles="symbolic")
|
|
xx4, yy4 = s4.get_data()
|
|
|
|
assert np.allclose(xx1, xx2) and np.allclose(xx1, xx3) and np.allclose(xx1, xx4)
|
|
assert not np.any(np.isnan(yy1))
|
|
assert not np.any(np.isnan(yy3))
|
|
assert np.any(np.isnan(yy2))
|
|
assert np.any(np.isnan(yy4))
|
|
assert len(s2.poles_locations) == len(s3.poles_locations) == 0
|
|
assert len(s4.poles_locations) == 2
|
|
assert np.allclose(np.abs(s4.poles_locations), np.pi / 2)
|
|
|
|
with warns(
|
|
UserWarning,
|
|
match="NumPy is unable to evaluate with complex numbers some of",
|
|
test_stacklevel=False,
|
|
):
|
|
u, v = symbols("u, v", real=True)
|
|
n = S(1) / 3
|
|
f = (u + I * v)**n
|
|
r, i = re(f), im(f)
|
|
s1 = Parametric2DLineSeries(r.subs(u, -2), i.subs(u, -2), (v, -2, 2),
|
|
adaptive=False, n=1000, detect_poles=False)
|
|
s2 = Parametric2DLineSeries(r.subs(u, -2), i.subs(u, -2), (v, -2, 2),
|
|
adaptive=False, n=1000, detect_poles=True)
|
|
with ignore_warnings(RuntimeWarning):
|
|
xx1, yy1, pp1 = s1.get_data()
|
|
assert not np.isnan(yy1).any()
|
|
xx2, yy2, pp2 = s2.get_data()
|
|
assert np.isnan(yy2).any()
|
|
|
|
with warns(
|
|
UserWarning,
|
|
match="NumPy is unable to evaluate with complex numbers some of",
|
|
test_stacklevel=False,
|
|
):
|
|
f = (x * u + x * I * v)**n
|
|
r, i = re(f), im(f)
|
|
s1 = Parametric2DLineSeries(r.subs(u, -2), i.subs(u, -2),
|
|
(v, -2, 2), params={x: 1},
|
|
adaptive=False, n1=1000, detect_poles=False)
|
|
s2 = Parametric2DLineSeries(r.subs(u, -2), i.subs(u, -2),
|
|
(v, -2, 2), params={x: 1},
|
|
adaptive=False, n1=1000, detect_poles=True)
|
|
with ignore_warnings(RuntimeWarning):
|
|
xx1, yy1, pp1 = s1.get_data()
|
|
assert not np.isnan(yy1).any()
|
|
xx2, yy2, pp2 = s2.get_data()
|
|
assert np.isnan(yy2).any()
|
|
|
|
|
|
def test_number_discretization_points():
|
|
# verify that the different ways to set the number of discretization
|
|
# points are consistent with each other.
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, y, z = symbols("x:z")
|
|
|
|
for pt in [LineOver1DRangeSeries, Parametric2DLineSeries,
|
|
Parametric3DLineSeries]:
|
|
kw1 = _set_discretization_points({"n": 10}, pt)
|
|
kw2 = _set_discretization_points({"n": [10, 20, 30]}, pt)
|
|
kw3 = _set_discretization_points({"n1": 10}, pt)
|
|
assert all(("n1" in kw) and kw["n1"] == 10 for kw in [kw1, kw2, kw3])
|
|
|
|
for pt in [SurfaceOver2DRangeSeries, ContourSeries, ParametricSurfaceSeries,
|
|
ImplicitSeries]:
|
|
kw1 = _set_discretization_points({"n": 10}, pt)
|
|
kw2 = _set_discretization_points({"n": [10, 20, 30]}, pt)
|
|
kw3 = _set_discretization_points({"n1": 10, "n2": 20}, pt)
|
|
assert kw1["n1"] == kw1["n2"] == 10
|
|
assert all((kw["n1"] == 10) and (kw["n2"] == 20) for kw in [kw2, kw3])
|
|
|
|
# verify that line-related series can deal with large float number of
|
|
# discretization points
|
|
LineOver1DRangeSeries(cos(x), (x, -5, 5), adaptive=False, n=1e04).get_data()
|
|
|
|
|
|
def test_list2dseries():
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
xx = np.linspace(-3, 3, 10)
|
|
yy1 = np.cos(xx)
|
|
yy2 = np.linspace(-3, 3, 20)
|
|
|
|
# same number of elements: everything is fine
|
|
s = List2DSeries(xx, yy1)
|
|
assert not s.is_parametric
|
|
# different number of elements: error
|
|
raises(ValueError, lambda: List2DSeries(xx, yy2))
|
|
|
|
# no color func: returns only x, y components and s in not parametric
|
|
s = List2DSeries(xx, yy1)
|
|
xxs, yys = s.get_data()
|
|
assert np.allclose(xx, xxs)
|
|
assert np.allclose(yy1, yys)
|
|
assert not s.is_parametric
|
|
|
|
|
|
def test_interactive_vs_noninteractive():
|
|
# verify that if a *Series class receives a `params` dictionary, it sets
|
|
# is_interactive=True
|
|
x, y, z, u, v = symbols("x, y, z, u, v")
|
|
|
|
s = LineOver1DRangeSeries(cos(x), (x, -5, 5))
|
|
assert not s.is_interactive
|
|
s = LineOver1DRangeSeries(u * cos(x), (x, -5, 5), params={u: 1})
|
|
assert s.is_interactive
|
|
|
|
s = Parametric2DLineSeries(cos(x), sin(x), (x, -5, 5))
|
|
assert not s.is_interactive
|
|
s = Parametric2DLineSeries(u * cos(x), u * sin(x), (x, -5, 5),
|
|
params={u: 1})
|
|
assert s.is_interactive
|
|
|
|
s = Parametric3DLineSeries(cos(x), sin(x), x, (x, -5, 5))
|
|
assert not s.is_interactive
|
|
s = Parametric3DLineSeries(u * cos(x), u * sin(x), x, (x, -5, 5),
|
|
params={u: 1})
|
|
assert s.is_interactive
|
|
|
|
s = SurfaceOver2DRangeSeries(cos(x * y), (x, -5, 5), (y, -5, 5))
|
|
assert not s.is_interactive
|
|
s = SurfaceOver2DRangeSeries(u * cos(x * y), (x, -5, 5), (y, -5, 5),
|
|
params={u: 1})
|
|
assert s.is_interactive
|
|
|
|
s = ContourSeries(cos(x * y), (x, -5, 5), (y, -5, 5))
|
|
assert not s.is_interactive
|
|
s = ContourSeries(u * cos(x * y), (x, -5, 5), (y, -5, 5),
|
|
params={u: 1})
|
|
assert s.is_interactive
|
|
|
|
s = ParametricSurfaceSeries(u * cos(v), v * sin(u), u + v,
|
|
(u, -5, 5), (v, -5, 5))
|
|
assert not s.is_interactive
|
|
s = ParametricSurfaceSeries(u * cos(v * x), v * sin(u), u + v,
|
|
(u, -5, 5), (v, -5, 5), params={x: 1})
|
|
assert s.is_interactive
|
|
|
|
|
|
def test_lin_log_scale():
|
|
# Verify that data series create the correct spacing in the data.
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, y, z = symbols("x, y, z")
|
|
|
|
s = LineOver1DRangeSeries(x, (x, 1, 10), adaptive=False, n=50,
|
|
xscale="linear")
|
|
xx, _ = s.get_data()
|
|
assert np.isclose(xx[1] - xx[0], xx[-1] - xx[-2])
|
|
|
|
s = LineOver1DRangeSeries(x, (x, 1, 10), adaptive=False, n=50,
|
|
xscale="log")
|
|
xx, _ = s.get_data()
|
|
assert not np.isclose(xx[1] - xx[0], xx[-1] - xx[-2])
|
|
|
|
s = Parametric2DLineSeries(
|
|
cos(x), sin(x), (x, pi / 2, 1.5 * pi), adaptive=False, n=50,
|
|
xscale="linear")
|
|
_, _, param = s.get_data()
|
|
assert np.isclose(param[1] - param[0], param[-1] - param[-2])
|
|
|
|
s = Parametric2DLineSeries(
|
|
cos(x), sin(x), (x, pi / 2, 1.5 * pi), adaptive=False, n=50,
|
|
xscale="log")
|
|
_, _, param = s.get_data()
|
|
assert not np.isclose(param[1] - param[0], param[-1] - param[-2])
|
|
|
|
s = Parametric3DLineSeries(
|
|
cos(x), sin(x), x, (x, pi / 2, 1.5 * pi), adaptive=False, n=50,
|
|
xscale="linear")
|
|
_, _, _, param = s.get_data()
|
|
assert np.isclose(param[1] - param[0], param[-1] - param[-2])
|
|
|
|
s = Parametric3DLineSeries(
|
|
cos(x), sin(x), x, (x, pi / 2, 1.5 * pi), adaptive=False, n=50,
|
|
xscale="log")
|
|
_, _, _, param = s.get_data()
|
|
assert not np.isclose(param[1] - param[0], param[-1] - param[-2])
|
|
|
|
s = SurfaceOver2DRangeSeries(
|
|
cos(x ** 2 + y ** 2), (x, 1, 5), (y, 1, 5), n=10,
|
|
xscale="linear", yscale="linear")
|
|
xx, yy, _ = s.get_data()
|
|
assert np.isclose(xx[0, 1] - xx[0, 0], xx[0, -1] - xx[0, -2])
|
|
assert np.isclose(yy[1, 0] - yy[0, 0], yy[-1, 0] - yy[-2, 0])
|
|
|
|
s = SurfaceOver2DRangeSeries(
|
|
cos(x ** 2 + y ** 2), (x, 1, 5), (y, 1, 5), n=10,
|
|
xscale="log", yscale="log")
|
|
xx, yy, _ = s.get_data()
|
|
assert not np.isclose(xx[0, 1] - xx[0, 0], xx[0, -1] - xx[0, -2])
|
|
assert not np.isclose(yy[1, 0] - yy[0, 0], yy[-1, 0] - yy[-2, 0])
|
|
|
|
s = ImplicitSeries(
|
|
cos(x ** 2 + y ** 2) > 0, (x, 1, 5), (y, 1, 5),
|
|
n1=10, n2=10, xscale="linear", yscale="linear", adaptive=False)
|
|
xx, yy, _, _ = s.get_data()
|
|
assert np.isclose(xx[0, 1] - xx[0, 0], xx[0, -1] - xx[0, -2])
|
|
assert np.isclose(yy[1, 0] - yy[0, 0], yy[-1, 0] - yy[-2, 0])
|
|
|
|
s = ImplicitSeries(
|
|
cos(x ** 2 + y ** 2) > 0, (x, 1, 5), (y, 1, 5),
|
|
n=10, xscale="log", yscale="log", adaptive=False)
|
|
xx, yy, _, _ = s.get_data()
|
|
assert not np.isclose(xx[0, 1] - xx[0, 0], xx[0, -1] - xx[0, -2])
|
|
assert not np.isclose(yy[1, 0] - yy[0, 0], yy[-1, 0] - yy[-2, 0])
|
|
|
|
|
|
def test_rendering_kw():
|
|
# verify that each series exposes the `rendering_kw` attribute
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
u, v, x, y, z = symbols("u, v, x:z")
|
|
|
|
s = List2DSeries([1, 2, 3], [4, 5, 6])
|
|
assert isinstance(s.rendering_kw, dict)
|
|
|
|
s = LineOver1DRangeSeries(1, (x, -5, 5))
|
|
assert isinstance(s.rendering_kw, dict)
|
|
|
|
s = Parametric2DLineSeries(sin(x), cos(x), (x, 0, pi))
|
|
assert isinstance(s.rendering_kw, dict)
|
|
|
|
s = Parametric3DLineSeries(cos(x), sin(x), x, (x, 0, 2 * pi))
|
|
assert isinstance(s.rendering_kw, dict)
|
|
|
|
s = SurfaceOver2DRangeSeries(x + y, (x, -2, 2), (y, -3, 3))
|
|
assert isinstance(s.rendering_kw, dict)
|
|
|
|
s = ContourSeries(x + y, (x, -2, 2), (y, -3, 3))
|
|
assert isinstance(s.rendering_kw, dict)
|
|
|
|
s = ParametricSurfaceSeries(1, x, y, (x, 0, 1), (y, 0, 1))
|
|
assert isinstance(s.rendering_kw, dict)
|
|
|
|
|
|
def test_data_shape():
|
|
# Verify that the series produces the correct data shape when the input
|
|
# expression is a number.
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
u, x, y, z = symbols("u, x:z")
|
|
|
|
# scalar expression: it should return a numpy ones array
|
|
s = LineOver1DRangeSeries(1, (x, -5, 5))
|
|
xx, yy = s.get_data()
|
|
assert len(xx) == len(yy)
|
|
assert np.all(yy == 1)
|
|
|
|
s = LineOver1DRangeSeries(1, (x, -5, 5), adaptive=False, n=10)
|
|
xx, yy = s.get_data()
|
|
assert len(xx) == len(yy) == 10
|
|
assert np.all(yy == 1)
|
|
|
|
s = Parametric2DLineSeries(sin(x), 1, (x, 0, pi))
|
|
xx, yy, param = s.get_data()
|
|
assert (len(xx) == len(yy)) and (len(xx) == len(param))
|
|
assert np.all(yy == 1)
|
|
|
|
s = Parametric2DLineSeries(1, sin(x), (x, 0, pi))
|
|
xx, yy, param = s.get_data()
|
|
assert (len(xx) == len(yy)) and (len(xx) == len(param))
|
|
assert np.all(xx == 1)
|
|
|
|
s = Parametric2DLineSeries(sin(x), 1, (x, 0, pi), adaptive=False)
|
|
xx, yy, param = s.get_data()
|
|
assert (len(xx) == len(yy)) and (len(xx) == len(param))
|
|
assert np.all(yy == 1)
|
|
|
|
s = Parametric2DLineSeries(1, sin(x), (x, 0, pi), adaptive=False)
|
|
xx, yy, param = s.get_data()
|
|
assert (len(xx) == len(yy)) and (len(xx) == len(param))
|
|
assert np.all(xx == 1)
|
|
|
|
s = Parametric3DLineSeries(cos(x), sin(x), 1, (x, 0, 2 * pi))
|
|
xx, yy, zz, param = s.get_data()
|
|
assert (len(xx) == len(yy)) and (len(xx) == len(zz)) and (len(xx) == len(param))
|
|
assert np.all(zz == 1)
|
|
|
|
s = Parametric3DLineSeries(cos(x), 1, x, (x, 0, 2 * pi))
|
|
xx, yy, zz, param = s.get_data()
|
|
assert (len(xx) == len(yy)) and (len(xx) == len(zz)) and (len(xx) == len(param))
|
|
assert np.all(yy == 1)
|
|
|
|
s = Parametric3DLineSeries(1, sin(x), x, (x, 0, 2 * pi))
|
|
xx, yy, zz, param = s.get_data()
|
|
assert (len(xx) == len(yy)) and (len(xx) == len(zz)) and (len(xx) == len(param))
|
|
assert np.all(xx == 1)
|
|
|
|
s = SurfaceOver2DRangeSeries(1, (x, -2, 2), (y, -3, 3))
|
|
xx, yy, zz = s.get_data()
|
|
assert (xx.shape == yy.shape) and (xx.shape == zz.shape)
|
|
assert np.all(zz == 1)
|
|
|
|
s = ParametricSurfaceSeries(1, x, y, (x, 0, 1), (y, 0, 1))
|
|
xx, yy, zz, uu, vv = s.get_data()
|
|
assert xx.shape == yy.shape == zz.shape == uu.shape == vv.shape
|
|
assert np.all(xx == 1)
|
|
|
|
s = ParametricSurfaceSeries(1, 1, y, (x, 0, 1), (y, 0, 1))
|
|
xx, yy, zz, uu, vv = s.get_data()
|
|
assert xx.shape == yy.shape == zz.shape == uu.shape == vv.shape
|
|
assert np.all(yy == 1)
|
|
|
|
s = ParametricSurfaceSeries(x, 1, 1, (x, 0, 1), (y, 0, 1))
|
|
xx, yy, zz, uu, vv = s.get_data()
|
|
assert xx.shape == yy.shape == zz.shape == uu.shape == vv.shape
|
|
assert np.all(zz == 1)
|
|
|
|
|
|
def test_only_integers():
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, y, u, v = symbols("x, y, u, v")
|
|
|
|
s = LineOver1DRangeSeries(sin(x), (x, -5.5, 4.5), "",
|
|
adaptive=False, only_integers=True)
|
|
xx, _ = s.get_data()
|
|
assert len(xx) == 10
|
|
assert xx[0] == -5 and xx[-1] == 4
|
|
|
|
s = Parametric2DLineSeries(cos(x), sin(x), (x, 0, 2 * pi), "",
|
|
adaptive=False, only_integers=True)
|
|
_, _, p = s.get_data()
|
|
assert len(p) == 7
|
|
assert p[0] == 0 and p[-1] == 6
|
|
|
|
s = Parametric3DLineSeries(cos(x), sin(x), x, (x, 0, 2 * pi), "",
|
|
adaptive=False, only_integers=True)
|
|
_, _, _, p = s.get_data()
|
|
assert len(p) == 7
|
|
assert p[0] == 0 and p[-1] == 6
|
|
|
|
s = SurfaceOver2DRangeSeries(cos(x**2 + y**2), (x, -5.5, 5.5),
|
|
(y, -3.5, 3.5), "",
|
|
adaptive=False, only_integers=True)
|
|
xx, yy, _ = s.get_data()
|
|
assert xx.shape == yy.shape == (7, 11)
|
|
assert np.allclose(xx[:, 0] - (-5) * np.ones(7), 0)
|
|
assert np.allclose(xx[0, :] - np.linspace(-5, 5, 11), 0)
|
|
assert np.allclose(yy[:, 0] - np.linspace(-3, 3, 7), 0)
|
|
assert np.allclose(yy[0, :] - (-3) * np.ones(11), 0)
|
|
|
|
r = 2 + sin(7 * u + 5 * v)
|
|
expr = (
|
|
r * cos(u) * sin(v),
|
|
r * sin(u) * sin(v),
|
|
r * cos(v)
|
|
)
|
|
s = ParametricSurfaceSeries(*expr, (u, 0, 2 * pi), (v, 0, pi), "",
|
|
adaptive=False, only_integers=True)
|
|
xx, yy, zz, uu, vv = s.get_data()
|
|
assert xx.shape == yy.shape == zz.shape == uu.shape == vv.shape == (4, 7)
|
|
|
|
# only_integers also works with scalar expressions
|
|
s = LineOver1DRangeSeries(1, (x, -5.5, 4.5), "",
|
|
adaptive=False, only_integers=True)
|
|
xx, _ = s.get_data()
|
|
assert len(xx) == 10
|
|
assert xx[0] == -5 and xx[-1] == 4
|
|
|
|
s = Parametric2DLineSeries(cos(x), 1, (x, 0, 2 * pi), "",
|
|
adaptive=False, only_integers=True)
|
|
_, _, p = s.get_data()
|
|
assert len(p) == 7
|
|
assert p[0] == 0 and p[-1] == 6
|
|
|
|
s = SurfaceOver2DRangeSeries(1, (x, -5.5, 5.5), (y, -3.5, 3.5), "",
|
|
adaptive=False, only_integers=True)
|
|
xx, yy, _ = s.get_data()
|
|
assert xx.shape == yy.shape == (7, 11)
|
|
assert np.allclose(xx[:, 0] - (-5) * np.ones(7), 0)
|
|
assert np.allclose(xx[0, :] - np.linspace(-5, 5, 11), 0)
|
|
assert np.allclose(yy[:, 0] - np.linspace(-3, 3, 7), 0)
|
|
assert np.allclose(yy[0, :] - (-3) * np.ones(11), 0)
|
|
|
|
r = 2 + sin(7 * u + 5 * v)
|
|
expr = (
|
|
r * cos(u) * sin(v),
|
|
1,
|
|
r * cos(v)
|
|
)
|
|
s = ParametricSurfaceSeries(*expr, (u, 0, 2 * pi), (v, 0, pi), "",
|
|
adaptive=False, only_integers=True)
|
|
xx, yy, zz, uu, vv = s.get_data()
|
|
assert xx.shape == yy.shape == zz.shape == uu.shape == vv.shape == (4, 7)
|
|
|
|
|
|
def test_is_point_is_filled():
|
|
# verify that `is_point` and `is_filled` are attributes and that they
|
|
# they receive the correct values
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, u = symbols("x, u")
|
|
|
|
s = LineOver1DRangeSeries(cos(x), (x, -5, 5), "",
|
|
is_point=False, is_filled=True)
|
|
assert (not s.is_point) and s.is_filled
|
|
s = LineOver1DRangeSeries(cos(x), (x, -5, 5), "",
|
|
is_point=True, is_filled=False)
|
|
assert s.is_point and (not s.is_filled)
|
|
|
|
s = List2DSeries([0, 1, 2], [3, 4, 5],
|
|
is_point=False, is_filled=True)
|
|
assert (not s.is_point) and s.is_filled
|
|
s = List2DSeries([0, 1, 2], [3, 4, 5],
|
|
is_point=True, is_filled=False)
|
|
assert s.is_point and (not s.is_filled)
|
|
|
|
s = Parametric2DLineSeries(cos(x), sin(x), (x, -5, 5),
|
|
is_point=False, is_filled=True)
|
|
assert (not s.is_point) and s.is_filled
|
|
s = Parametric2DLineSeries(cos(x), sin(x), (x, -5, 5),
|
|
is_point=True, is_filled=False)
|
|
assert s.is_point and (not s.is_filled)
|
|
|
|
s = Parametric3DLineSeries(cos(x), sin(x), x, (x, -5, 5),
|
|
is_point=False, is_filled=True)
|
|
assert (not s.is_point) and s.is_filled
|
|
s = Parametric3DLineSeries(cos(x), sin(x), x, (x, -5, 5),
|
|
is_point=True, is_filled=False)
|
|
assert s.is_point and (not s.is_filled)
|
|
|
|
|
|
def test_is_filled_2d():
|
|
# verify that the is_filled attribute is exposed by the following series
|
|
x, y = symbols("x, y")
|
|
|
|
expr = cos(x**2 + y**2)
|
|
ranges = (x, -2, 2), (y, -2, 2)
|
|
|
|
s = ContourSeries(expr, *ranges)
|
|
assert s.is_filled
|
|
s = ContourSeries(expr, *ranges, is_filled=True)
|
|
assert s.is_filled
|
|
s = ContourSeries(expr, *ranges, is_filled=False)
|
|
assert not s.is_filled
|
|
|
|
|
|
def test_steps():
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, u = symbols("x, u")
|
|
|
|
def do_test(s1, s2):
|
|
if (not s1.is_parametric) and s1.is_2Dline:
|
|
xx1, _ = s1.get_data()
|
|
xx2, _ = s2.get_data()
|
|
elif s1.is_parametric and s1.is_2Dline:
|
|
xx1, _, _ = s1.get_data()
|
|
xx2, _, _ = s2.get_data()
|
|
elif (not s1.is_parametric) and s1.is_3Dline:
|
|
xx1, _, _ = s1.get_data()
|
|
xx2, _, _ = s2.get_data()
|
|
else:
|
|
xx1, _, _, _ = s1.get_data()
|
|
xx2, _, _, _ = s2.get_data()
|
|
assert len(xx1) != len(xx2)
|
|
|
|
s1 = LineOver1DRangeSeries(cos(x), (x, -5, 5), "",
|
|
adaptive=False, n=40, steps=False)
|
|
s2 = LineOver1DRangeSeries(cos(x), (x, -5, 5), "",
|
|
adaptive=False, n=40, steps=True)
|
|
do_test(s1, s2)
|
|
|
|
s1 = List2DSeries([0, 1, 2], [3, 4, 5], steps=False)
|
|
s2 = List2DSeries([0, 1, 2], [3, 4, 5], steps=True)
|
|
do_test(s1, s2)
|
|
|
|
s1 = Parametric2DLineSeries(cos(x), sin(x), (x, -5, 5),
|
|
adaptive=False, n=40, steps=False)
|
|
s2 = Parametric2DLineSeries(cos(x), sin(x), (x, -5, 5),
|
|
adaptive=False, n=40, steps=True)
|
|
do_test(s1, s2)
|
|
|
|
s1 = Parametric3DLineSeries(cos(x), sin(x), x, (x, -5, 5),
|
|
adaptive=False, n=40, steps=False)
|
|
s2 = Parametric3DLineSeries(cos(x), sin(x), x, (x, -5, 5),
|
|
adaptive=False, n=40, steps=True)
|
|
do_test(s1, s2)
|
|
|
|
|
|
def test_interactive_data():
|
|
# verify that InteractiveSeries produces the same numerical data as their
|
|
# corresponding non-interactive series.
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
u, x, y, z = symbols("u, x:z")
|
|
|
|
def do_test(data1, data2):
|
|
assert len(data1) == len(data2)
|
|
for d1, d2 in zip(data1, data2):
|
|
assert np.allclose(d1, d2)
|
|
|
|
s1 = LineOver1DRangeSeries(u * cos(x), (x, -5, 5), params={u: 1}, n=50)
|
|
s2 = LineOver1DRangeSeries(cos(x), (x, -5, 5), adaptive=False, n=50)
|
|
do_test(s1.get_data(), s2.get_data())
|
|
|
|
s1 = Parametric2DLineSeries(
|
|
u * cos(x), u * sin(x), (x, -5, 5), params={u: 1}, n=50)
|
|
s2 = Parametric2DLineSeries(cos(x), sin(x), (x, -5, 5),
|
|
adaptive=False, n=50)
|
|
do_test(s1.get_data(), s2.get_data())
|
|
|
|
s1 = Parametric3DLineSeries(
|
|
u * cos(x), u * sin(x), u * x, (x, -5, 5),
|
|
params={u: 1}, n=50)
|
|
s2 = Parametric3DLineSeries(cos(x), sin(x), x, (x, -5, 5),
|
|
adaptive=False, n=50)
|
|
do_test(s1.get_data(), s2.get_data())
|
|
|
|
s1 = SurfaceOver2DRangeSeries(
|
|
u * cos(x ** 2 + y ** 2), (x, -3, 3), (y, -3, 3),
|
|
params={u: 1}, n1=50, n2=50,)
|
|
s2 = SurfaceOver2DRangeSeries(
|
|
cos(x ** 2 + y ** 2), (x, -3, 3), (y, -3, 3),
|
|
adaptive=False, n1=50, n2=50)
|
|
do_test(s1.get_data(), s2.get_data())
|
|
|
|
s1 = ParametricSurfaceSeries(
|
|
u * cos(x + y), sin(x + y), x - y, (x, -3, 3), (y, -3, 3),
|
|
params={u: 1}, n1=50, n2=50,)
|
|
s2 = ParametricSurfaceSeries(
|
|
cos(x + y), sin(x + y), x - y, (x, -3, 3), (y, -3, 3),
|
|
adaptive=False, n1=50, n2=50,)
|
|
do_test(s1.get_data(), s2.get_data())
|
|
|
|
# real part of a complex function evaluated over a real line with numpy
|
|
expr = re((z ** 2 + 1) / (z ** 2 - 1))
|
|
s1 = LineOver1DRangeSeries(u * expr, (z, -3, 3), adaptive=False, n=50,
|
|
modules=None, params={u: 1})
|
|
s2 = LineOver1DRangeSeries(expr, (z, -3, 3), adaptive=False, n=50,
|
|
modules=None)
|
|
do_test(s1.get_data(), s2.get_data())
|
|
|
|
# real part of a complex function evaluated over a real line with mpmath
|
|
expr = re((z ** 2 + 1) / (z ** 2 - 1))
|
|
s1 = LineOver1DRangeSeries(u * expr, (z, -3, 3), n=50, modules="mpmath",
|
|
params={u: 1})
|
|
s2 = LineOver1DRangeSeries(expr, (z, -3, 3),
|
|
adaptive=False, n=50, modules="mpmath")
|
|
do_test(s1.get_data(), s2.get_data())
|
|
|
|
|
|
def test_list2dseries_interactive():
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, y, u = symbols("x, y, u")
|
|
|
|
s = List2DSeries([1, 2, 3], [1, 2, 3])
|
|
assert not s.is_interactive
|
|
|
|
# symbolic expressions as coordinates, but no ``params``
|
|
raises(ValueError, lambda: List2DSeries([cos(x)], [sin(x)]))
|
|
|
|
# too few parameters
|
|
raises(ValueError,
|
|
lambda: List2DSeries([cos(x), y], [sin(x), 2], params={u: 1}))
|
|
|
|
s = List2DSeries([cos(x)], [sin(x)], params={x: 1})
|
|
assert s.is_interactive
|
|
|
|
s = List2DSeries([x, 2, 3, 4], [4, 3, 2, x], params={x: 3})
|
|
xx, yy = s.get_data()
|
|
assert np.allclose(xx, [3, 2, 3, 4])
|
|
assert np.allclose(yy, [4, 3, 2, 3])
|
|
assert not s.is_parametric
|
|
|
|
# numeric lists + params is present -> interactive series and
|
|
# lists are converted to Tuple.
|
|
s = List2DSeries([1, 2, 3], [1, 2, 3], params={x: 1})
|
|
assert s.is_interactive
|
|
assert isinstance(s.list_x, Tuple)
|
|
assert isinstance(s.list_y, Tuple)
|
|
|
|
|
|
def test_mpmath():
|
|
# test that the argument of complex functions evaluated with mpmath
|
|
# might be different than the one computed with Numpy (different
|
|
# behaviour at branch cuts)
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
z, u = symbols("z, u")
|
|
|
|
s1 = LineOver1DRangeSeries(im(sqrt(-z)), (z, 1e-03, 5),
|
|
adaptive=True, modules=None, force_real_eval=True)
|
|
s2 = LineOver1DRangeSeries(im(sqrt(-z)), (z, 1e-03, 5),
|
|
adaptive=True, modules="mpmath", force_real_eval=True)
|
|
xx1, yy1 = s1.get_data()
|
|
xx2, yy2 = s2.get_data()
|
|
assert np.all(yy1 < 0)
|
|
assert np.all(yy2 > 0)
|
|
|
|
s1 = LineOver1DRangeSeries(im(sqrt(-z)), (z, -5, 5),
|
|
adaptive=False, n=20, modules=None, force_real_eval=True)
|
|
s2 = LineOver1DRangeSeries(im(sqrt(-z)), (z, -5, 5),
|
|
adaptive=False, n=20, modules="mpmath", force_real_eval=True)
|
|
xx1, yy1 = s1.get_data()
|
|
xx2, yy2 = s2.get_data()
|
|
assert np.allclose(xx1, xx2)
|
|
assert not np.allclose(yy1, yy2)
|
|
|
|
|
|
def test_str():
|
|
u, x, y, z = symbols("u, x:z")
|
|
|
|
s = LineOver1DRangeSeries(cos(x), (x, -4, 3))
|
|
assert str(s) == "cartesian line: cos(x) for x over (-4.0, 3.0)"
|
|
|
|
d = {"return": "real"}
|
|
s = LineOver1DRangeSeries(cos(x), (x, -4, 3), **d)
|
|
assert str(s) == "cartesian line: re(cos(x)) for x over (-4.0, 3.0)"
|
|
|
|
d = {"return": "imag"}
|
|
s = LineOver1DRangeSeries(cos(x), (x, -4, 3), **d)
|
|
assert str(s) == "cartesian line: im(cos(x)) for x over (-4.0, 3.0)"
|
|
|
|
d = {"return": "abs"}
|
|
s = LineOver1DRangeSeries(cos(x), (x, -4, 3), **d)
|
|
assert str(s) == "cartesian line: abs(cos(x)) for x over (-4.0, 3.0)"
|
|
|
|
d = {"return": "arg"}
|
|
s = LineOver1DRangeSeries(cos(x), (x, -4, 3), **d)
|
|
assert str(s) == "cartesian line: arg(cos(x)) for x over (-4.0, 3.0)"
|
|
|
|
s = LineOver1DRangeSeries(cos(u * x), (x, -4, 3), params={u: 1})
|
|
assert str(s) == "interactive cartesian line: cos(u*x) for x over (-4.0, 3.0) and parameters (u,)"
|
|
|
|
s = LineOver1DRangeSeries(cos(u * x), (x, -u, 3*y), params={u: 1, y: 1})
|
|
assert str(s) == "interactive cartesian line: cos(u*x) for x over (-u, 3*y) and parameters (u, y)"
|
|
|
|
s = Parametric2DLineSeries(cos(x), sin(x), (x, -4, 3))
|
|
assert str(s) == "parametric cartesian line: (cos(x), sin(x)) for x over (-4.0, 3.0)"
|
|
|
|
s = Parametric2DLineSeries(cos(u * x), sin(x), (x, -4, 3), params={u: 1})
|
|
assert str(s) == "interactive parametric cartesian line: (cos(u*x), sin(x)) for x over (-4.0, 3.0) and parameters (u,)"
|
|
|
|
s = Parametric2DLineSeries(cos(u * x), sin(x), (x, -u, 3*y), params={u: 1, y:1})
|
|
assert str(s) == "interactive parametric cartesian line: (cos(u*x), sin(x)) for x over (-u, 3*y) and parameters (u, y)"
|
|
|
|
s = Parametric3DLineSeries(cos(x), sin(x), x, (x, -4, 3))
|
|
assert str(s) == "3D parametric cartesian line: (cos(x), sin(x), x) for x over (-4.0, 3.0)"
|
|
|
|
s = Parametric3DLineSeries(cos(u*x), sin(x), x, (x, -4, 3), params={u: 1})
|
|
assert str(s) == "interactive 3D parametric cartesian line: (cos(u*x), sin(x), x) for x over (-4.0, 3.0) and parameters (u,)"
|
|
|
|
s = Parametric3DLineSeries(cos(u*x), sin(x), x, (x, -u, 3*y), params={u: 1, y: 1})
|
|
assert str(s) == "interactive 3D parametric cartesian line: (cos(u*x), sin(x), x) for x over (-u, 3*y) and parameters (u, y)"
|
|
|
|
s = SurfaceOver2DRangeSeries(cos(x * y), (x, -4, 3), (y, -2, 5))
|
|
assert str(s) == "cartesian surface: cos(x*y) for x over (-4.0, 3.0) and y over (-2.0, 5.0)"
|
|
|
|
s = SurfaceOver2DRangeSeries(cos(u * x * y), (x, -4, 3), (y, -2, 5), params={u: 1})
|
|
assert str(s) == "interactive cartesian surface: cos(u*x*y) for x over (-4.0, 3.0) and y over (-2.0, 5.0) and parameters (u,)"
|
|
|
|
s = SurfaceOver2DRangeSeries(cos(u * x * y), (x, -4*u, 3), (y, -2, 5*u), params={u: 1})
|
|
assert str(s) == "interactive cartesian surface: cos(u*x*y) for x over (-4*u, 3.0) and y over (-2.0, 5*u) and parameters (u,)"
|
|
|
|
s = ContourSeries(cos(x * y), (x, -4, 3), (y, -2, 5))
|
|
assert str(s) == "contour: cos(x*y) for x over (-4.0, 3.0) and y over (-2.0, 5.0)"
|
|
|
|
s = ContourSeries(cos(u * x * y), (x, -4, 3), (y, -2, 5), params={u: 1})
|
|
assert str(s) == "interactive contour: cos(u*x*y) for x over (-4.0, 3.0) and y over (-2.0, 5.0) and parameters (u,)"
|
|
|
|
s = ParametricSurfaceSeries(cos(x * y), sin(x * y), x * y,
|
|
(x, -4, 3), (y, -2, 5))
|
|
assert str(s) == "parametric cartesian surface: (cos(x*y), sin(x*y), x*y) for x over (-4.0, 3.0) and y over (-2.0, 5.0)"
|
|
|
|
s = ParametricSurfaceSeries(cos(u * x * y), sin(x * y), x * y,
|
|
(x, -4, 3), (y, -2, 5), params={u: 1})
|
|
assert str(s) == "interactive parametric cartesian surface: (cos(u*x*y), sin(x*y), x*y) for x over (-4.0, 3.0) and y over (-2.0, 5.0) and parameters (u,)"
|
|
|
|
s = ImplicitSeries(x < y, (x, -5, 4), (y, -3, 2))
|
|
assert str(s) == "Implicit expression: x < y for x over (-5.0, 4.0) and y over (-3.0, 2.0)"
|
|
|
|
|
|
def test_use_cm():
|
|
# verify that the `use_cm` attribute is implemented.
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
u, x, y, z = symbols("u, x:z")
|
|
|
|
s = List2DSeries([1, 2, 3, 4], [5, 6, 7, 8], use_cm=True)
|
|
assert s.use_cm
|
|
s = List2DSeries([1, 2, 3, 4], [5, 6, 7, 8], use_cm=False)
|
|
assert not s.use_cm
|
|
|
|
s = Parametric2DLineSeries(cos(x), sin(x), (x, -4, 3), use_cm=True)
|
|
assert s.use_cm
|
|
s = Parametric2DLineSeries(cos(x), sin(x), (x, -4, 3), use_cm=False)
|
|
assert not s.use_cm
|
|
|
|
s = Parametric3DLineSeries(cos(x), sin(x), x, (x, -4, 3),
|
|
use_cm=True)
|
|
assert s.use_cm
|
|
s = Parametric3DLineSeries(cos(x), sin(x), x, (x, -4, 3),
|
|
use_cm=False)
|
|
assert not s.use_cm
|
|
|
|
s = SurfaceOver2DRangeSeries(cos(x * y), (x, -4, 3), (y, -2, 5),
|
|
use_cm=True)
|
|
assert s.use_cm
|
|
s = SurfaceOver2DRangeSeries(cos(x * y), (x, -4, 3), (y, -2, 5),
|
|
use_cm=False)
|
|
assert not s.use_cm
|
|
|
|
s = ParametricSurfaceSeries(cos(x * y), sin(x * y), x * y,
|
|
(x, -4, 3), (y, -2, 5), use_cm=True)
|
|
assert s.use_cm
|
|
s = ParametricSurfaceSeries(cos(x * y), sin(x * y), x * y,
|
|
(x, -4, 3), (y, -2, 5), use_cm=False)
|
|
assert not s.use_cm
|
|
|
|
|
|
def test_surface_use_cm():
|
|
# verify that SurfaceOver2DRangeSeries and ParametricSurfaceSeries get
|
|
# the same value for use_cm
|
|
|
|
x, y, u, v = symbols("x, y, u, v")
|
|
|
|
# they read the same value from default settings
|
|
s1 = SurfaceOver2DRangeSeries(cos(x**2 + y**2), (x, -2, 2), (y, -2, 2))
|
|
s2 = ParametricSurfaceSeries(u * cos(v), u * sin(v), u,
|
|
(u, 0, 1), (v, 0 , 2*pi))
|
|
assert s1.use_cm == s2.use_cm
|
|
|
|
# they get the same value
|
|
s1 = SurfaceOver2DRangeSeries(cos(x**2 + y**2), (x, -2, 2), (y, -2, 2),
|
|
use_cm=False)
|
|
s2 = ParametricSurfaceSeries(u * cos(v), u * sin(v), u,
|
|
(u, 0, 1), (v, 0 , 2*pi), use_cm=False)
|
|
assert s1.use_cm == s2.use_cm
|
|
|
|
# they get the same value
|
|
s1 = SurfaceOver2DRangeSeries(cos(x**2 + y**2), (x, -2, 2), (y, -2, 2),
|
|
use_cm=True)
|
|
s2 = ParametricSurfaceSeries(u * cos(v), u * sin(v), u,
|
|
(u, 0, 1), (v, 0 , 2*pi), use_cm=True)
|
|
assert s1.use_cm == s2.use_cm
|
|
|
|
|
|
def test_sums():
|
|
# test that data series are able to deal with sums
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, y, u = symbols("x, y, u")
|
|
|
|
def do_test(data1, data2):
|
|
assert len(data1) == len(data2)
|
|
for d1, d2 in zip(data1, data2):
|
|
assert np.allclose(d1, d2)
|
|
|
|
s = LineOver1DRangeSeries(Sum(1 / x ** y, (x, 1, 1000)), (y, 2, 10),
|
|
adaptive=False, only_integers=True)
|
|
xx, yy = s.get_data()
|
|
|
|
s1 = LineOver1DRangeSeries(Sum(1 / x, (x, 1, y)), (y, 2, 10),
|
|
adaptive=False, only_integers=True)
|
|
xx1, yy1 = s1.get_data()
|
|
|
|
s2 = LineOver1DRangeSeries(Sum(u / x, (x, 1, y)), (y, 2, 10),
|
|
params={u: 1}, only_integers=True)
|
|
xx2, yy2 = s2.get_data()
|
|
xx1 = xx1.astype(float)
|
|
xx2 = xx2.astype(float)
|
|
do_test([xx1, yy1], [xx2, yy2])
|
|
|
|
s = LineOver1DRangeSeries(Sum(1 / x, (x, 1, y)), (y, 2, 10),
|
|
adaptive=True)
|
|
with warns(
|
|
UserWarning,
|
|
match="The evaluation with NumPy/SciPy failed",
|
|
test_stacklevel=False,
|
|
):
|
|
raises(TypeError, lambda: s.get_data())
|
|
|
|
|
|
def test_apply_transforms():
|
|
# verify that transformation functions get applied to the output
|
|
# of data series
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, y, z, u, v = symbols("x:z, u, v")
|
|
|
|
s1 = LineOver1DRangeSeries(cos(x), (x, -2*pi, 2*pi), adaptive=False, n=10)
|
|
s2 = LineOver1DRangeSeries(cos(x), (x, -2*pi, 2*pi), adaptive=False, n=10,
|
|
tx=np.rad2deg)
|
|
s3 = LineOver1DRangeSeries(cos(x), (x, -2*pi, 2*pi), adaptive=False, n=10,
|
|
ty=np.rad2deg)
|
|
s4 = LineOver1DRangeSeries(cos(x), (x, -2*pi, 2*pi), adaptive=False, n=10,
|
|
tx=np.rad2deg, ty=np.rad2deg)
|
|
|
|
x1, y1 = s1.get_data()
|
|
x2, y2 = s2.get_data()
|
|
x3, y3 = s3.get_data()
|
|
x4, y4 = s4.get_data()
|
|
assert np.isclose(x1[0], -2*np.pi) and np.isclose(x1[-1], 2*np.pi)
|
|
assert (y1.min() < -0.9) and (y1.max() > 0.9)
|
|
assert np.isclose(x2[0], -360) and np.isclose(x2[-1], 360)
|
|
assert (y2.min() < -0.9) and (y2.max() > 0.9)
|
|
assert np.isclose(x3[0], -2*np.pi) and np.isclose(x3[-1], 2*np.pi)
|
|
assert (y3.min() < -52) and (y3.max() > 52)
|
|
assert np.isclose(x4[0], -360) and np.isclose(x4[-1], 360)
|
|
assert (y4.min() < -52) and (y4.max() > 52)
|
|
|
|
xx = np.linspace(-2*np.pi, 2*np.pi, 10)
|
|
yy = np.cos(xx)
|
|
s1 = List2DSeries(xx, yy)
|
|
s2 = List2DSeries(xx, yy, tx=np.rad2deg, ty=np.rad2deg)
|
|
x1, y1 = s1.get_data()
|
|
x2, y2 = s2.get_data()
|
|
assert np.isclose(x1[0], -2*np.pi) and np.isclose(x1[-1], 2*np.pi)
|
|
assert (y1.min() < -0.9) and (y1.max() > 0.9)
|
|
assert np.isclose(x2[0], -360) and np.isclose(x2[-1], 360)
|
|
assert (y2.min() < -52) and (y2.max() > 52)
|
|
|
|
s1 = Parametric2DLineSeries(
|
|
sin(x), cos(x), (x, -pi, pi), adaptive=False, n=10)
|
|
s2 = Parametric2DLineSeries(
|
|
sin(x), cos(x), (x, -pi, pi), adaptive=False, n=10,
|
|
tx=np.rad2deg, ty=np.rad2deg, tp=np.rad2deg)
|
|
x1, y1, a1 = s1.get_data()
|
|
x2, y2, a2 = s2.get_data()
|
|
assert np.allclose(x1, np.deg2rad(x2))
|
|
assert np.allclose(y1, np.deg2rad(y2))
|
|
assert np.allclose(a1, np.deg2rad(a2))
|
|
|
|
s1 = Parametric3DLineSeries(
|
|
sin(x), cos(x), x, (x, -pi, pi), adaptive=False, n=10)
|
|
s2 = Parametric3DLineSeries(
|
|
sin(x), cos(x), x, (x, -pi, pi), adaptive=False, n=10, tp=np.rad2deg)
|
|
x1, y1, z1, a1 = s1.get_data()
|
|
x2, y2, z2, a2 = s2.get_data()
|
|
assert np.allclose(x1, x2)
|
|
assert np.allclose(y1, y2)
|
|
assert np.allclose(z1, z2)
|
|
assert np.allclose(a1, np.deg2rad(a2))
|
|
|
|
s1 = SurfaceOver2DRangeSeries(
|
|
cos(x**2 + y**2), (x, -2*pi, 2*pi), (y, -2*pi, 2*pi),
|
|
adaptive=False, n1=10, n2=10)
|
|
s2 = SurfaceOver2DRangeSeries(
|
|
cos(x**2 + y**2), (x, -2*pi, 2*pi), (y, -2*pi, 2*pi),
|
|
adaptive=False, n1=10, n2=10,
|
|
tx=np.rad2deg, ty=lambda x: 2*x, tz=lambda x: 3*x)
|
|
x1, y1, z1 = s1.get_data()
|
|
x2, y2, z2 = s2.get_data()
|
|
assert np.allclose(x1, np.deg2rad(x2))
|
|
assert np.allclose(y1, y2 / 2)
|
|
assert np.allclose(z1, z2 / 3)
|
|
|
|
s1 = ParametricSurfaceSeries(
|
|
u + v, u - v, u * v, (u, 0, 2*pi), (v, 0, pi),
|
|
adaptive=False, n1=10, n2=10)
|
|
s2 = ParametricSurfaceSeries(
|
|
u + v, u - v, u * v, (u, 0, 2*pi), (v, 0, pi),
|
|
adaptive=False, n1=10, n2=10,
|
|
tx=np.rad2deg, ty=lambda x: 2*x, tz=lambda x: 3*x)
|
|
x1, y1, z1, u1, v1 = s1.get_data()
|
|
x2, y2, z2, u2, v2 = s2.get_data()
|
|
assert np.allclose(x1, np.deg2rad(x2))
|
|
assert np.allclose(y1, y2 / 2)
|
|
assert np.allclose(z1, z2 / 3)
|
|
assert np.allclose(u1, u2)
|
|
assert np.allclose(v1, v2)
|
|
|
|
|
|
def test_series_labels():
|
|
# verify that series return the correct label, depending on the plot
|
|
# type and input arguments. If the user set custom label on a data series,
|
|
# it should returned un-modified.
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, y, z, u, v = symbols("x, y, z, u, v")
|
|
wrapper = "$%s$"
|
|
|
|
expr = cos(x)
|
|
s1 = LineOver1DRangeSeries(expr, (x, -2, 2), None)
|
|
s2 = LineOver1DRangeSeries(expr, (x, -2, 2), "test")
|
|
assert s1.get_label(False) == str(expr)
|
|
assert s1.get_label(True) == wrapper % latex(expr)
|
|
assert s2.get_label(False) == "test"
|
|
assert s2.get_label(True) == "test"
|
|
|
|
s1 = List2DSeries([0, 1, 2, 3], [0, 1, 2, 3], "test")
|
|
assert s1.get_label(False) == "test"
|
|
assert s1.get_label(True) == "test"
|
|
|
|
expr = (cos(x), sin(x))
|
|
s1 = Parametric2DLineSeries(*expr, (x, -2, 2), None, use_cm=True)
|
|
s2 = Parametric2DLineSeries(*expr, (x, -2, 2), "test", use_cm=True)
|
|
s3 = Parametric2DLineSeries(*expr, (x, -2, 2), None, use_cm=False)
|
|
s4 = Parametric2DLineSeries(*expr, (x, -2, 2), "test", use_cm=False)
|
|
assert s1.get_label(False) == "x"
|
|
assert s1.get_label(True) == wrapper % "x"
|
|
assert s2.get_label(False) == "test"
|
|
assert s2.get_label(True) == "test"
|
|
assert s3.get_label(False) == str(expr)
|
|
assert s3.get_label(True) == wrapper % latex(expr)
|
|
assert s4.get_label(False) == "test"
|
|
assert s4.get_label(True) == "test"
|
|
|
|
expr = (cos(x), sin(x), x)
|
|
s1 = Parametric3DLineSeries(*expr, (x, -2, 2), None, use_cm=True)
|
|
s2 = Parametric3DLineSeries(*expr, (x, -2, 2), "test", use_cm=True)
|
|
s3 = Parametric3DLineSeries(*expr, (x, -2, 2), None, use_cm=False)
|
|
s4 = Parametric3DLineSeries(*expr, (x, -2, 2), "test", use_cm=False)
|
|
assert s1.get_label(False) == "x"
|
|
assert s1.get_label(True) == wrapper % "x"
|
|
assert s2.get_label(False) == "test"
|
|
assert s2.get_label(True) == "test"
|
|
assert s3.get_label(False) == str(expr)
|
|
assert s3.get_label(True) == wrapper % latex(expr)
|
|
assert s4.get_label(False) == "test"
|
|
assert s4.get_label(True) == "test"
|
|
|
|
expr = cos(x**2 + y**2)
|
|
s1 = SurfaceOver2DRangeSeries(expr, (x, -2, 2), (y, -2, 2), None)
|
|
s2 = SurfaceOver2DRangeSeries(expr, (x, -2, 2), (y, -2, 2), "test")
|
|
assert s1.get_label(False) == str(expr)
|
|
assert s1.get_label(True) == wrapper % latex(expr)
|
|
assert s2.get_label(False) == "test"
|
|
assert s2.get_label(True) == "test"
|
|
|
|
expr = (cos(x - y), sin(x + y), x - y)
|
|
s1 = ParametricSurfaceSeries(*expr, (x, -2, 2), (y, -2, 2), None)
|
|
s2 = ParametricSurfaceSeries(*expr, (x, -2, 2), (y, -2, 2), "test")
|
|
assert s1.get_label(False) == str(expr)
|
|
assert s1.get_label(True) == wrapper % latex(expr)
|
|
assert s2.get_label(False) == "test"
|
|
assert s2.get_label(True) == "test"
|
|
|
|
expr = Eq(cos(x - y), 0)
|
|
s1 = ImplicitSeries(expr, (x, -10, 10), (y, -10, 10), None)
|
|
s2 = ImplicitSeries(expr, (x, -10, 10), (y, -10, 10), "test")
|
|
assert s1.get_label(False) == str(expr)
|
|
assert s1.get_label(True) == wrapper % latex(expr)
|
|
assert s2.get_label(False) == "test"
|
|
assert s2.get_label(True) == "test"
|
|
|
|
|
|
def test_is_polar_2d_parametric():
|
|
# verify that Parametric2DLineSeries isable to apply polar discretization,
|
|
# which is used when polar_plot is executed with polar_axis=True
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
t, u = symbols("t u")
|
|
|
|
# NOTE: a sufficiently big n must be provided, or else tests
|
|
# are going to fail
|
|
# No colormap
|
|
f = sin(4 * t)
|
|
s1 = Parametric2DLineSeries(f * cos(t), f * sin(t), (t, 0, 2*pi),
|
|
adaptive=False, n=10, is_polar=False, use_cm=False)
|
|
x1, y1, p1 = s1.get_data()
|
|
s2 = Parametric2DLineSeries(f * cos(t), f * sin(t), (t, 0, 2*pi),
|
|
adaptive=False, n=10, is_polar=True, use_cm=False)
|
|
th, r, p2 = s2.get_data()
|
|
assert (not np.allclose(x1, th)) and (not np.allclose(y1, r))
|
|
assert np.allclose(p1, p2)
|
|
|
|
# With colormap
|
|
s3 = Parametric2DLineSeries(f * cos(t), f * sin(t), (t, 0, 2*pi),
|
|
adaptive=False, n=10, is_polar=False, color_func=lambda t: 2*t)
|
|
x3, y3, p3 = s3.get_data()
|
|
s4 = Parametric2DLineSeries(f * cos(t), f * sin(t), (t, 0, 2*pi),
|
|
adaptive=False, n=10, is_polar=True, color_func=lambda t: 2*t)
|
|
th4, r4, p4 = s4.get_data()
|
|
assert np.allclose(p3, p4) and (not np.allclose(p1, p3))
|
|
assert np.allclose(x3, x1) and np.allclose(y3, y1)
|
|
assert np.allclose(th4, th) and np.allclose(r4, r)
|
|
|
|
|
|
def test_is_polar_3d():
|
|
# verify that SurfaceOver2DRangeSeries is able to apply
|
|
# polar discretization
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, y, t = symbols("x, y, t")
|
|
expr = (x**2 - 1)**2
|
|
s1 = SurfaceOver2DRangeSeries(expr, (x, 0, 1.5), (y, 0, 2 * pi),
|
|
n=10, adaptive=False, is_polar=False)
|
|
s2 = SurfaceOver2DRangeSeries(expr, (x, 0, 1.5), (y, 0, 2 * pi),
|
|
n=10, adaptive=False, is_polar=True)
|
|
x1, y1, z1 = s1.get_data()
|
|
x2, y2, z2 = s2.get_data()
|
|
x22, y22 = x1 * np.cos(y1), x1 * np.sin(y1)
|
|
assert np.allclose(x2, x22)
|
|
assert np.allclose(y2, y22)
|
|
|
|
|
|
def test_color_func():
|
|
# verify that eval_color_func produces the expected results in order to
|
|
# maintain back compatibility with the old sympy.plotting module
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, y, z, u, v = symbols("x, y, z, u, v")
|
|
|
|
# color func: returns x, y, color and s is parametric
|
|
xx = np.linspace(-3, 3, 10)
|
|
yy1 = np.cos(xx)
|
|
s = List2DSeries(xx, yy1, color_func=lambda x, y: 2 * x, use_cm=True)
|
|
xxs, yys, col = s.get_data()
|
|
assert np.allclose(xx, xxs)
|
|
assert np.allclose(yy1, yys)
|
|
assert np.allclose(2 * xx, col)
|
|
assert s.is_parametric
|
|
|
|
s = List2DSeries(xx, yy1, color_func=lambda x, y: 2 * x, use_cm=False)
|
|
assert len(s.get_data()) == 2
|
|
assert not s.is_parametric
|
|
|
|
s = Parametric2DLineSeries(cos(x), sin(x), (x, 0, 2*pi),
|
|
adaptive=False, n=10, color_func=lambda t: t)
|
|
xx, yy, col = s.get_data()
|
|
assert (not np.allclose(xx, col)) and (not np.allclose(yy, col))
|
|
s = Parametric2DLineSeries(cos(x), sin(x), (x, 0, 2*pi),
|
|
adaptive=False, n=10, color_func=lambda x, y: x * y)
|
|
xx, yy, col = s.get_data()
|
|
assert np.allclose(col, xx * yy)
|
|
s = Parametric2DLineSeries(cos(x), sin(x), (x, 0, 2*pi),
|
|
adaptive=False, n=10, color_func=lambda x, y, t: x * y * t)
|
|
xx, yy, col = s.get_data()
|
|
assert np.allclose(col, xx * yy * np.linspace(0, 2*np.pi, 10))
|
|
|
|
s = Parametric3DLineSeries(cos(x), sin(x), x, (x, 0, 2*pi),
|
|
adaptive=False, n=10, color_func=lambda t: t)
|
|
xx, yy, zz, col = s.get_data()
|
|
assert (not np.allclose(xx, col)) and (not np.allclose(yy, col))
|
|
s = Parametric3DLineSeries(cos(x), sin(x), x, (x, 0, 2*pi),
|
|
adaptive=False, n=10, color_func=lambda x, y, z: x * y * z)
|
|
xx, yy, zz, col = s.get_data()
|
|
assert np.allclose(col, xx * yy * zz)
|
|
s = Parametric3DLineSeries(cos(x), sin(x), x, (x, 0, 2*pi),
|
|
adaptive=False, n=10, color_func=lambda x, y, z, t: x * y * z * t)
|
|
xx, yy, zz, col = s.get_data()
|
|
assert np.allclose(col, xx * yy * zz * np.linspace(0, 2*np.pi, 10))
|
|
|
|
s = SurfaceOver2DRangeSeries(cos(x**2 + y**2), (x, -2, 2), (y, -2, 2),
|
|
adaptive=False, n1=10, n2=10, color_func=lambda x: x)
|
|
xx, yy, zz = s.get_data()
|
|
col = s.eval_color_func(xx, yy, zz)
|
|
assert np.allclose(xx, col)
|
|
s = SurfaceOver2DRangeSeries(cos(x**2 + y**2), (x, -2, 2), (y, -2, 2),
|
|
adaptive=False, n1=10, n2=10, color_func=lambda x, y: x * y)
|
|
xx, yy, zz = s.get_data()
|
|
col = s.eval_color_func(xx, yy, zz)
|
|
assert np.allclose(xx * yy, col)
|
|
s = SurfaceOver2DRangeSeries(cos(x**2 + y**2), (x, -2, 2), (y, -2, 2),
|
|
adaptive=False, n1=10, n2=10, color_func=lambda x, y, z: x * y * z)
|
|
xx, yy, zz = s.get_data()
|
|
col = s.eval_color_func(xx, yy, zz)
|
|
assert np.allclose(xx * yy * zz, col)
|
|
|
|
s = ParametricSurfaceSeries(1, x, y, (x, 0, 1), (y, 0, 1), adaptive=False,
|
|
n1=10, n2=10, color_func=lambda u:u)
|
|
xx, yy, zz, uu, vv = s.get_data()
|
|
col = s.eval_color_func(xx, yy, zz, uu, vv)
|
|
assert np.allclose(uu, col)
|
|
s = ParametricSurfaceSeries(1, x, y, (x, 0, 1), (y, 0, 1), adaptive=False,
|
|
n1=10, n2=10, color_func=lambda u, v: u * v)
|
|
xx, yy, zz, uu, vv = s.get_data()
|
|
col = s.eval_color_func(xx, yy, zz, uu, vv)
|
|
assert np.allclose(uu * vv, col)
|
|
s = ParametricSurfaceSeries(1, x, y, (x, 0, 1), (y, 0, 1), adaptive=False,
|
|
n1=10, n2=10, color_func=lambda x, y, z: x * y * z)
|
|
xx, yy, zz, uu, vv = s.get_data()
|
|
col = s.eval_color_func(xx, yy, zz, uu, vv)
|
|
assert np.allclose(xx * yy * zz, col)
|
|
s = ParametricSurfaceSeries(1, x, y, (x, 0, 1), (y, 0, 1), adaptive=False,
|
|
n1=10, n2=10, color_func=lambda x, y, z, u, v: x * y * z * u * v)
|
|
xx, yy, zz, uu, vv = s.get_data()
|
|
col = s.eval_color_func(xx, yy, zz, uu, vv)
|
|
assert np.allclose(xx * yy * zz * uu * vv, col)
|
|
|
|
# Interactive Series
|
|
s = List2DSeries([0, 1, 2, x], [x, 2, 3, 4],
|
|
color_func=lambda x, y: 2 * x, params={x: 1}, use_cm=True)
|
|
xx, yy, col = s.get_data()
|
|
assert np.allclose(xx, [0, 1, 2, 1])
|
|
assert np.allclose(yy, [1, 2, 3, 4])
|
|
assert np.allclose(2 * xx, col)
|
|
assert s.is_parametric and s.use_cm
|
|
|
|
s = List2DSeries([0, 1, 2, x], [x, 2, 3, 4],
|
|
color_func=lambda x, y: 2 * x, params={x: 1}, use_cm=False)
|
|
assert len(s.get_data()) == 2
|
|
assert not s.is_parametric
|
|
|
|
|
|
def test_color_func_scalar_val():
|
|
# verify that eval_color_func returns a numpy array even when color_func
|
|
# evaluates to a scalar value
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, y = symbols("x, y")
|
|
|
|
s = Parametric2DLineSeries(cos(x), sin(x), (x, 0, 2*pi),
|
|
adaptive=False, n=10, color_func=lambda t: 1)
|
|
xx, yy, col = s.get_data()
|
|
assert np.allclose(col, np.ones(xx.shape))
|
|
|
|
s = Parametric3DLineSeries(cos(x), sin(x), x, (x, 0, 2*pi),
|
|
adaptive=False, n=10, color_func=lambda t: 1)
|
|
xx, yy, zz, col = s.get_data()
|
|
assert np.allclose(col, np.ones(xx.shape))
|
|
|
|
s = SurfaceOver2DRangeSeries(cos(x**2 + y**2), (x, -2, 2), (y, -2, 2),
|
|
adaptive=False, n1=10, n2=10, color_func=lambda x: 1)
|
|
xx, yy, zz = s.get_data()
|
|
assert np.allclose(s.eval_color_func(xx), np.ones(xx.shape))
|
|
|
|
s = ParametricSurfaceSeries(1, x, y, (x, 0, 1), (y, 0, 1), adaptive=False,
|
|
n1=10, n2=10, color_func=lambda u: 1)
|
|
xx, yy, zz, uu, vv = s.get_data()
|
|
col = s.eval_color_func(xx, yy, zz, uu, vv)
|
|
assert np.allclose(col, np.ones(xx.shape))
|
|
|
|
|
|
def test_color_func_expression():
|
|
# verify that color_func is able to deal with instances of Expr: they will
|
|
# be lambdified with the same signature used for the main expression.
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, y = symbols("x, y")
|
|
|
|
s1 = Parametric2DLineSeries(cos(x), sin(x), (x, 0, 2*pi),
|
|
color_func=sin(x), adaptive=False, n=10, use_cm=True)
|
|
s2 = Parametric2DLineSeries(cos(x), sin(x), (x, 0, 2*pi),
|
|
color_func=lambda x: np.cos(x), adaptive=False, n=10, use_cm=True)
|
|
# the following statement should not raise errors
|
|
d1 = s1.get_data()
|
|
assert callable(s1.color_func)
|
|
d2 = s2.get_data()
|
|
assert not np.allclose(d1[-1], d2[-1])
|
|
|
|
s = SurfaceOver2DRangeSeries(cos(x**2 + y**2), (x, -pi, pi), (y, -pi, pi),
|
|
color_func=sin(x**2 + y**2), adaptive=False, n1=5, n2=5)
|
|
# the following statement should not raise errors
|
|
s.get_data()
|
|
assert callable(s.color_func)
|
|
|
|
xx = [1, 2, 3, 4, 5]
|
|
yy = [1, 2, 3, 4, 5]
|
|
raises(TypeError,
|
|
lambda : List2DSeries(xx, yy, use_cm=True, color_func=sin(x)))
|
|
|
|
|
|
def test_line_surface_color():
|
|
# verify the back-compatibility with the old sympy.plotting module.
|
|
# By setting line_color or surface_color to be a callable, it will set
|
|
# the color_func attribute.
|
|
|
|
x, y, z = symbols("x, y, z")
|
|
|
|
s = LineOver1DRangeSeries(sin(x), (x, -5, 5), adaptive=False, n=10,
|
|
line_color=lambda x: x)
|
|
assert (s.line_color is None) and callable(s.color_func)
|
|
|
|
s = Parametric2DLineSeries(cos(x), sin(x), (x, 0, 2*pi),
|
|
adaptive=False, n=10, line_color=lambda t: t)
|
|
assert (s.line_color is None) and callable(s.color_func)
|
|
|
|
s = SurfaceOver2DRangeSeries(cos(x**2 + y**2), (x, -2, 2), (y, -2, 2),
|
|
n1=10, n2=10, surface_color=lambda x: x)
|
|
assert (s.surface_color is None) and callable(s.color_func)
|
|
|
|
|
|
def test_complex_adaptive_false():
|
|
# verify that series with adaptive=False is evaluated with discretized
|
|
# ranges of type complex.
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, y, u = symbols("x y u")
|
|
|
|
def do_test(data1, data2):
|
|
assert len(data1) == len(data2)
|
|
for d1, d2 in zip(data1, data2):
|
|
assert np.allclose(d1, d2)
|
|
|
|
expr1 = sqrt(x) * exp(-x**2)
|
|
expr2 = sqrt(u * x) * exp(-x**2)
|
|
s1 = LineOver1DRangeSeries(im(expr1), (x, -5, 5), adaptive=False, n=10)
|
|
s2 = LineOver1DRangeSeries(im(expr2), (x, -5, 5),
|
|
adaptive=False, n=10, params={u: 1})
|
|
data1 = s1.get_data()
|
|
data2 = s2.get_data()
|
|
|
|
do_test(data1, data2)
|
|
assert (not np.allclose(data1[1], 0)) and (not np.allclose(data2[1], 0))
|
|
|
|
s1 = Parametric2DLineSeries(re(expr1), im(expr1), (x, -pi, pi),
|
|
adaptive=False, n=10)
|
|
s2 = Parametric2DLineSeries(re(expr2), im(expr2), (x, -pi, pi),
|
|
adaptive=False, n=10, params={u: 1})
|
|
data1 = s1.get_data()
|
|
data2 = s2.get_data()
|
|
do_test(data1, data2)
|
|
assert (not np.allclose(data1[1], 0)) and (not np.allclose(data2[1], 0))
|
|
|
|
s1 = SurfaceOver2DRangeSeries(im(expr1), (x, -5, 5), (y, -10, 10),
|
|
adaptive=False, n1=30, n2=3)
|
|
s2 = SurfaceOver2DRangeSeries(im(expr2), (x, -5, 5), (y, -10, 10),
|
|
adaptive=False, n1=30, n2=3, params={u: 1})
|
|
data1 = s1.get_data()
|
|
data2 = s2.get_data()
|
|
do_test(data1, data2)
|
|
assert (not np.allclose(data1[1], 0)) and (not np.allclose(data2[1], 0))
|
|
|
|
|
|
def test_expr_is_lambda_function():
|
|
# verify that when a numpy function is provided, the series will be able
|
|
# to evaluate it. Also, label should be empty in order to prevent some
|
|
# backend from crashing.
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
f = lambda x: np.cos(x)
|
|
s1 = LineOver1DRangeSeries(f, ("x", -5, 5), adaptive=True, depth=3)
|
|
s1.get_data()
|
|
s2 = LineOver1DRangeSeries(f, ("x", -5, 5), adaptive=False, n=10)
|
|
s2.get_data()
|
|
assert s1.label == s2.label == ""
|
|
|
|
fx = lambda x: np.cos(x)
|
|
fy = lambda x: np.sin(x)
|
|
s1 = Parametric2DLineSeries(fx, fy, ("x", 0, 2*pi),
|
|
adaptive=True, adaptive_goal=0.1)
|
|
s1.get_data()
|
|
s2 = Parametric2DLineSeries(fx, fy, ("x", 0, 2*pi),
|
|
adaptive=False, n=10)
|
|
s2.get_data()
|
|
assert s1.label == s2.label == ""
|
|
|
|
fz = lambda x: x
|
|
s1 = Parametric3DLineSeries(fx, fy, fz, ("x", 0, 2*pi),
|
|
adaptive=True, adaptive_goal=0.1)
|
|
s1.get_data()
|
|
s2 = Parametric3DLineSeries(fx, fy, fz, ("x", 0, 2*pi),
|
|
adaptive=False, n=10)
|
|
s2.get_data()
|
|
assert s1.label == s2.label == ""
|
|
|
|
f = lambda x, y: np.cos(x**2 + y**2)
|
|
s1 = SurfaceOver2DRangeSeries(f, ("a", -2, 2), ("b", -3, 3),
|
|
adaptive=False, n1=10, n2=10)
|
|
s1.get_data()
|
|
s2 = ContourSeries(f, ("a", -2, 2), ("b", -3, 3),
|
|
adaptive=False, n1=10, n2=10)
|
|
s2.get_data()
|
|
assert s1.label == s2.label == ""
|
|
|
|
fx = lambda u, v: np.cos(u + v)
|
|
fy = lambda u, v: np.sin(u - v)
|
|
fz = lambda u, v: u * v
|
|
s1 = ParametricSurfaceSeries(fx, fy, fz, ("u", 0, pi), ("v", 0, 2*pi),
|
|
adaptive=False, n1=10, n2=10)
|
|
s1.get_data()
|
|
assert s1.label == ""
|
|
|
|
raises(TypeError, lambda: List2DSeries(lambda t: t, lambda t: t))
|
|
raises(TypeError, lambda : ImplicitSeries(lambda t: np.sin(t),
|
|
("x", -5, 5), ("y", -6, 6)))
|
|
|
|
|
|
def test_show_in_legend_lines():
|
|
# verify that lines series correctly set the show_in_legend attribute
|
|
x, u = symbols("x, u")
|
|
|
|
s = LineOver1DRangeSeries(cos(x), (x, -2, 2), "test", show_in_legend=True)
|
|
assert s.show_in_legend
|
|
s = LineOver1DRangeSeries(cos(x), (x, -2, 2), "test", show_in_legend=False)
|
|
assert not s.show_in_legend
|
|
|
|
s = Parametric2DLineSeries(cos(x), sin(x), (x, 0, 1), "test",
|
|
show_in_legend=True)
|
|
assert s.show_in_legend
|
|
s = Parametric2DLineSeries(cos(x), sin(x), (x, 0, 1), "test",
|
|
show_in_legend=False)
|
|
assert not s.show_in_legend
|
|
|
|
s = Parametric3DLineSeries(cos(x), sin(x), x, (x, 0, 1), "test",
|
|
show_in_legend=True)
|
|
assert s.show_in_legend
|
|
s = Parametric3DLineSeries(cos(x), sin(x), x, (x, 0, 1), "test",
|
|
show_in_legend=False)
|
|
assert not s.show_in_legend
|
|
|
|
|
|
@XFAIL
|
|
def test_particular_case_1_with_adaptive_true():
|
|
# Verify that symbolic expressions and numerical lambda functions are
|
|
# evaluated with the same algorithm.
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
# NOTE: xfail because sympy's adaptive algorithm is not deterministic
|
|
|
|
def do_test(a, b):
|
|
with warns(
|
|
RuntimeWarning,
|
|
match="invalid value encountered in scalar power",
|
|
test_stacklevel=False,
|
|
):
|
|
d1 = a.get_data()
|
|
d2 = b.get_data()
|
|
for t, v in zip(d1, d2):
|
|
assert np.allclose(t, v)
|
|
|
|
n = symbols("n")
|
|
a = S(2) / 3
|
|
epsilon = 0.01
|
|
xn = (n**3 + n**2)**(S(1)/3) - (n**3 - n**2)**(S(1)/3)
|
|
expr = Abs(xn - a) - epsilon
|
|
math_func = lambdify([n], expr)
|
|
s1 = LineOver1DRangeSeries(expr, (n, -10, 10), "",
|
|
adaptive=True, depth=3)
|
|
s2 = LineOver1DRangeSeries(math_func, ("n", -10, 10), "",
|
|
adaptive=True, depth=3)
|
|
do_test(s1, s2)
|
|
|
|
|
|
def test_particular_case_1_with_adaptive_false():
|
|
# Verify that symbolic expressions and numerical lambda functions are
|
|
# evaluated with the same algorithm. In particular, uniform evaluation
|
|
# is going to use np.vectorize, which correctly evaluates the following
|
|
# mathematical function.
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
def do_test(a, b):
|
|
d1 = a.get_data()
|
|
d2 = b.get_data()
|
|
for t, v in zip(d1, d2):
|
|
assert np.allclose(t, v)
|
|
|
|
n = symbols("n")
|
|
a = S(2) / 3
|
|
epsilon = 0.01
|
|
xn = (n**3 + n**2)**(S(1)/3) - (n**3 - n**2)**(S(1)/3)
|
|
expr = Abs(xn - a) - epsilon
|
|
math_func = lambdify([n], expr)
|
|
|
|
s3 = LineOver1DRangeSeries(expr, (n, -10, 10), "",
|
|
adaptive=False, n=10)
|
|
s4 = LineOver1DRangeSeries(math_func, ("n", -10, 10), "",
|
|
adaptive=False, n=10)
|
|
do_test(s3, s4)
|
|
|
|
|
|
def test_complex_params_number_eval():
|
|
# The main expression contains terms like sqrt(xi - 1), with
|
|
# parameter (0 <= xi <= 1).
|
|
# There shouldn't be any NaN values on the output.
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
xi, wn, x0, v0, t = symbols("xi, omega_n, x0, v0, t")
|
|
x = Function("x")(t)
|
|
eq = x.diff(t, 2) + 2 * xi * wn * x.diff(t) + wn**2 * x
|
|
sol = dsolve(eq, x, ics={x.subs(t, 0): x0, x.diff(t).subs(t, 0): v0})
|
|
params = {
|
|
wn: 0.5,
|
|
xi: 0.25,
|
|
x0: 0.45,
|
|
v0: 0.0
|
|
}
|
|
s = LineOver1DRangeSeries(sol.rhs, (t, 0, 100), adaptive=False, n=5,
|
|
params=params)
|
|
x, y = s.get_data()
|
|
assert not np.isnan(x).any()
|
|
assert not np.isnan(y).any()
|
|
|
|
|
|
# Fourier Series of a sawtooth wave
|
|
# The main expression contains a Sum with a symbolic upper range.
|
|
# The lambdified code looks like:
|
|
# sum(blablabla for for n in range(1, m+1))
|
|
# But range requires integer numbers, whereas per above example, the series
|
|
# casts parameters to complex. Verify that the series is able to detect
|
|
# upper bounds in summations and cast it to int in order to get successfull
|
|
# evaluation
|
|
x, T, n, m = symbols("x, T, n, m")
|
|
fs = S(1) / 2 - (1 / pi) * Sum(sin(2 * n * pi * x / T) / n, (n, 1, m))
|
|
params = {
|
|
T: 4.5,
|
|
m: 5
|
|
}
|
|
s = LineOver1DRangeSeries(fs, (x, 0, 10), adaptive=False, n=5,
|
|
params=params)
|
|
x, y = s.get_data()
|
|
assert not np.isnan(x).any()
|
|
assert not np.isnan(y).any()
|
|
|
|
|
|
def test_complex_range_line_plot_1():
|
|
# verify that univariate functions are evaluated with a complex
|
|
# data range (with zero imaginary part). There shouln't be any
|
|
# NaN value in the output.
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, u = symbols("x, u")
|
|
expr1 = im(sqrt(x) * exp(-x**2))
|
|
expr2 = im(sqrt(u * x) * exp(-x**2))
|
|
s1 = LineOver1DRangeSeries(expr1, (x, -10, 10), adaptive=True,
|
|
adaptive_goal=0.1)
|
|
s2 = LineOver1DRangeSeries(expr1, (x, -10, 10), adaptive=False, n=30)
|
|
s3 = LineOver1DRangeSeries(expr2, (x, -10, 10), adaptive=False, n=30,
|
|
params={u: 1})
|
|
|
|
with ignore_warnings(RuntimeWarning):
|
|
data1 = s1.get_data()
|
|
data2 = s2.get_data()
|
|
data3 = s3.get_data()
|
|
|
|
assert not np.isnan(data1[1]).any()
|
|
assert not np.isnan(data2[1]).any()
|
|
assert not np.isnan(data3[1]).any()
|
|
assert np.allclose(data2[0], data3[0]) and np.allclose(data2[1], data3[1])
|
|
|
|
|
|
@XFAIL
|
|
def test_complex_range_line_plot_2():
|
|
# verify that univariate functions are evaluated with a complex
|
|
# data range (with non-zero imaginary part). There shouln't be any
|
|
# NaN value in the output.
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
# NOTE: xfail because sympy's adaptive algorithm is unable to deal with
|
|
# complex number.
|
|
|
|
x, u = symbols("x, u")
|
|
|
|
# adaptive and uniform meshing should produce the same data.
|
|
# because of the adaptive nature, just compare the first and last points
|
|
# of both series.
|
|
s1 = LineOver1DRangeSeries(abs(sqrt(x)), (x, -5-2j, 5-2j), adaptive=True)
|
|
s2 = LineOver1DRangeSeries(abs(sqrt(x)), (x, -5-2j, 5-2j), adaptive=False,
|
|
n=10)
|
|
with warns(
|
|
RuntimeWarning,
|
|
match="invalid value encountered in sqrt",
|
|
test_stacklevel=False,
|
|
):
|
|
d1 = s1.get_data()
|
|
d2 = s2.get_data()
|
|
xx1 = [d1[0][0], d1[0][-1]]
|
|
xx2 = [d2[0][0], d2[0][-1]]
|
|
yy1 = [d1[1][0], d1[1][-1]]
|
|
yy2 = [d2[1][0], d2[1][-1]]
|
|
assert np.allclose(xx1, xx2)
|
|
assert np.allclose(yy1, yy2)
|
|
|
|
|
|
def test_force_real_eval():
|
|
# verify that force_real_eval=True produces inconsistent results when
|
|
# compared with evaluation of complex domain.
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x = symbols("x")
|
|
|
|
expr = im(sqrt(x) * exp(-x**2))
|
|
s1 = LineOver1DRangeSeries(expr, (x, -10, 10), adaptive=False, n=10,
|
|
force_real_eval=False)
|
|
s2 = LineOver1DRangeSeries(expr, (x, -10, 10), adaptive=False, n=10,
|
|
force_real_eval=True)
|
|
d1 = s1.get_data()
|
|
with ignore_warnings(RuntimeWarning):
|
|
d2 = s2.get_data()
|
|
assert not np.allclose(d1[1], 0)
|
|
assert np.allclose(d2[1], 0)
|
|
|
|
|
|
def test_contour_series_show_clabels():
|
|
# verify that a contour series has the abiliy to set the visibility of
|
|
# labels to contour lines
|
|
|
|
x, y = symbols("x, y")
|
|
s = ContourSeries(cos(x*y), (x, -2, 2), (y, -2, 2))
|
|
assert s.show_clabels
|
|
|
|
s = ContourSeries(cos(x*y), (x, -2, 2), (y, -2, 2), clabels=True)
|
|
assert s.show_clabels
|
|
|
|
s = ContourSeries(cos(x*y), (x, -2, 2), (y, -2, 2), clabels=False)
|
|
assert not s.show_clabels
|
|
|
|
|
|
def test_LineOver1DRangeSeries_complex_range():
|
|
# verify that LineOver1DRangeSeries can accept a complex range
|
|
# if the imaginary part of the start and end values are the same
|
|
|
|
x = symbols("x")
|
|
|
|
LineOver1DRangeSeries(sqrt(x), (x, -10, 10))
|
|
LineOver1DRangeSeries(sqrt(x), (x, -10-2j, 10-2j))
|
|
raises(ValueError,
|
|
lambda : LineOver1DRangeSeries(sqrt(x), (x, -10-2j, 10+2j)))
|
|
|
|
|
|
def test_symbolic_plotting_ranges():
|
|
# verify that data series can use symbolic plotting ranges
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, y, z, a, b = symbols("x, y, z, a, b")
|
|
|
|
def do_test(s1, s2, new_params):
|
|
d1 = s1.get_data()
|
|
d2 = s2.get_data()
|
|
for u, v in zip(d1, d2):
|
|
assert np.allclose(u, v)
|
|
s2.params = new_params
|
|
d2 = s2.get_data()
|
|
for u, v in zip(d1, d2):
|
|
assert not np.allclose(u, v)
|
|
|
|
s1 = LineOver1DRangeSeries(sin(x), (x, 0, 1), adaptive=False, n=10)
|
|
s2 = LineOver1DRangeSeries(sin(x), (x, a, b), params={a: 0, b: 1},
|
|
adaptive=False, n=10)
|
|
do_test(s1, s2, {a: 0.5, b: 1.5})
|
|
|
|
# missing a parameter
|
|
raises(ValueError,
|
|
lambda : LineOver1DRangeSeries(sin(x), (x, a, b), params={a: 1}, n=10))
|
|
|
|
s1 = Parametric2DLineSeries(cos(x), sin(x), (x, 0, 1), adaptive=False, n=10)
|
|
s2 = Parametric2DLineSeries(cos(x), sin(x), (x, a, b), params={a: 0, b: 1},
|
|
adaptive=False, n=10)
|
|
do_test(s1, s2, {a: 0.5, b: 1.5})
|
|
|
|
# missing a parameter
|
|
raises(ValueError,
|
|
lambda : Parametric2DLineSeries(cos(x), sin(x), (x, a, b),
|
|
params={a: 0}, adaptive=False, n=10))
|
|
|
|
s1 = Parametric3DLineSeries(cos(x), sin(x), x, (x, 0, 1),
|
|
adaptive=False, n=10)
|
|
s2 = Parametric3DLineSeries(cos(x), sin(x), x, (x, a, b),
|
|
params={a: 0, b: 1}, adaptive=False, n=10)
|
|
do_test(s1, s2, {a: 0.5, b: 1.5})
|
|
|
|
# missing a parameter
|
|
raises(ValueError,
|
|
lambda : Parametric3DLineSeries(cos(x), sin(x), x, (x, a, b),
|
|
params={a: 0}, adaptive=False, n=10))
|
|
|
|
s1 = SurfaceOver2DRangeSeries(cos(x**2 + y**2), (x, -pi, pi), (y, -pi, pi),
|
|
adaptive=False, n1=5, n2=5)
|
|
s2 = SurfaceOver2DRangeSeries(cos(x**2 + y**2), (x, -pi * a, pi * a),
|
|
(y, -pi * b, pi * b), params={a: 1, b: 1},
|
|
adaptive=False, n1=5, n2=5)
|
|
do_test(s1, s2, {a: 0.5, b: 1.5})
|
|
|
|
# missing a parameter
|
|
raises(ValueError,
|
|
lambda : SurfaceOver2DRangeSeries(cos(x**2 + y**2),
|
|
(x, -pi * a, pi * a), (y, -pi * b, pi * b), params={a: 1},
|
|
adaptive=False, n1=5, n2=5))
|
|
# one range symbol is included into another range's minimum or maximum val
|
|
raises(ValueError,
|
|
lambda : SurfaceOver2DRangeSeries(cos(x**2 + y**2),
|
|
(x, -pi * a + y, pi * a), (y, -pi * b, pi * b), params={a: 1},
|
|
adaptive=False, n1=5, n2=5))
|
|
|
|
s1 = ParametricSurfaceSeries(
|
|
cos(x - y), sin(x + y), x - y, (x, -2, 2), (y, -2, 2), n1=5, n2=5)
|
|
s2 = ParametricSurfaceSeries(
|
|
cos(x - y), sin(x + y), x - y, (x, -2 * a, 2), (y, -2, 2 * b),
|
|
params={a: 1, b: 1}, n1=5, n2=5)
|
|
do_test(s1, s2, {a: 0.5, b: 1.5})
|
|
|
|
# missing a parameter
|
|
raises(ValueError,
|
|
lambda : ParametricSurfaceSeries(
|
|
cos(x - y), sin(x + y), x - y, (x, -2 * a, 2), (y, -2, 2 * b),
|
|
params={a: 1}, n1=5, n2=5))
|
|
|
|
|
|
def test_exclude_points():
|
|
# verify that exclude works as expected
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x = symbols("x")
|
|
|
|
expr = (floor(x) + S.Half) / (1 - (x - S.Half)**2)
|
|
|
|
with warns(
|
|
UserWarning,
|
|
match="NumPy is unable to evaluate with complex numbers some",
|
|
test_stacklevel=False,
|
|
):
|
|
s = LineOver1DRangeSeries(expr, (x, -3.5, 3.5), adaptive=False, n=100,
|
|
exclude=list(range(-3, 4)))
|
|
xx, yy = s.get_data()
|
|
assert not np.isnan(xx).any()
|
|
assert np.count_nonzero(np.isnan(yy)) == 7
|
|
assert len(xx) > 100
|
|
|
|
e1 = log(floor(x)) * cos(x)
|
|
e2 = log(floor(x)) * sin(x)
|
|
with warns(
|
|
UserWarning,
|
|
match="NumPy is unable to evaluate with complex numbers some",
|
|
test_stacklevel=False,
|
|
):
|
|
s = Parametric2DLineSeries(e1, e2, (x, 1, 12), adaptive=False, n=100,
|
|
exclude=list(range(1, 13)))
|
|
xx, yy, pp = s.get_data()
|
|
assert not np.isnan(pp).any()
|
|
assert np.count_nonzero(np.isnan(xx)) == 11
|
|
assert np.count_nonzero(np.isnan(yy)) == 11
|
|
assert len(xx) > 100
|
|
|
|
|
|
def test_unwrap():
|
|
# verify that unwrap works as expected
|
|
if not np:
|
|
skip("numpy not installed.")
|
|
|
|
x, y = symbols("x, y")
|
|
expr = 1 / (x**3 + 2*x**2 + x)
|
|
expr = arg(expr.subs(x, I*y*2*pi))
|
|
s1 = LineOver1DRangeSeries(expr, (y, 1e-05, 1e05), xscale="log",
|
|
adaptive=False, n=10, unwrap=False)
|
|
s2 = LineOver1DRangeSeries(expr, (y, 1e-05, 1e05), xscale="log",
|
|
adaptive=False, n=10, unwrap=True)
|
|
s3 = LineOver1DRangeSeries(expr, (y, 1e-05, 1e05), xscale="log",
|
|
adaptive=False, n=10, unwrap={"period": 4})
|
|
x1, y1 = s1.get_data()
|
|
x2, y2 = s2.get_data()
|
|
x3, y3 = s3.get_data()
|
|
assert np.allclose(x1, x2)
|
|
# there must not be nan values in the results of these evaluations
|
|
assert all(not np.isnan(t).any() for t in [y1, y2, y3])
|
|
assert not np.allclose(y1, y2)
|
|
assert not np.allclose(y1, y3)
|
|
assert not np.allclose(y2, y3)
|