Add files using upload-large-folder tool

.gitattributes

@@ -1634,3 +1634,7 @@ evalkit_tf437/lib/python3.10/site-packages/pyarrow/libarrow_substrait.so.1800 fi
 falcon/bin/python filter=lfs diff=lfs merge=lfs -text
 evalkit_internvl/lib/python3.10/site-packages/sympy/utilities/tests/__pycache__/test_wester.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 evalkit_internvl/lib/python3.10/site-packages/sympy/tensor/__pycache__/tensor.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+evalkit_internvl/lib/python3.10/site-packages/sympy/solvers/diophantine/__pycache__/diophantine.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+evalkit_internvl/lib/python3.10/site-packages/sympy/solvers/tests/__pycache__/test_solvers.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+evalkit_internvl/lib/python3.10/site-packages/sympy/solvers/ode/tests/__pycache__/test_systems.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+evalkit_tf437/lib/python3.10/site-packages/pydantic_core/_pydantic_core.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

evalkit_internvl/lib/python3.10/site-packages/sympy/plotting/tests/test_experimental_lambdify.py

@@ -0,0 +1,77 @@
+from sympy.core.symbol import symbols, Symbol
+from sympy.functions import Max
+from sympy.plotting.experimental_lambdify import experimental_lambdify
+from sympy.plotting.intervalmath.interval_arithmetic import \
+    interval, intervalMembership
+
+
+# Tests for exception handling in experimental_lambdify
+def test_experimental_lambify():
+    x = Symbol('x')
+    f = experimental_lambdify([x], Max(x, 5))
+    # XXX should f be tested? If f(2) is attempted, an
+    # error is raised because a complex produced during wrapping of the arg
+    # is being compared with an int.
+    assert Max(2, 5) == 5
+    assert Max(5, 7) == 7
+
+    x = Symbol('x-3')
+    f = experimental_lambdify([x], x + 1)
+    assert f(1) == 2
+
+
+def test_composite_boolean_region():
+    x, y = symbols('x y')
+
+    r1 = (x - 1)**2 + y**2 < 2
+    r2 = (x + 1)**2 + y**2 < 2
+
+    f = experimental_lambdify((x, y), r1 & r2)
+    a = (interval(-0.1, 0.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(True, True)
+    a = (interval(-1.1, -0.9), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(False, True)
+    a = (interval(0.9, 1.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(False, True)
+    a = (interval(-0.1, 0.1), interval(1.9, 2.1))
+    assert f(*a) == intervalMembership(False, True)
+
+    f = experimental_lambdify((x, y), r1 | r2)
+    a = (interval(-0.1, 0.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(True, True)
+    a = (interval(-1.1, -0.9), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(True, True)
+    a = (interval(0.9, 1.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(True, True)
+    a = (interval(-0.1, 0.1), interval(1.9, 2.1))
+    assert f(*a) == intervalMembership(False, True)
+
+    f = experimental_lambdify((x, y), r1 & ~r2)
+    a = (interval(-0.1, 0.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(False, True)
+    a = (interval(-1.1, -0.9), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(False, True)
+    a = (interval(0.9, 1.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(True, True)
+    a = (interval(-0.1, 0.1), interval(1.9, 2.1))
+    assert f(*a) == intervalMembership(False, True)
+
+    f = experimental_lambdify((x, y), ~r1 & r2)
+    a = (interval(-0.1, 0.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(False, True)
+    a = (interval(-1.1, -0.9), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(True, True)
+    a = (interval(0.9, 1.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(False, True)
+    a = (interval(-0.1, 0.1), interval(1.9, 2.1))
+    assert f(*a) == intervalMembership(False, True)
+
+    f = experimental_lambdify((x, y), ~r1 & ~r2)
+    a = (interval(-0.1, 0.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(False, True)
+    a = (interval(-1.1, -0.9), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(False, True)
+    a = (interval(0.9, 1.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(False, True)
+    a = (interval(-0.1, 0.1), interval(1.9, 2.1))
+    assert f(*a) == intervalMembership(True, True)

evalkit_internvl/lib/python3.10/site-packages/sympy/plotting/tests/test_plot.py

@@ -0,0 +1,1343 @@
+import os
+from tempfile import TemporaryDirectory
+import pytest
+from sympy.concrete.summations import Sum
+from sympy.core.numbers import (I, oo, pi)
+from sympy.core.relational import Ne
+from sympy.core.symbol import Symbol, symbols
+from sympy.functions.elementary.exponential import (LambertW, exp, exp_polar, log)
+from sympy.functions.elementary.miscellaneous import (real_root, sqrt)
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.elementary.miscellaneous import Min
+from sympy.functions.special.hyper import meijerg
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import And
+from sympy.core.singleton import S
+from sympy.core.sympify import sympify
+from sympy.external import import_module
+from sympy.plotting.plot import (
+    Plot, plot, plot_parametric, plot3d_parametric_line, plot3d,
+    plot3d_parametric_surface)
+from sympy.plotting.plot import (
+    unset_show, plot_contour, PlotGrid, MatplotlibBackend, TextBackend)
+from sympy.plotting.series import (
+    LineOver1DRangeSeries, Parametric2DLineSeries, Parametric3DLineSeries,
+    ParametricSurfaceSeries, SurfaceOver2DRangeSeries)
+from sympy.testing.pytest import skip, warns, raises, warns_deprecated_sympy
+from sympy.utilities import lambdify as lambdify_
+from sympy.utilities.exceptions import ignore_warnings
+
+unset_show()
+
+
+matplotlib = import_module(
+    'matplotlib', min_module_version='1.1.0', catch=(RuntimeError,))
+
+
+class DummyBackendNotOk(Plot):
+    """ Used to verify if users can create their own backends.
+    This backend is meant to raise NotImplementedError for methods `show`,
+    `save`, `close`.
+    """
+    def __new__(cls, *args, **kwargs):
+        return object.__new__(cls)
+
+
+class DummyBackendOk(Plot):
+    """ Used to verify if users can create their own backends.
+    This backend is meant to pass all tests.
+    """
+    def __new__(cls, *args, **kwargs):
+        return object.__new__(cls)
+
+    def show(self):
+        pass
+
+    def save(self):
+        pass
+
+    def close(self):
+        pass
+
+def test_basic_plotting_backend():
+    x = Symbol('x')
+    plot(x, (x, 0, 3), backend='text')
+    plot(x**2 + 1, (x, 0, 3), backend='text')
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_plot_and_save_1(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    y = Symbol('y')
+
+    with TemporaryDirectory(prefix='sympy_') as tmpdir:
+        ###
+        # Examples from the 'introduction' notebook
+        ###
+        p = plot(x, legend=True, label='f1', adaptive=adaptive, n=10)
+        p = plot(x*sin(x), x*cos(x), label='f2', adaptive=adaptive, n=10)
+        p.extend(p)
+        p[0].line_color = lambda a: a
+        p[1].line_color = 'b'
+        p.title = 'Big title'
+        p.xlabel = 'the x axis'
+        p[1].label = 'straight line'
+        p.legend = True
+        p.aspect_ratio = (1, 1)
+        p.xlim = (-15, 20)
+        filename = 'test_basic_options_and_colors.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p.extend(plot(x + 1, adaptive=adaptive, n=10))
+        p.append(plot(x + 3, x**2, adaptive=adaptive, n=10)[1])
+        filename = 'test_plot_extend_append.png'
+        p.save(os.path.join(tmpdir, filename))
+
+        p[2] = plot(x**2, (x, -2, 3), adaptive=adaptive, n=10)
+        filename = 'test_plot_setitem.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot(sin(x), (x, -2*pi, 4*pi), adaptive=adaptive, n=10)
+        filename = 'test_line_explicit.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot(sin(x), adaptive=adaptive, n=10)
+        filename = 'test_line_default_range.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot((x**2, (x, -5, 5)), (x**3, (x, -3, 3)), adaptive=adaptive, n=10)
+        filename = 'test_line_multiple_range.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        raises(ValueError, lambda: plot(x, y))
+
+        #Piecewise plots
+        p = plot(Piecewise((1, x > 0), (0, True)), (x, -1, 1), adaptive=adaptive, n=10)
+        filename = 'test_plot_piecewise.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot(Piecewise((x, x < 1), (x**2, True)), (x, -3, 3), adaptive=adaptive, n=10)
+        filename = 'test_plot_piecewise_2.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # test issue 7471
+        p1 = plot(x, adaptive=adaptive, n=10)
+        p2 = plot(3, adaptive=adaptive, n=10)
+        p1.extend(p2)
+        filename = 'test_horizontal_line.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # test issue 10925
+        f = Piecewise((-1, x < -1), (x, And(-1 <= x, x < 0)), \
+            (x**2, And(0 <= x, x < 1)), (x**3, x >= 1))
+        p = plot(f, (x, -3, 3), adaptive=adaptive, n=10)
+        filename = 'test_plot_piecewise_3.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_plot_and_save_2(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    y = Symbol('y')
+    z = Symbol('z')
+
+    with TemporaryDirectory(prefix='sympy_') as tmpdir:
+        #parametric 2d plots.
+        #Single plot with default range.
+        p = plot_parametric(sin(x), cos(x), adaptive=adaptive, n=10)
+        filename = 'test_parametric.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        #Single plot with range.
+        p = plot_parametric(
+            sin(x), cos(x), (x, -5, 5), legend=True, label='parametric_plot',
+            adaptive=adaptive, n=10)
+        filename = 'test_parametric_range.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        #Multiple plots with same range.
+        p = plot_parametric((sin(x), cos(x)), (x, sin(x)),
+            adaptive=adaptive, n=10)
+        filename = 'test_parametric_multiple.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        #Multiple plots with different ranges.
+        p = plot_parametric(
+            (sin(x), cos(x), (x, -3, 3)), (x, sin(x), (x, -5, 5)),
+            adaptive=adaptive, n=10)
+        filename = 'test_parametric_multiple_ranges.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        #depth of recursion specified.
+        p = plot_parametric(x, sin(x), depth=13,
+            adaptive=adaptive, n=10)
+        filename = 'test_recursion_depth.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        #No adaptive sampling.
+        p = plot_parametric(cos(x), sin(x), adaptive=False, n=500)
+        filename = 'test_adaptive.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        #3d parametric plots
+        p = plot3d_parametric_line(
+            sin(x), cos(x), x, legend=True, label='3d_parametric_plot',
+            adaptive=adaptive, n=10)
+        filename = 'test_3d_line.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot3d_parametric_line(
+            (sin(x), cos(x), x, (x, -5, 5)), (cos(x), sin(x), x, (x, -3, 3)),
+            adaptive=adaptive, n=10)
+        filename = 'test_3d_line_multiple.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot3d_parametric_line(sin(x), cos(x), x, n=30,
+            adaptive=adaptive)
+        filename = 'test_3d_line_points.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # 3d surface single plot.
+        p = plot3d(x * y, adaptive=adaptive, n=10)
+        filename = 'test_surface.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # Multiple 3D plots with same range.
+        p = plot3d(-x * y, x * y, (x, -5, 5), adaptive=adaptive, n=10)
+        filename = 'test_surface_multiple.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # Multiple 3D plots with different ranges.
+        p = plot3d(
+            (x * y, (x, -3, 3), (y, -3, 3)), (-x * y, (x, -3, 3), (y, -3, 3)),
+            adaptive=adaptive, n=10)
+        filename = 'test_surface_multiple_ranges.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # Single Parametric 3D plot
+        p = plot3d_parametric_surface(sin(x + y), cos(x - y), x - y,
+            adaptive=adaptive, n=10)
+        filename = 'test_parametric_surface.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # Multiple Parametric 3D plots.
+        p = plot3d_parametric_surface(
+            (x*sin(z), x*cos(z), z, (x, -5, 5), (z, -5, 5)),
+            (sin(x + y), cos(x - y), x - y, (x, -5, 5), (y, -5, 5)),
+            adaptive=adaptive, n=10)
+        filename = 'test_parametric_surface.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # Single Contour plot.
+        p = plot_contour(sin(x)*sin(y), (x, -5, 5), (y, -5, 5),
+            adaptive=adaptive, n=10)
+        filename = 'test_contour_plot.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # Multiple Contour plots with same range.
+        p = plot_contour(x**2 + y**2, x**3 + y**3, (x, -5, 5), (y, -5, 5),
+            adaptive=adaptive, n=10)
+        filename = 'test_contour_plot.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # Multiple Contour plots with different range.
+        p = plot_contour(
+            (x**2 + y**2, (x, -5, 5), (y, -5, 5)),
+            (x**3 + y**3, (x, -3, 3), (y, -3, 3)),
+            adaptive=adaptive, n=10)
+        filename = 'test_contour_plot.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_plot_and_save_3(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    y = Symbol('y')
+    z = Symbol('z')
+
+    with TemporaryDirectory(prefix='sympy_') as tmpdir:
+        ###
+        # Examples from the 'colors' notebook
+        ###
+
+        p = plot(sin(x), adaptive=adaptive, n=10)
+        p[0].line_color = lambda a: a
+        filename = 'test_colors_line_arity1.png'
+        p.save(os.path.join(tmpdir, filename))
+
+        p[0].line_color = lambda a, b: b
+        filename = 'test_colors_line_arity2.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot(x*sin(x), x*cos(x), (x, 0, 10), adaptive=adaptive, n=10)
+        p[0].line_color = lambda a: a
+        filename = 'test_colors_param_line_arity1.png'
+        p.save(os.path.join(tmpdir, filename))
+
+        p[0].line_color = lambda a, b: a
+        filename = 'test_colors_param_line_arity1.png'
+        p.save(os.path.join(tmpdir, filename))
+
+        p[0].line_color = lambda a, b: b
+        filename = 'test_colors_param_line_arity2b.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot3d_parametric_line(
+            sin(x) + 0.1*sin(x)*cos(7*x),
+            cos(x) + 0.1*cos(x)*cos(7*x),
+            0.1*sin(7*x),
+            (x, 0, 2*pi), adaptive=adaptive, n=10)
+        p[0].line_color = lambdify_(x, sin(4*x))
+        filename = 'test_colors_3d_line_arity1.png'
+        p.save(os.path.join(tmpdir, filename))
+        p[0].line_color = lambda a, b: b
+        filename = 'test_colors_3d_line_arity2.png'
+        p.save(os.path.join(tmpdir, filename))
+        p[0].line_color = lambda a, b, c: c
+        filename = 'test_colors_3d_line_arity3.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot3d(sin(x)*y, (x, 0, 6*pi), (y, -5, 5), adaptive=adaptive, n=10)
+        p[0].surface_color = lambda a: a
+        filename = 'test_colors_surface_arity1.png'
+        p.save(os.path.join(tmpdir, filename))
+        p[0].surface_color = lambda a, b: b
+        filename = 'test_colors_surface_arity2.png'
+        p.save(os.path.join(tmpdir, filename))
+        p[0].surface_color = lambda a, b, c: c
+        filename = 'test_colors_surface_arity3a.png'
+        p.save(os.path.join(tmpdir, filename))
+        p[0].surface_color = lambdify_((x, y, z), sqrt((x - 3*pi)**2 + y**2))
+        filename = 'test_colors_surface_arity3b.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot3d_parametric_surface(x * cos(4 * y), x * sin(4 * y), y,
+                (x, -1, 1), (y, -1, 1), adaptive=adaptive, n=10)
+        p[0].surface_color = lambda a: a
+        filename = 'test_colors_param_surf_arity1.png'
+        p.save(os.path.join(tmpdir, filename))
+        p[0].surface_color = lambda a, b: a*b
+        filename = 'test_colors_param_surf_arity2.png'
+        p.save(os.path.join(tmpdir, filename))
+        p[0].surface_color = lambdify_((x, y, z), sqrt(x**2 + y**2 + z**2))
+        filename = 'test_colors_param_surf_arity3.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+
+@pytest.mark.parametrize("adaptive", [True])
+def test_plot_and_save_4(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    y = Symbol('y')
+
+    ###
+    # Examples from the 'advanced' notebook
+    ###
+
+    with TemporaryDirectory(prefix='sympy_') as tmpdir:
+        i = Integral(log((sin(x)**2 + 1)*sqrt(x**2 + 1)), (x, 0, y))
+        p = plot(i, (y, 1, 5), adaptive=adaptive, n=10, force_real_eval=True)
+        filename = 'test_advanced_integral.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_plot_and_save_5(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    y = Symbol('y')
+
+    with TemporaryDirectory(prefix='sympy_') as tmpdir:
+        s = Sum(1/x**y, (x, 1, oo))
+        p = plot(s, (y, 2, 10), adaptive=adaptive, n=10)
+        filename = 'test_advanced_inf_sum.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot(Sum(1/x, (x, 1, y)), (y, 2, 10), show=False,
+            adaptive=adaptive, n=10)
+        p[0].only_integers = True
+        p[0].steps = True
+        filename = 'test_advanced_fin_sum.png'
+
+        # XXX: This should be fixed in experimental_lambdify or by using
+        # ordinary lambdify so that it doesn't warn. The error results from
+        # passing an array of values as the integration limit.
+        #
+        # UserWarning: The evaluation of the expression is problematic. We are
+        # trying a failback method that may still work. Please report this as a
+        # bug.
+        with ignore_warnings(UserWarning):
+            p.save(os.path.join(tmpdir, filename))
+
+        p._backend.close()
+
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_plot_and_save_6(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+
+    with TemporaryDirectory(prefix='sympy_') as tmpdir:
+        filename = 'test.png'
+        ###
+        # Test expressions that can not be translated to np and generate complex
+        # results.
+        ###
+        p = plot(sin(x) + I*cos(x))
+        p.save(os.path.join(tmpdir, filename))
+
+        with ignore_warnings(RuntimeWarning):
+            p = plot(sqrt(sqrt(-x)))
+            p.save(os.path.join(tmpdir, filename))
+
+        p = plot(LambertW(x))
+        p.save(os.path.join(tmpdir, filename))
+        p = plot(sqrt(LambertW(x)))
+        p.save(os.path.join(tmpdir, filename))
+
+        #Characteristic function of a StudentT distribution with nu=10
+        x1 = 5 * x**2 * exp_polar(-I*pi)/2
+        m1 = meijerg(((1 / 2,), ()), ((5, 0, 1 / 2), ()), x1)
+        x2 = 5*x**2 * exp_polar(I*pi)/2
+        m2 = meijerg(((1/2,), ()), ((5, 0, 1/2), ()), x2)
+        expr = (m1 + m2) / (48 * pi)
+        with warns(
+            UserWarning,
+            match="The evaluation with NumPy/SciPy failed",
+            test_stacklevel=False,
+        ):
+            p = plot(expr, (x, 1e-6, 1e-2), adaptive=adaptive, n=10)
+            p.save(os.path.join(tmpdir, filename))
+
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_plotgrid_and_save(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    y = Symbol('y')
+
+    with TemporaryDirectory(prefix='sympy_') as tmpdir:
+        p1 = plot(x, adaptive=adaptive, n=10)
+        p2 = plot_parametric((sin(x), cos(x)), (x, sin(x)), show=False,
+            adaptive=adaptive, n=10)
+        p3 = plot_parametric(
+            cos(x), sin(x), adaptive=adaptive, n=10, show=False)
+        p4 = plot3d_parametric_line(sin(x), cos(x), x, show=False,
+            adaptive=adaptive, n=10)
+        # symmetric grid
+        p = PlotGrid(2, 2, p1, p2, p3, p4)
+        filename = 'test_grid1.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # grid size greater than the number of subplots
+        p = PlotGrid(3, 4, p1, p2, p3, p4)
+        filename = 'test_grid2.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p5 = plot(cos(x),(x, -pi, pi), show=False, adaptive=adaptive, n=10)
+        p5[0].line_color = lambda a: a
+        p6 = plot(Piecewise((1, x > 0), (0, True)), (x, -1, 1), show=False,
+            adaptive=adaptive, n=10)
+        p7 = plot_contour(
+            (x**2 + y**2, (x, -5, 5), (y, -5, 5)),
+            (x**3 + y**3, (x, -3, 3), (y, -3, 3)), show=False,
+            adaptive=adaptive, n=10)
+        # unsymmetric grid (subplots in one line)
+        p = PlotGrid(1, 3, p5, p6, p7)
+        filename = 'test_grid3.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_append_issue_7140(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    p1 = plot(x, adaptive=adaptive, n=10)
+    p2 = plot(x**2, adaptive=adaptive, n=10)
+    plot(x + 2, adaptive=adaptive, n=10)
+
+    # append a series
+    p2.append(p1[0])
+    assert len(p2._series) == 2
+
+    with raises(TypeError):
+        p1.append(p2)
+
+    with raises(TypeError):
+        p1.append(p2._series)
+
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_issue_15265(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    eqn = sin(x)
+
+    p = plot(eqn, xlim=(-S.Pi, S.Pi), ylim=(-1, 1), adaptive=adaptive, n=10)
+    p._backend.close()
+
+    p = plot(eqn, xlim=(-1, 1), ylim=(-S.Pi, S.Pi), adaptive=adaptive, n=10)
+    p._backend.close()
+
+    p = plot(eqn, xlim=(-1, 1), adaptive=adaptive, n=10,
+        ylim=(sympify('-3.14'), sympify('3.14')))
+    p._backend.close()
+
+    p = plot(eqn, adaptive=adaptive, n=10,
+        xlim=(sympify('-3.14'), sympify('3.14')), ylim=(-1, 1))
+    p._backend.close()
+
+    raises(ValueError,
+        lambda: plot(eqn, adaptive=adaptive, n=10,
+            xlim=(-S.ImaginaryUnit, 1), ylim=(-1, 1)))
+
+    raises(ValueError,
+        lambda: plot(eqn, adaptive=adaptive, n=10,
+            xlim=(-1, 1), ylim=(-1, S.ImaginaryUnit)))
+
+    raises(ValueError,
+        lambda: plot(eqn, adaptive=adaptive, n=10,
+            xlim=(S.NegativeInfinity, 1), ylim=(-1, 1)))
+
+    raises(ValueError,
+        lambda: plot(eqn, adaptive=adaptive, n=10,
+            xlim=(-1, 1), ylim=(-1, S.Infinity)))
+
+
+def test_empty_Plot():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    # No exception showing an empty plot
+    plot()
+    # Plot is only a base class: doesn't implement any logic for showing
+    # images
+    p = Plot()
+    raises(NotImplementedError, lambda: p.show())
+
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_issue_17405(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    f = x**0.3 - 10*x**3 + x**2
+    p = plot(f, (x, -10, 10), adaptive=adaptive, n=30, show=False)
+    # Random number of segments, probably more than 100, but we want to see
+    # that there are segments generated, as opposed to when the bug was present
+
+    # RuntimeWarning: invalid value encountered in double_scalars
+    with ignore_warnings(RuntimeWarning):
+        assert len(p[0].get_data()[0]) >= 30
+
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_logplot_PR_16796(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    p = plot(x, (x, .001, 100), adaptive=adaptive, n=30,
+        xscale='log', show=False)
+    # Random number of segments, probably more than 100, but we want to see
+    # that there are segments generated, as opposed to when the bug was present
+    assert len(p[0].get_data()[0]) >= 30
+    assert p[0].end == 100.0
+    assert p[0].start == .001
+
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_issue_16572(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    p = plot(LambertW(x), show=False, adaptive=adaptive, n=30)
+    # Random number of segments, probably more than 50, but we want to see
+    # that there are segments generated, as opposed to when the bug was present
+    assert len(p[0].get_data()[0]) >= 30
+
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_issue_11865(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    k = Symbol('k', integer=True)
+    f = Piecewise((-I*exp(I*pi*k)/k + I*exp(-I*pi*k)/k, Ne(k, 0)), (2*pi, True))
+    p = plot(f, show=False, adaptive=adaptive, n=30)
+    # Random number of segments, probably more than 100, but we want to see
+    # that there are segments generated, as opposed to when the bug was present
+    # and that there are no exceptions.
+    assert len(p[0].get_data()[0]) >= 30
+
+
+def test_issue_11461():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    p = plot(real_root((log(x/(x-2))), 3), show=False, adaptive=True)
+    with warns(
+        RuntimeWarning,
+        match="invalid value encountered in",
+        test_stacklevel=False,
+    ):
+        # Random number of segments, probably more than 100, but we want to see
+        # that there are segments generated, as opposed to when the bug was present
+        # and that there are no exceptions.
+        assert len(p[0].get_data()[0]) >= 30
+
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_issue_11764(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    p = plot_parametric(cos(x), sin(x), (x, 0, 2 * pi),
+        aspect_ratio=(1,1), show=False, adaptive=adaptive, n=30)
+    assert p.aspect_ratio == (1, 1)
+    # Random number of segments, probably more than 100, but we want to see
+    # that there are segments generated, as opposed to when the bug was present
+    assert len(p[0].get_data()[0]) >= 30
+
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_issue_13516(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+
+    pm = plot(sin(x), backend="matplotlib", show=False, adaptive=adaptive, n=30)
+    assert pm.backend == MatplotlibBackend
+    assert len(pm[0].get_data()[0]) >= 30
+
+    pt = plot(sin(x), backend="text", show=False, adaptive=adaptive, n=30)
+    assert pt.backend == TextBackend
+    assert len(pt[0].get_data()[0]) >= 30
+
+    pd = plot(sin(x), backend="default", show=False, adaptive=adaptive, n=30)
+    assert pd.backend == MatplotlibBackend
+    assert len(pd[0].get_data()[0]) >= 30
+
+    p = plot(sin(x), show=False, adaptive=adaptive, n=30)
+    assert p.backend == MatplotlibBackend
+    assert len(p[0].get_data()[0]) >= 30
+
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_plot_limits(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    p = plot(x, x**2, (x, -10, 10), adaptive=adaptive, n=10)
+    backend = p._backend
+
+    xmin, xmax = backend.ax.get_xlim()
+    assert abs(xmin + 10) < 2
+    assert abs(xmax - 10) < 2
+    ymin, ymax = backend.ax.get_ylim()
+    assert abs(ymin + 10) < 10
+    assert abs(ymax - 100) < 10
+
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_plot3d_parametric_line_limits(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+
+    v1 = (2*cos(x), 2*sin(x), 2*x, (x, -5, 5))
+    v2 = (sin(x), cos(x), x, (x, -5, 5))
+    p = plot3d_parametric_line(v1, v2, adaptive=adaptive, n=60)
+    backend = p._backend
+
+    xmin, xmax = backend.ax.get_xlim()
+    assert abs(xmin + 2) < 1e-2
+    assert abs(xmax - 2) < 1e-2
+    ymin, ymax = backend.ax.get_ylim()
+    assert abs(ymin + 2) < 1e-2
+    assert abs(ymax - 2) < 1e-2
+    zmin, zmax = backend.ax.get_zlim()
+    assert abs(zmin + 10) < 1e-2
+    assert abs(zmax - 10) < 1e-2
+
+    p = plot3d_parametric_line(v2, v1, adaptive=adaptive, n=60)
+    backend = p._backend
+
+    xmin, xmax = backend.ax.get_xlim()
+    assert abs(xmin + 2) < 1e-2
+    assert abs(xmax - 2) < 1e-2
+    ymin, ymax = backend.ax.get_ylim()
+    assert abs(ymin + 2) < 1e-2
+    assert abs(ymax - 2) < 1e-2
+    zmin, zmax = backend.ax.get_zlim()
+    assert abs(zmin + 10) < 1e-2
+    assert abs(zmax - 10) < 1e-2
+
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_plot_size(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+
+    p1 = plot(sin(x), backend="matplotlib", size=(8, 4),
+        adaptive=adaptive, n=10)
+    s1 = p1._backend.fig.get_size_inches()
+    assert (s1[0] == 8) and (s1[1] == 4)
+    p2 = plot(sin(x), backend="matplotlib", size=(5, 10),
+        adaptive=adaptive, n=10)
+    s2 = p2._backend.fig.get_size_inches()
+    assert (s2[0] == 5) and (s2[1] == 10)
+    p3 = PlotGrid(2, 1, p1, p2, size=(6, 2),
+        adaptive=adaptive, n=10)
+    s3 = p3._backend.fig.get_size_inches()
+    assert (s3[0] == 6) and (s3[1] == 2)
+
+    with raises(ValueError):
+        plot(sin(x), backend="matplotlib", size=(-1, 3))
+
+
+def test_issue_20113():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+
+    # verify the capability to use custom backends
+    plot(sin(x), backend=Plot, show=False)
+    p2 = plot(sin(x), backend=MatplotlibBackend, show=False)
+    assert p2.backend == MatplotlibBackend
+    assert len(p2[0].get_data()[0]) >= 30
+    p3 = plot(sin(x), backend=DummyBackendOk, show=False)
+    assert p3.backend == DummyBackendOk
+    assert len(p3[0].get_data()[0]) >= 30
+
+    # test for an improper coded backend
+    p4 = plot(sin(x), backend=DummyBackendNotOk, show=False)
+    assert p4.backend == DummyBackendNotOk
+    assert len(p4[0].get_data()[0]) >= 30
+    with raises(NotImplementedError):
+        p4.show()
+    with raises(NotImplementedError):
+        p4.save("test/path")
+    with raises(NotImplementedError):
+        p4._backend.close()
+
+
+def test_custom_coloring():
+    x = Symbol('x')
+    y = Symbol('y')
+    plot(cos(x), line_color=lambda a: a)
+    plot(cos(x), line_color=1)
+    plot(cos(x), line_color="r")
+    plot_parametric(cos(x), sin(x), line_color=lambda a: a)
+    plot_parametric(cos(x), sin(x), line_color=1)
+    plot_parametric(cos(x), sin(x), line_color="r")
+    plot3d_parametric_line(cos(x), sin(x), x, line_color=lambda a: a)
+    plot3d_parametric_line(cos(x), sin(x), x, line_color=1)
+    plot3d_parametric_line(cos(x), sin(x), x, line_color="r")
+    plot3d_parametric_surface(cos(x + y), sin(x - y), x - y,
+            (x, -5, 5), (y, -5, 5),
+            surface_color=lambda a, b: a**2 + b**2)
+    plot3d_parametric_surface(cos(x + y), sin(x - y), x - y,
+            (x, -5, 5), (y, -5, 5),
+            surface_color=1)
+    plot3d_parametric_surface(cos(x + y), sin(x - y), x - y,
+            (x, -5, 5), (y, -5, 5),
+            surface_color="r")
+    plot3d(x*y, (x, -5, 5), (y, -5, 5),
+            surface_color=lambda a, b: a**2 + b**2)
+    plot3d(x*y, (x, -5, 5), (y, -5, 5), surface_color=1)
+    plot3d(x*y, (x, -5, 5), (y, -5, 5), surface_color="r")
+
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_deprecated_get_segments(adaptive):
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    f = sin(x)
+    p = plot(f, (x, -10, 10), show=False, adaptive=adaptive, n=10)
+    with warns_deprecated_sympy():
+        p[0].get_segments()
+
+
+@pytest.mark.parametrize("adaptive", [True, False])
+def test_generic_data_series(adaptive):
+    # verify that no errors are raised when generic data series are used
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol("x")
+    p = plot(x,
+        markers=[{"args":[[0, 1], [0, 1]], "marker": "*", "linestyle": "none"}],
+        annotations=[{"text": "test", "xy": (0, 0)}],
+        fill={"x": [0, 1, 2, 3], "y1": [0, 1, 2, 3]},
+        rectangles=[{"xy": (0, 0), "width": 5, "height": 1}],
+        adaptive=adaptive, n=10)
+    assert len(p._backend.ax.collections) == 1
+    assert len(p._backend.ax.patches) == 1
+    assert len(p._backend.ax.lines) == 2
+    assert len(p._backend.ax.texts) == 1
+
+
+def test_deprecated_markers_annotations_rectangles_fill():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    p = plot(sin(x), (x, -10, 10), show=False)
+    with warns_deprecated_sympy():
+        p.markers = [{"args":[[0, 1], [0, 1]], "marker": "*", "linestyle": "none"}]
+    assert len(p._series) == 2
+    with warns_deprecated_sympy():
+        p.annotations = [{"text": "test", "xy": (0, 0)}]
+    assert len(p._series) == 3
+    with warns_deprecated_sympy():
+        p.fill = {"x": [0, 1, 2, 3], "y1": [0, 1, 2, 3]}
+    assert len(p._series) == 4
+    with warns_deprecated_sympy():
+        p.rectangles = [{"xy": (0, 0), "width": 5, "height": 1}]
+    assert len(p._series) == 5
+
+
+def test_back_compatibility():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    y = Symbol('y')
+    p = plot(sin(x), adaptive=False, n=5)
+    assert len(p[0].get_points()) == 2
+    assert len(p[0].get_data()) == 2
+    p = plot_parametric(cos(x), sin(x), (x, 0, 2), adaptive=False, n=5)
+    assert len(p[0].get_points()) == 2
+    assert len(p[0].get_data()) == 3
+    p = plot3d_parametric_line(cos(x), sin(x), x, (x, 0, 2),
+        adaptive=False, n=5)
+    assert len(p[0].get_points()) == 3
+    assert len(p[0].get_data()) == 4
+    p = plot3d(cos(x**2 + y**2), (x, -pi, pi), (y, -pi, pi), n=5)
+    assert len(p[0].get_meshes()) == 3
+    assert len(p[0].get_data()) == 3
+    p = plot_contour(cos(x**2 + y**2), (x, -pi, pi), (y, -pi, pi), n=5)
+    assert len(p[0].get_meshes()) == 3
+    assert len(p[0].get_data()) == 3
+    p = plot3d_parametric_surface(x * cos(y), x * sin(y), x * cos(4 * y) / 2,
+        (x, 0, pi), (y, 0, 2*pi), n=5)
+    assert len(p[0].get_meshes()) == 3
+    assert len(p[0].get_data()) == 5
+
+
+def test_plot_arguments():
+    ### Test arguments for plot()
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x, y = symbols("x, y")
+
+    # single expressions
+    p = plot(x + 1)
+    assert isinstance(p[0], LineOver1DRangeSeries)
+    assert p[0].expr == x + 1
+    assert p[0].ranges == [(x, -10, 10)]
+    assert p[0].get_label(False) == "x + 1"
+    assert p[0].rendering_kw == {}
+
+    # single expressions custom label
+    p = plot(x + 1, "label")
+    assert isinstance(p[0], LineOver1DRangeSeries)
+    assert p[0].expr == x + 1
+    assert p[0].ranges == [(x, -10, 10)]
+    assert p[0].get_label(False) == "label"
+    assert p[0].rendering_kw == {}
+
+    # single expressions with range
+    p = plot(x + 1, (x, -2, 2))
+    assert p[0].ranges == [(x, -2, 2)]
+
+    # single expressions with range, label and rendering-kw dictionary
+    p = plot(x + 1, (x, -2, 2), "test", {"color": "r"})
+    assert p[0].get_label(False) == "test"
+    assert p[0].rendering_kw == {"color": "r"}
+
+    # multiple expressions
+    p = plot(x + 1, x**2)
+    assert isinstance(p[0], LineOver1DRangeSeries)
+    assert p[0].expr == x + 1
+    assert p[0].ranges == [(x, -10, 10)]
+    assert p[0].get_label(False) == "x + 1"
+    assert p[0].rendering_kw == {}
+    assert isinstance(p[1], LineOver1DRangeSeries)
+    assert p[1].expr == x**2
+    assert p[1].ranges == [(x, -10, 10)]
+    assert p[1].get_label(False) == "x**2"
+    assert p[1].rendering_kw == {}
+
+    # multiple expressions over the same range
+    p = plot(x + 1, x**2, (x, 0, 5))
+    assert p[0].ranges == [(x, 0, 5)]
+    assert p[1].ranges == [(x, 0, 5)]
+
+    # multiple expressions over the same range with the same rendering kws
+    p = plot(x + 1, x**2, (x, 0, 5), {"color": "r"})
+    assert p[0].ranges == [(x, 0, 5)]
+    assert p[1].ranges == [(x, 0, 5)]
+    assert p[0].rendering_kw == {"color": "r"}
+    assert p[1].rendering_kw == {"color": "r"}
+
+    # multiple expressions with different ranges, labels and rendering kws
+    p = plot(
+        (x + 1, (x, 0, 5)),
+        (x**2, (x, -2, 2), "test", {"color": "r"}))
+    assert isinstance(p[0], LineOver1DRangeSeries)
+    assert p[0].expr == x + 1
+    assert p[0].ranges == [(x, 0, 5)]
+    assert p[0].get_label(False) == "x + 1"
+    assert p[0].rendering_kw == {}
+    assert isinstance(p[1], LineOver1DRangeSeries)
+    assert p[1].expr == x**2
+    assert p[1].ranges == [(x, -2, 2)]
+    assert p[1].get_label(False) == "test"
+    assert p[1].rendering_kw == {"color": "r"}
+
+    # single argument: lambda function
+    f = lambda t: t
+    p = plot(lambda t: t)
+    assert isinstance(p[0], LineOver1DRangeSeries)
+    assert callable(p[0].expr)
+    assert p[0].ranges[0][1:] == (-10, 10)
+    assert p[0].get_label(False) == ""
+    assert p[0].rendering_kw == {}
+
+    # single argument: lambda function + custom range and label
+    p = plot(f, ("t", -5, 6), "test")
+    assert p[0].ranges[0][1:] == (-5, 6)
+    assert p[0].get_label(False) == "test"
+
+
+def test_plot_parametric_arguments():
+    ### Test arguments for plot_parametric()
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x, y = symbols("x, y")
+
+    # single parametric expression
+    p = plot_parametric(x + 1, x)
+    assert isinstance(p[0], Parametric2DLineSeries)
+    assert p[0].expr == (x + 1, x)
+    assert p[0].ranges == [(x, -10, 10)]
+    assert p[0].get_label(False) == "x"
+    assert p[0].rendering_kw == {}
+
+    # single parametric expression with custom range, label and rendering kws
+    p = plot_parametric(x + 1, x, (x, -2, 2), "test",
+        {"cmap": "Reds"})
+    assert p[0].expr == (x + 1, x)
+    assert p[0].ranges == [(x, -2, 2)]
+    assert p[0].get_label(False) == "test"
+    assert p[0].rendering_kw == {"cmap": "Reds"}
+
+    p = plot_parametric((x + 1, x), (x, -2, 2), "test")
+    assert p[0].expr == (x + 1, x)
+    assert p[0].ranges == [(x, -2, 2)]
+    assert p[0].get_label(False) == "test"
+    assert p[0].rendering_kw == {}
+
+    # multiple parametric expressions same symbol
+    p = plot_parametric((x + 1, x), (x ** 2, x + 1))
+    assert p[0].expr == (x + 1, x)
+    assert p[0].ranges == [(x, -10, 10)]
+    assert p[0].get_label(False) == "x"
+    assert p[0].rendering_kw == {}
+    assert p[1].expr == (x ** 2, x + 1)
+    assert p[1].ranges == [(x, -10, 10)]
+    assert p[1].get_label(False) == "x"
+    assert p[1].rendering_kw == {}
+
+    # multiple parametric expressions different symbols
+    p = plot_parametric((x + 1, x), (y ** 2, y + 1, "test"))
+    assert p[0].expr == (x + 1, x)
+    assert p[0].ranges == [(x, -10, 10)]
+    assert p[0].get_label(False) == "x"
+    assert p[0].rendering_kw == {}
+    assert p[1].expr == (y ** 2, y + 1)
+    assert p[1].ranges == [(y, -10, 10)]
+    assert p[1].get_label(False) == "test"
+    assert p[1].rendering_kw == {}
+
+    # multiple parametric expressions same range
+    p = plot_parametric((x + 1, x), (x ** 2, x + 1), (x, -2, 2))
+    assert p[0].expr == (x + 1, x)
+    assert p[0].ranges == [(x, -2, 2)]
+    assert p[0].get_label(False) == "x"
+    assert p[0].rendering_kw == {}
+    assert p[1].expr == (x ** 2, x + 1)
+    assert p[1].ranges == [(x, -2, 2)]
+    assert p[1].get_label(False) == "x"
+    assert p[1].rendering_kw == {}
+
+    # multiple parametric expressions, custom ranges and labels
+    p = plot_parametric(
+        (x + 1, x, (x, -2, 2), "test1"),
+        (x ** 2, x + 1, (x, -3, 3), "test2", {"cmap": "Reds"}))
+    assert p[0].expr == (x + 1, x)
+    assert p[0].ranges == [(x, -2, 2)]
+    assert p[0].get_label(False) == "test1"
+    assert p[0].rendering_kw == {}
+    assert p[1].expr == (x ** 2, x + 1)
+    assert p[1].ranges == [(x, -3, 3)]
+    assert p[1].get_label(False) == "test2"
+    assert p[1].rendering_kw == {"cmap": "Reds"}
+
+    # single argument: lambda function
+    fx = lambda t: t
+    fy = lambda t: 2 * t
+    p = plot_parametric(fx, fy)
+    assert all(callable(t) for t in p[0].expr)
+    assert p[0].ranges[0][1:] == (-10, 10)
+    assert "Dummy" in p[0].get_label(False)
+    assert p[0].rendering_kw == {}
+
+    # single argument: lambda function + custom range + label
+    p = plot_parametric(fx, fy, ("t", 0, 2), "test")
+    assert all(callable(t) for t in p[0].expr)
+    assert p[0].ranges[0][1:] == (0, 2)
+    assert p[0].get_label(False) == "test"
+    assert p[0].rendering_kw == {}
+
+
+def test_plot3d_parametric_line_arguments():
+    ### Test arguments for plot3d_parametric_line()
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x, y = symbols("x, y")
+
+    # single parametric expression
+    p = plot3d_parametric_line(x + 1, x, sin(x))
+    assert isinstance(p[0], Parametric3DLineSeries)
+    assert p[0].expr == (x + 1, x, sin(x))
+    assert p[0].ranges == [(x, -10, 10)]
+    assert p[0].get_label(False) == "x"
+    assert p[0].rendering_kw == {}
+
+    # single parametric expression with custom range, label and rendering kws
+    p = plot3d_parametric_line(x + 1, x, sin(x), (x, -2, 2),
+        "test", {"cmap": "Reds"})
+    assert isinstance(p[0], Parametric3DLineSeries)
+    assert p[0].expr == (x + 1, x, sin(x))
+    assert p[0].ranges == [(x, -2, 2)]
+    assert p[0].get_label(False) == "test"
+    assert p[0].rendering_kw == {"cmap": "Reds"}
+
+    p = plot3d_parametric_line((x + 1, x, sin(x)), (x, -2, 2), "test")
+    assert p[0].expr == (x + 1, x, sin(x))
+    assert p[0].ranges == [(x, -2, 2)]
+    assert p[0].get_label(False) == "test"
+    assert p[0].rendering_kw == {}
+
+    # multiple parametric expression same symbol
+    p = plot3d_parametric_line(
+        (x + 1, x, sin(x)), (x ** 2, 1, cos(x), {"cmap": "Reds"}))
+    assert p[0].expr == (x + 1, x, sin(x))
+    assert p[0].ranges == [(x, -10, 10)]
+    assert p[0].get_label(False) == "x"
+    assert p[0].rendering_kw == {}
+    assert p[1].expr == (x ** 2, 1, cos(x))
+    assert p[1].ranges == [(x, -10, 10)]
+    assert p[1].get_label(False) == "x"
+    assert p[1].rendering_kw == {"cmap": "Reds"}
+
+    # multiple parametric expression different symbols
+    p = plot3d_parametric_line((x + 1, x, sin(x)), (y ** 2, 1, cos(y)))
+    assert p[0].expr == (x + 1, x, sin(x))
+    assert p[0].ranges == [(x, -10, 10)]
+    assert p[0].get_label(False) == "x"
+    assert p[0].rendering_kw == {}
+    assert p[1].expr == (y ** 2, 1, cos(y))
+    assert p[1].ranges == [(y, -10, 10)]
+    assert p[1].get_label(False) == "y"
+    assert p[1].rendering_kw == {}
+
+    # multiple parametric expression, custom ranges and labels
+    p = plot3d_parametric_line(
+        (x + 1, x, sin(x)),
+        (x ** 2, 1, cos(x), (x, -2, 2), "test", {"cmap": "Reds"}))
+    assert p[0].expr == (x + 1, x, sin(x))
+    assert p[0].ranges == [(x, -10, 10)]
+    assert p[0].get_label(False) == "x"
+    assert p[0].rendering_kw == {}
+    assert p[1].expr == (x ** 2, 1, cos(x))
+    assert p[1].ranges == [(x, -2, 2)]
+    assert p[1].get_label(False) == "test"
+    assert p[1].rendering_kw == {"cmap": "Reds"}
+
+    # single argument: lambda function
+    fx = lambda t: t
+    fy = lambda t: 2 * t
+    fz = lambda t: 3 * t
+    p = plot3d_parametric_line(fx, fy, fz)
+    assert all(callable(t) for t in p[0].expr)
+    assert p[0].ranges[0][1:] == (-10, 10)
+    assert "Dummy" in p[0].get_label(False)
+    assert p[0].rendering_kw == {}
+
+    # single argument: lambda function + custom range + label
+    p = plot3d_parametric_line(fx, fy, fz, ("t", 0, 2), "test")
+    assert all(callable(t) for t in p[0].expr)
+    assert p[0].ranges[0][1:] == (0, 2)
+    assert p[0].get_label(False) == "test"
+    assert p[0].rendering_kw == {}
+
+
+def test_plot3d_plot_contour_arguments():
+    ### Test arguments for plot3d() and plot_contour()
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x, y = symbols("x, y")
+
+    # single expression
+    p = plot3d(x + y)
+    assert isinstance(p[0], SurfaceOver2DRangeSeries)
+    assert p[0].expr == x + y
+    assert p[0].ranges[0] == (x, -10, 10) or (y, -10, 10)
+    assert p[0].ranges[1] == (x, -10, 10) or (y, -10, 10)
+    assert p[0].get_label(False) == "x + y"
+    assert p[0].rendering_kw == {}
+
+    # single expression, custom range, label and rendering kws
+    p = plot3d(x + y, (x, -2, 2), "test", {"cmap": "Reds"})
+    assert isinstance(p[0], SurfaceOver2DRangeSeries)
+    assert p[0].expr == x + y
+    assert p[0].ranges[0] == (x, -2, 2)
+    assert p[0].ranges[1] == (y, -10, 10)
+    assert p[0].get_label(False) == "test"
+    assert p[0].rendering_kw == {"cmap": "Reds"}
+
+    p = plot3d(x + y, (x, -2, 2), (y, -4, 4), "test")
+    assert p[0].ranges[0] == (x, -2, 2)
+    assert p[0].ranges[1] == (y, -4, 4)
+
+    # multiple expressions
+    p = plot3d(x + y, x * y)
+    assert p[0].expr == x + y
+    assert p[0].ranges[0] == (x, -10, 10) or (y, -10, 10)
+    assert p[0].ranges[1] == (x, -10, 10) or (y, -10, 10)
+    assert p[0].get_label(False) == "x + y"
+    assert p[0].rendering_kw == {}
+    assert p[1].expr == x * y
+    assert p[1].ranges[0] == (x, -10, 10) or (y, -10, 10)
+    assert p[1].ranges[1] == (x, -10, 10) or (y, -10, 10)
+    assert p[1].get_label(False) == "x*y"
+    assert p[1].rendering_kw == {}
+
+    # multiple expressions, same custom ranges
+    p = plot3d(x + y, x * y, (x, -2, 2), (y, -4, 4))
+    assert p[0].expr == x + y
+    assert p[0].ranges[0] == (x, -2, 2)
+    assert p[0].ranges[1] == (y, -4, 4)
+    assert p[0].get_label(False) == "x + y"
+    assert p[0].rendering_kw == {}
+    assert p[1].expr == x * y
+    assert p[1].ranges[0] == (x, -2, 2)
+    assert p[1].ranges[1] == (y, -4, 4)
+    assert p[1].get_label(False) == "x*y"
+    assert p[1].rendering_kw == {}
+
+    # multiple expressions, custom ranges, labels and rendering kws
+    p = plot3d(
+        (x + y, (x, -2, 2), (y, -4, 4)),
+        (x * y, (x, -3, 3), (y, -6, 6), "test", {"cmap": "Reds"}))
+    assert p[0].expr == x + y
+    assert p[0].ranges[0] == (x, -2, 2)
+    assert p[0].ranges[1] == (y, -4, 4)
+    assert p[0].get_label(False) == "x + y"
+    assert p[0].rendering_kw == {}
+    assert p[1].expr == x * y
+    assert p[1].ranges[0] == (x, -3, 3)
+    assert p[1].ranges[1] == (y, -6, 6)
+    assert p[1].get_label(False) == "test"
+    assert p[1].rendering_kw == {"cmap": "Reds"}
+
+    # single expression: lambda function
+    f = lambda x, y: x + y
+    p = plot3d(f)
+    assert callable(p[0].expr)
+    assert p[0].ranges[0][1:] == (-10, 10)
+    assert p[0].ranges[1][1:] == (-10, 10)
+    assert p[0].get_label(False) == ""
+    assert p[0].rendering_kw == {}
+
+    # single expression: lambda function + custom ranges + label
+    p = plot3d(f, ("a", -5, 3), ("b", -2, 1), "test")
+    assert callable(p[0].expr)
+    assert p[0].ranges[0][1:] == (-5, 3)
+    assert p[0].ranges[1][1:] == (-2, 1)
+    assert p[0].get_label(False) == "test"
+    assert p[0].rendering_kw == {}
+
+    # test issue 25818
+    # single expression, custom range, min/max functions
+    p = plot3d(Min(x, y), (x, 0, 10), (y, 0, 10))
+    assert isinstance(p[0], SurfaceOver2DRangeSeries)
+    assert p[0].expr == Min(x, y)
+    assert p[0].ranges[0] == (x, 0, 10)
+    assert p[0].ranges[1] == (y, 0, 10)
+    assert p[0].get_label(False) == "Min(x, y)"
+    assert p[0].rendering_kw == {}
+
+
+def test_plot3d_parametric_surface_arguments():
+    ### Test arguments for plot3d_parametric_surface()
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x, y = symbols("x, y")
+
+    # single parametric expression
+    p = plot3d_parametric_surface(x + y, cos(x + y), sin(x + y))
+    assert isinstance(p[0], ParametricSurfaceSeries)
+    assert p[0].expr == (x + y, cos(x + y), sin(x + y))
+    assert p[0].ranges[0] == (x, -10, 10) or (y, -10, 10)
+    assert p[0].ranges[1] == (x, -10, 10) or (y, -10, 10)
+    assert p[0].get_label(False) == "(x + y, cos(x + y), sin(x + y))"
+    assert p[0].rendering_kw == {}
+
+    # single parametric expression, custom ranges, labels and rendering kws
+    p = plot3d_parametric_surface(x + y, cos(x + y), sin(x + y),
+        (x, -2, 2), (y, -4, 4), "test", {"cmap": "Reds"})
+    assert isinstance(p[0], ParametricSurfaceSeries)
+    assert p[0].expr == (x + y, cos(x + y), sin(x + y))
+    assert p[0].ranges[0] == (x, -2, 2)
+    assert p[0].ranges[1] == (y, -4, 4)
+    assert p[0].get_label(False) == "test"
+    assert p[0].rendering_kw == {"cmap": "Reds"}
+
+    # multiple parametric expressions
+    p = plot3d_parametric_surface(
+        (x + y, cos(x + y), sin(x + y)),
+        (x - y, cos(x - y), sin(x - y), "test"))
+    assert p[0].expr == (x + y, cos(x + y), sin(x + y))
+    assert p[0].ranges[0] == (x, -10, 10) or (y, -10, 10)
+    assert p[0].ranges[1] == (x, -10, 10) or (y, -10, 10)
+    assert p[0].get_label(False) == "(x + y, cos(x + y), sin(x + y))"
+    assert p[0].rendering_kw == {}
+    assert p[1].expr == (x - y, cos(x - y), sin(x - y))
+    assert p[1].ranges[0] == (x, -10, 10) or (y, -10, 10)
+    assert p[1].ranges[1] == (x, -10, 10) or (y, -10, 10)
+    assert p[1].get_label(False) == "test"
+    assert p[1].rendering_kw == {}
+
+    # multiple parametric expressions, custom ranges and labels
+    p = plot3d_parametric_surface(
+        (x + y, cos(x + y), sin(x + y), (x, -2, 2), "test"),
+        (x - y, cos(x - y), sin(x - y), (x, -3, 3), (y, -4, 4),
+            "test2", {"cmap": "Reds"}))
+    assert p[0].expr == (x + y, cos(x + y), sin(x + y))
+    assert p[0].ranges[0] == (x, -2, 2)
+    assert p[0].ranges[1] == (y, -10, 10)
+    assert p[0].get_label(False) == "test"
+    assert p[0].rendering_kw == {}
+    assert p[1].expr == (x - y, cos(x - y), sin(x - y))
+    assert p[1].ranges[0] == (x, -3, 3)
+    assert p[1].ranges[1] == (y, -4, 4)
+    assert p[1].get_label(False) == "test2"
+    assert p[1].rendering_kw == {"cmap": "Reds"}
+
+    # lambda functions instead of symbolic expressions for a single 3D
+    # parametric surface
+    p = plot3d_parametric_surface(
+        lambda u, v: u, lambda u, v: v, lambda u, v: u + v,
+        ("u", 0, 2), ("v", -3, 4))
+    assert all(callable(t) for t in p[0].expr)
+    assert p[0].ranges[0][1:] == (-0, 2)
+    assert p[0].ranges[1][1:] == (-3, 4)
+    assert p[0].get_label(False) == ""
+    assert p[0].rendering_kw == {}
+
+    # lambda functions instead of symbolic expressions for multiple 3D
+    # parametric surfaces
+    p = plot3d_parametric_surface(
+        (lambda u, v: u, lambda u, v: v, lambda u, v: u + v,
+        ("u", 0, 2), ("v", -3, 4)),
+        (lambda u, v: v, lambda u, v: u, lambda u, v: u - v,
+        ("u", -2, 3), ("v", -4, 5), "test"))
+    assert all(callable(t) for t in p[0].expr)
+    assert p[0].ranges[0][1:] == (0, 2)
+    assert p[0].ranges[1][1:] == (-3, 4)
+    assert p[0].get_label(False) == ""
+    assert p[0].rendering_kw == {}
+    assert all(callable(t) for t in p[1].expr)
+    assert p[1].ranges[0][1:] == (-2, 3)
+    assert p[1].ranges[1][1:] == (-4, 5)
+    assert p[1].get_label(False) == "test"
+    assert p[1].rendering_kw == {}

evalkit_internvl/lib/python3.10/site-packages/sympy/plotting/tests/test_series.py

@@ -0,0 +1,1771 @@
+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)

evalkit_internvl/lib/python3.10/site-packages/sympy/plotting/tests/test_utils.py

@@ -0,0 +1,110 @@
+from pytest import raises
+from sympy import (
+    symbols, Expr, Tuple, Integer, cos, solveset, FiniteSet, ImageSet)
+from sympy.plotting.utils import (
+    _create_ranges, _plot_sympify, extract_solution)
+from sympy.physics.mechanics import ReferenceFrame, Vector as MechVector
+from sympy.vector import CoordSys3D, Vector
+
+
+def test_plot_sympify():
+    x, y = symbols("x, y")
+
+    # argument is already sympified
+    args = x + y
+    r = _plot_sympify(args)
+    assert r == args
+
+    # one argument needs to be sympified
+    args = (x + y, 1)
+    r = _plot_sympify(args)
+    assert isinstance(r, (list, tuple, Tuple)) and len(r) == 2
+    assert isinstance(r[0], Expr)
+    assert isinstance(r[1], Integer)
+
+    # string and dict should not be sympified
+    args = (x + y, (x, 0, 1), "str", 1, {1: 1, 2: 2.0})
+    r = _plot_sympify(args)
+    assert isinstance(r, (list, tuple, Tuple)) and len(r) == 5
+    assert isinstance(r[0], Expr)
+    assert isinstance(r[1], Tuple)
+    assert isinstance(r[2], str)
+    assert isinstance(r[3], Integer)
+    assert isinstance(r[4], dict) and isinstance(r[4][1], int) and isinstance(r[4][2], float)
+
+    # nested arguments containing strings
+    args = ((x + y, (y, 0, 1), "a"), (x + 1, (x, 0, 1), "$f_{1}$"))
+    r = _plot_sympify(args)
+    assert isinstance(r, (list, tuple, Tuple)) and len(r) == 2
+    assert isinstance(r[0], Tuple)
+    assert isinstance(r[0][1], Tuple)
+    assert isinstance(r[0][1][1], Integer)
+    assert isinstance(r[0][2], str)
+    assert isinstance(r[1], Tuple)
+    assert isinstance(r[1][1], Tuple)
+    assert isinstance(r[1][1][1], Integer)
+    assert isinstance(r[1][2], str)
+
+    # vectors from sympy.physics.vectors module are not sympified
+    # vectors from sympy.vectors are sympified
+    # in both cases, no error should be raised
+    R = ReferenceFrame("R")
+    v1 = 2 * R.x + R.y
+    C = CoordSys3D("C")
+    v2 = 2 * C.i + C.j
+    args = (v1, v2)
+    r = _plot_sympify(args)
+    assert isinstance(r, (list, tuple, Tuple)) and len(r) == 2
+    assert isinstance(v1, MechVector)
+    assert isinstance(v2, Vector)
+
+
+def test_create_ranges():
+    x, y = symbols("x, y")
+
+    # user don't provide any range -> return a default range
+    r = _create_ranges({x}, [], 1)
+    assert isinstance(r, (list, tuple, Tuple)) and len(r) == 1
+    assert isinstance(r[0], (Tuple, tuple))
+    assert r[0] == (x, -10, 10)
+
+    r = _create_ranges({x, y}, [], 2)
+    assert isinstance(r, (list, tuple, Tuple)) and len(r) == 2
+    assert isinstance(r[0], (Tuple, tuple))
+    assert isinstance(r[1], (Tuple, tuple))
+    assert r[0] == (x, -10, 10) or (y, -10, 10)
+    assert r[1] == (y, -10, 10) or (x, -10, 10)
+    assert r[0] != r[1]
+
+    # not enough ranges provided by the user -> create default ranges
+    r = _create_ranges(
+        {x, y},
+        [
+            (x, 0, 1),
+        ],
+        2,
+    )
+    assert isinstance(r, (list, tuple, Tuple)) and len(r) == 2
+    assert isinstance(r[0], (Tuple, tuple))
+    assert isinstance(r[1], (Tuple, tuple))
+    assert r[0] == (x, 0, 1) or (y, -10, 10)
+    assert r[1] == (y, -10, 10) or (x, 0, 1)
+    assert r[0] != r[1]
+
+    # too many free symbols
+    raises(ValueError, lambda: _create_ranges({x, y}, [], 1))
+    raises(ValueError, lambda: _create_ranges({x, y}, [(x, 0, 5), (y, 0, 1)], 1))
+
+
+def test_extract_solution():
+    x = symbols("x")
+
+    sol = solveset(cos(10 * x))
+    assert sol.has(ImageSet)
+    res = extract_solution(sol)
+    assert len(res) == 20
+    assert isinstance(res, FiniteSet)
+
+    res = extract_solution(sol, 20)
+    assert len(res) == 40
+    assert isinstance(res, FiniteSet)

evalkit_internvl/lib/python3.10/site-packages/sympy/solvers/diophantine/__pycache__/diophantine.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:310b467920b7c47537a5b4cc7be2d95d9bc3e1debd0eb0eec15d1a086c54bff2
+size 106624

evalkit_internvl/lib/python3.10/site-packages/sympy/solvers/ode/tests/__pycache__/test_systems.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:012aa5a4a636162aecfdaf1098e2074ea9e7136f1d75471f8ef7a0ca7df6e9e8
+size 112044

evalkit_internvl/lib/python3.10/site-packages/sympy/solvers/tests/__pycache__/test_solvers.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cbf9853e6395e88fe228f678aef9abe73d4c381a412697e313bdfce599db29b7
+size 108394

evalkit_tf437/lib/python3.10/site-packages/pydantic_core/_pydantic_core.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f812dd0f40ab6a517a9a5a66ad96c6c0e56f1c9ad7568ad5ba4c9d29a129e42a
+size 4985256

evalkit_tf437/lib/python3.10/site-packages/sklearn/_build_utils/tempita.py

@@ -0,0 +1,60 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import argparse
+import os
+
+from Cython import Tempita as tempita
+
+# XXX: If this import ever fails (does it really?), vendor either
+# cython.tempita or numpy/npy_tempita.
+
+
+def process_tempita(fromfile, outfile=None):
+    """Process tempita templated file and write out the result.
+
+    The template file is expected to end in `.c.tp` or `.pyx.tp`:
+    E.g. processing `template.c.in` generates `template.c`.
+
+    """
+    with open(fromfile, "r", encoding="utf-8") as f:
+        template_content = f.read()
+
+    template = tempita.Template(template_content)
+    content = template.substitute()
+
+    with open(outfile, "w", encoding="utf-8") as f:
+        f.write(content)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("infile", type=str, help="Path to the input file")
+    parser.add_argument("-o", "--outdir", type=str, help="Path to the output directory")
+    parser.add_argument(
+        "-i",
+        "--ignore",
+        type=str,
+        help=(
+            "An ignored input - may be useful to add a "
+            "dependency between custom targets"
+        ),
+    )
+    args = parser.parse_args()
+
+    if not args.infile.endswith(".tp"):
+        raise ValueError(f"Unexpected extension: {args.infile}")
+
+    if not args.outdir:
+        raise ValueError("Missing `--outdir` argument to tempita.py")
+
+    outdir_abs = os.path.join(os.getcwd(), args.outdir)
+    outfile = os.path.join(
+        outdir_abs, os.path.splitext(os.path.split(args.infile)[1])[0]
+    )
+
+    process_tempita(args.infile, outfile)
+
+
+if __name__ == "__main__":
+    main()

evalkit_tf437/lib/python3.10/site-packages/sklearn/_build_utils/version.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+"""Extract version number from __init__.py"""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import os
+
+sklearn_init = os.path.join(os.path.dirname(__file__), "../__init__.py")
+
+data = open(sklearn_init).readlines()
+version_line = next(line for line in data if line.startswith("__version__"))
+
+version = version_line.strip().split(" = ")[1].replace('"', "").replace("'", "")
+
+print(version)

evalkit_tf437/lib/python3.10/site-packages/sklearn/covariance/__init__.py

@@ -0,0 +1,46 @@
+"""Methods and algorithms to robustly estimate covariance.
+
+They estimate the covariance of features at given sets of points, as well as the
+precision matrix defined as the inverse of the covariance. Covariance estimation is
+closely related to the theory of Gaussian graphical models.
+"""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+from ._elliptic_envelope import EllipticEnvelope
+from ._empirical_covariance import (
+    EmpiricalCovariance,
+    empirical_covariance,
+    log_likelihood,
+)
+from ._graph_lasso import GraphicalLasso, GraphicalLassoCV, graphical_lasso
+from ._robust_covariance import MinCovDet, fast_mcd
+from ._shrunk_covariance import (
+    OAS,
+    LedoitWolf,
+    ShrunkCovariance,
+    ledoit_wolf,
+    ledoit_wolf_shrinkage,
+    oas,
+    shrunk_covariance,
+)
+
+__all__ = [
+    "EllipticEnvelope",
+    "EmpiricalCovariance",
+    "GraphicalLasso",
+    "GraphicalLassoCV",
+    "LedoitWolf",
+    "MinCovDet",
+    "OAS",
+    "ShrunkCovariance",
+    "empirical_covariance",
+    "fast_mcd",
+    "graphical_lasso",
+    "ledoit_wolf",
+    "ledoit_wolf_shrinkage",
+    "log_likelihood",
+    "oas",
+    "shrunk_covariance",
+]

evalkit_tf437/lib/python3.10/site-packages/sklearn/covariance/_elliptic_envelope.py

@@ -0,0 +1,266 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+from numbers import Real
+
+import numpy as np
+
+from ..base import OutlierMixin, _fit_context
+from ..metrics import accuracy_score
+from ..utils._param_validation import Interval
+from ..utils.validation import check_is_fitted
+from ._robust_covariance import MinCovDet
+
+
+class EllipticEnvelope(OutlierMixin, MinCovDet):
+    """An object for detecting outliers in a Gaussian distributed dataset.
+
+    Read more in the :ref:`User Guide <outlier_detection>`.
+
+    Parameters
+    ----------
+    store_precision : bool, default=True
+        Specify if the estimated precision is stored.
+
+    assume_centered : bool, default=False
+        If True, the support of robust location and covariance estimates
+        is computed, and a covariance estimate is recomputed from it,
+        without centering the data.
+        Useful to work with data whose mean is significantly equal to
+        zero but is not exactly zero.
+        If False, the robust location and covariance are directly computed
+        with the FastMCD algorithm without additional treatment.
+
+    support_fraction : float, default=None
+        The proportion of points to be included in the support of the raw
+        MCD estimate. If None, the minimum value of support_fraction will
+        be used within the algorithm: `(n_samples + n_features + 1) / 2 * n_samples`.
+        Range is (0, 1).
+
+    contamination : float, default=0.1
+        The amount of contamination of the data set, i.e. the proportion
+        of outliers in the data set. Range is (0, 0.5].
+
+    random_state : int, RandomState instance or None, default=None
+        Determines the pseudo random number generator for shuffling
+        the data. Pass an int for reproducible results across multiple function
+        calls. See :term:`Glossary <random_state>`.
+
+    Attributes
+    ----------
+    location_ : ndarray of shape (n_features,)
+        Estimated robust location.
+
+    covariance_ : ndarray of shape (n_features, n_features)
+        Estimated robust covariance matrix.
+
+    precision_ : ndarray of shape (n_features, n_features)
+        Estimated pseudo inverse matrix.
+        (stored only if store_precision is True)
+
+    support_ : ndarray of shape (n_samples,)
+        A mask of the observations that have been used to compute the
+        robust estimates of location and shape.
+
+    offset_ : float
+        Offset used to define the decision function from the raw scores.
+        We have the relation: ``decision_function = score_samples - offset_``.
+        The offset depends on the contamination parameter and is defined in
+        such a way we obtain the expected number of outliers (samples with
+        decision function < 0) in training.
+
+        .. versionadded:: 0.20
+
+    raw_location_ : ndarray of shape (n_features,)
+        The raw robust estimated location before correction and re-weighting.
+
+    raw_covariance_ : ndarray of shape (n_features, n_features)
+        The raw robust estimated covariance before correction and re-weighting.
+
+    raw_support_ : ndarray of shape (n_samples,)
+        A mask of the observations that have been used to compute
+        the raw robust estimates of location and shape, before correction
+        and re-weighting.
+
+    dist_ : ndarray of shape (n_samples,)
+        Mahalanobis distances of the training set (on which :meth:`fit` is
+        called) observations.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    EmpiricalCovariance : Maximum likelihood covariance estimator.
+    GraphicalLasso : Sparse inverse covariance estimation
+        with an l1-penalized estimator.
+    LedoitWolf : LedoitWolf Estimator.
+    MinCovDet : Minimum Covariance Determinant
+        (robust estimator of covariance).
+    OAS : Oracle Approximating Shrinkage Estimator.
+    ShrunkCovariance : Covariance estimator with shrinkage.
+
+    Notes
+    -----
+    Outlier detection from covariance estimation may break or not
+    perform well in high-dimensional settings. In particular, one will
+    always take care to work with ``n_samples > n_features ** 2``.
+
+    References
+    ----------
+    .. [1] Rousseeuw, P.J., Van Driessen, K. "A fast algorithm for the
+       minimum covariance determinant estimator" Technometrics 41(3), 212
+       (1999)
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.covariance import EllipticEnvelope
+    >>> true_cov = np.array([[.8, .3],
+    ...                      [.3, .4]])
+    >>> X = np.random.RandomState(0).multivariate_normal(mean=[0, 0],
+    ...                                                  cov=true_cov,
+    ...                                                  size=500)
+    >>> cov = EllipticEnvelope(random_state=0).fit(X)
+    >>> # predict returns 1 for an inlier and -1 for an outlier
+    >>> cov.predict([[0, 0],
+    ...              [3, 3]])
+    array([ 1, -1])
+    >>> cov.covariance_
+    array([[0.7411..., 0.2535...],
+           [0.2535..., 0.3053...]])
+    >>> cov.location_
+    array([0.0813... , 0.0427...])
+    """
+
+    _parameter_constraints: dict = {
+        **MinCovDet._parameter_constraints,
+        "contamination": [Interval(Real, 0, 0.5, closed="right")],
+    }
+
+    def __init__(
+        self,
+        *,
+        store_precision=True,
+        assume_centered=False,
+        support_fraction=None,
+        contamination=0.1,
+        random_state=None,
+    ):
+        super().__init__(
+            store_precision=store_precision,
+            assume_centered=assume_centered,
+            support_fraction=support_fraction,
+            random_state=random_state,
+        )
+        self.contamination = contamination
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit the EllipticEnvelope model.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        super().fit(X)
+        self.offset_ = np.percentile(-self.dist_, 100.0 * self.contamination)
+        return self
+
+    def decision_function(self, X):
+        """Compute the decision function of the given observations.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            The data matrix.
+
+        Returns
+        -------
+        decision : ndarray of shape (n_samples,)
+            Decision function of the samples.
+            It is equal to the shifted Mahalanobis distances.
+            The threshold for being an outlier is 0, which ensures a
+            compatibility with other outlier detection algorithms.
+        """
+        check_is_fitted(self)
+        negative_mahal_dist = self.score_samples(X)
+        return negative_mahal_dist - self.offset_
+
+    def score_samples(self, X):
+        """Compute the negative Mahalanobis distances.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            The data matrix.
+
+        Returns
+        -------
+        negative_mahal_distances : array-like of shape (n_samples,)
+            Opposite of the Mahalanobis distances.
+        """
+        check_is_fitted(self)
+        return -self.mahalanobis(X)
+
+    def predict(self, X):
+        """
+        Predict labels (1 inlier, -1 outlier) of X according to fitted model.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            The data matrix.
+
+        Returns
+        -------
+        is_inlier : ndarray of shape (n_samples,)
+            Returns -1 for anomalies/outliers and +1 for inliers.
+        """
+        values = self.decision_function(X)
+        is_inlier = np.full(values.shape[0], -1, dtype=int)
+        is_inlier[values >= 0] = 1
+
+        return is_inlier
+
+    def score(self, X, y, sample_weight=None):
+        """Return the mean accuracy on the given test data and labels.
+
+        In multi-label classification, this is the subset accuracy
+        which is a harsh metric since you require for each sample that
+        each label set be correctly predicted.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Test samples.
+
+        y : array-like of shape (n_samples,) or (n_samples, n_outputs)
+            True labels for X.
+
+        sample_weight : array-like of shape (n_samples,), default=None
+            Sample weights.
+
+        Returns
+        -------
+        score : float
+            Mean accuracy of self.predict(X) w.r.t. y.
+        """
+        return accuracy_score(y, self.predict(X), sample_weight=sample_weight)

evalkit_tf437/lib/python3.10/site-packages/sklearn/covariance/_empirical_covariance.py

@@ -0,0 +1,367 @@
+"""
+Maximum likelihood covariance estimator.
+
+"""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+# avoid division truncation
+import warnings
+
+import numpy as np
+from scipy import linalg
+
+from sklearn.utils import metadata_routing
+
+from .. import config_context
+from ..base import BaseEstimator, _fit_context
+from ..metrics.pairwise import pairwise_distances
+from ..utils import check_array
+from ..utils._param_validation import validate_params
+from ..utils.extmath import fast_logdet
+from ..utils.validation import validate_data
+
+
+@validate_params(
+    {
+        "emp_cov": [np.ndarray],
+        "precision": [np.ndarray],
+    },
+    prefer_skip_nested_validation=True,
+)
+def log_likelihood(emp_cov, precision):
+    """Compute the sample mean of the log_likelihood under a covariance model.
+
+    Computes the empirical expected log-likelihood, allowing for universal
+    comparison (beyond this software package), and accounts for normalization
+    terms and scaling.
+
+    Parameters
+    ----------
+    emp_cov : ndarray of shape (n_features, n_features)
+        Maximum Likelihood Estimator of covariance.
+
+    precision : ndarray of shape (n_features, n_features)
+        The precision matrix of the covariance model to be tested.
+
+    Returns
+    -------
+    log_likelihood_ : float
+        Sample mean of the log-likelihood.
+    """
+    p = precision.shape[0]
+    log_likelihood_ = -np.sum(emp_cov * precision) + fast_logdet(precision)
+    log_likelihood_ -= p * np.log(2 * np.pi)
+    log_likelihood_ /= 2.0
+    return log_likelihood_
+
+
+@validate_params(
+    {
+        "X": ["array-like"],
+        "assume_centered": ["boolean"],
+    },
+    prefer_skip_nested_validation=True,
+)
+def empirical_covariance(X, *, assume_centered=False):
+    """Compute the Maximum likelihood covariance estimator.
+
+    Parameters
+    ----------
+    X : ndarray of shape (n_samples, n_features)
+        Data from which to compute the covariance estimate.
+
+    assume_centered : bool, default=False
+        If `True`, data will not be centered before computation.
+        Useful when working with data whose mean is almost, but not exactly
+        zero.
+        If `False`, data will be centered before computation.
+
+    Returns
+    -------
+    covariance : ndarray of shape (n_features, n_features)
+        Empirical covariance (Maximum Likelihood Estimator).
+
+    Examples
+    --------
+    >>> from sklearn.covariance import empirical_covariance
+    >>> X = [[1,1,1],[1,1,1],[1,1,1],
+    ...      [0,0,0],[0,0,0],[0,0,0]]
+    >>> empirical_covariance(X)
+    array([[0.25, 0.25, 0.25],
+           [0.25, 0.25, 0.25],
+           [0.25, 0.25, 0.25]])
+    """
+    X = check_array(X, ensure_2d=False, ensure_all_finite=False)
+
+    if X.ndim == 1:
+        X = np.reshape(X, (1, -1))
+
+    if X.shape[0] == 1:
+        warnings.warn(
+            "Only one sample available. You may want to reshape your data array"
+        )
+
+    if assume_centered:
+        covariance = np.dot(X.T, X) / X.shape[0]
+    else:
+        covariance = np.cov(X.T, bias=1)
+
+    if covariance.ndim == 0:
+        covariance = np.array([[covariance]])
+    return covariance
+
+
+class EmpiricalCovariance(BaseEstimator):
+    """Maximum likelihood covariance estimator.
+
+    Read more in the :ref:`User Guide <covariance>`.
+
+    Parameters
+    ----------
+    store_precision : bool, default=True
+        Specifies if the estimated precision is stored.
+
+    assume_centered : bool, default=False
+        If True, data are not centered before computation.
+        Useful when working with data whose mean is almost, but not exactly
+        zero.
+        If False (default), data are centered before computation.
+
+    Attributes
+    ----------
+    location_ : ndarray of shape (n_features,)
+        Estimated location, i.e. the estimated mean.
+
+    covariance_ : ndarray of shape (n_features, n_features)
+        Estimated covariance matrix
+
+    precision_ : ndarray of shape (n_features, n_features)
+        Estimated pseudo-inverse matrix.
+        (stored only if store_precision is True)
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    EllipticEnvelope : An object for detecting outliers in
+        a Gaussian distributed dataset.
+    GraphicalLasso : Sparse inverse covariance estimation
+        with an l1-penalized estimator.
+    LedoitWolf : LedoitWolf Estimator.
+    MinCovDet : Minimum Covariance Determinant
+        (robust estimator of covariance).
+    OAS : Oracle Approximating Shrinkage Estimator.
+    ShrunkCovariance : Covariance estimator with shrinkage.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.covariance import EmpiricalCovariance
+    >>> from sklearn.datasets import make_gaussian_quantiles
+    >>> real_cov = np.array([[.8, .3],
+    ...                      [.3, .4]])
+    >>> rng = np.random.RandomState(0)
+    >>> X = rng.multivariate_normal(mean=[0, 0],
+    ...                             cov=real_cov,
+    ...                             size=500)
+    >>> cov = EmpiricalCovariance().fit(X)
+    >>> cov.covariance_
+    array([[0.7569..., 0.2818...],
+           [0.2818..., 0.3928...]])
+    >>> cov.location_
+    array([0.0622..., 0.0193...])
+    """
+
+    # X_test should have been called X
+    __metadata_request__score = {"X_test": metadata_routing.UNUSED}
+
+    _parameter_constraints: dict = {
+        "store_precision": ["boolean"],
+        "assume_centered": ["boolean"],
+    }
+
+    def __init__(self, *, store_precision=True, assume_centered=False):
+        self.store_precision = store_precision
+        self.assume_centered = assume_centered
+
+    def _set_covariance(self, covariance):
+        """Saves the covariance and precision estimates
+
+        Storage is done accordingly to `self.store_precision`.
+        Precision stored only if invertible.
+
+        Parameters
+        ----------
+        covariance : array-like of shape (n_features, n_features)
+            Estimated covariance matrix to be stored, and from which precision
+            is computed.
+        """
+        covariance = check_array(covariance)
+        # set covariance
+        self.covariance_ = covariance
+        # set precision
+        if self.store_precision:
+            self.precision_ = linalg.pinvh(covariance, check_finite=False)
+        else:
+            self.precision_ = None
+
+    def get_precision(self):
+        """Getter for the precision matrix.
+
+        Returns
+        -------
+        precision_ : array-like of shape (n_features, n_features)
+            The precision matrix associated to the current covariance object.
+        """
+        if self.store_precision:
+            precision = self.precision_
+        else:
+            precision = linalg.pinvh(self.covariance_, check_finite=False)
+        return precision
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit the maximum likelihood covariance estimator to X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+          Training data, where `n_samples` is the number of samples and
+          `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        X = validate_data(self, X)
+        if self.assume_centered:
+            self.location_ = np.zeros(X.shape[1])
+        else:
+            self.location_ = X.mean(0)
+        covariance = empirical_covariance(X, assume_centered=self.assume_centered)
+        self._set_covariance(covariance)
+
+        return self
+
+    def score(self, X_test, y=None):
+        """Compute the log-likelihood of `X_test` under the estimated Gaussian model.
+
+        The Gaussian model is defined by its mean and covariance matrix which are
+        represented respectively by `self.location_` and `self.covariance_`.
+
+        Parameters
+        ----------
+        X_test : array-like of shape (n_samples, n_features)
+            Test data of which we compute the likelihood, where `n_samples` is
+            the number of samples and `n_features` is the number of features.
+            `X_test` is assumed to be drawn from the same distribution than
+            the data used in fit (including centering).
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        res : float
+            The log-likelihood of `X_test` with `self.location_` and `self.covariance_`
+            as estimators of the Gaussian model mean and covariance matrix respectively.
+        """
+        X_test = validate_data(self, X_test, reset=False)
+        # compute empirical covariance of the test set
+        test_cov = empirical_covariance(X_test - self.location_, assume_centered=True)
+        # compute log likelihood
+        res = log_likelihood(test_cov, self.get_precision())
+
+        return res
+
+    def error_norm(self, comp_cov, norm="frobenius", scaling=True, squared=True):
+        """Compute the Mean Squared Error between two covariance estimators.
+
+        Parameters
+        ----------
+        comp_cov : array-like of shape (n_features, n_features)
+            The covariance to compare with.
+
+        norm : {"frobenius", "spectral"}, default="frobenius"
+            The type of norm used to compute the error. Available error types:
+            - 'frobenius' (default): sqrt(tr(A^t.A))
+            - 'spectral': sqrt(max(eigenvalues(A^t.A))
+            where A is the error ``(comp_cov - self.covariance_)``.
+
+        scaling : bool, default=True
+            If True (default), the squared error norm is divided by n_features.
+            If False, the squared error norm is not rescaled.
+
+        squared : bool, default=True
+            Whether to compute the squared error norm or the error norm.
+            If True (default), the squared error norm is returned.
+            If False, the error norm is returned.
+
+        Returns
+        -------
+        result : float
+            The Mean Squared Error (in the sense of the Frobenius norm) between
+            `self` and `comp_cov` covariance estimators.
+        """
+        # compute the error
+        error = comp_cov - self.covariance_
+        # compute the error norm
+        if norm == "frobenius":
+            squared_norm = np.sum(error**2)
+        elif norm == "spectral":
+            squared_norm = np.amax(linalg.svdvals(np.dot(error.T, error)))
+        else:
+            raise NotImplementedError(
+                "Only spectral and frobenius norms are implemented"
+            )
+        # optionally scale the error norm
+        if scaling:
+            squared_norm = squared_norm / error.shape[0]
+        # finally get either the squared norm or the norm
+        if squared:
+            result = squared_norm
+        else:
+            result = np.sqrt(squared_norm)
+
+        return result
+
+    def mahalanobis(self, X):
+        """Compute the squared Mahalanobis distances of given observations.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            The observations, the Mahalanobis distances of the which we
+            compute. Observations are assumed to be drawn from the same
+            distribution than the data used in fit.
+
+        Returns
+        -------
+        dist : ndarray of shape (n_samples,)
+            Squared Mahalanobis distances of the observations.
+        """
+        X = validate_data(self, X, reset=False)
+
+        precision = self.get_precision()
+        with config_context(assume_finite=True):
+            # compute mahalanobis distances
+            dist = pairwise_distances(
+                X, self.location_[np.newaxis, :], metric="mahalanobis", VI=precision
+            )
+
+        return np.reshape(dist, (len(X),)) ** 2

evalkit_tf437/lib/python3.10/site-packages/sklearn/covariance/_graph_lasso.py

@@ -0,0 +1,1140 @@
+"""GraphicalLasso: sparse inverse covariance estimation with an l1-penalized
+estimator.
+"""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import operator
+import sys
+import time
+import warnings
+from numbers import Integral, Real
+
+import numpy as np
+from scipy import linalg
+
+from ..base import _fit_context
+from ..exceptions import ConvergenceWarning
+
+# mypy error: Module 'sklearn.linear_model' has no attribute '_cd_fast'
+from ..linear_model import _cd_fast as cd_fast  # type: ignore
+from ..linear_model import lars_path_gram
+from ..model_selection import check_cv, cross_val_score
+from ..utils import Bunch
+from ..utils._param_validation import Interval, StrOptions, validate_params
+from ..utils.metadata_routing import (
+    MetadataRouter,
+    MethodMapping,
+    _raise_for_params,
+    _routing_enabled,
+    process_routing,
+)
+from ..utils.parallel import Parallel, delayed
+from ..utils.validation import (
+    _is_arraylike_not_scalar,
+    check_random_state,
+    check_scalar,
+    validate_data,
+)
+from . import EmpiricalCovariance, empirical_covariance, log_likelihood
+
+
+# Helper functions to compute the objective and dual objective functions
+# of the l1-penalized estimator
+def _objective(mle, precision_, alpha):
+    """Evaluation of the graphical-lasso objective function
+
+    the objective function is made of a shifted scaled version of the
+    normalized log-likelihood (i.e. its empirical mean over the samples) and a
+    penalisation term to promote sparsity
+    """
+    p = precision_.shape[0]
+    cost = -2.0 * log_likelihood(mle, precision_) + p * np.log(2 * np.pi)
+    cost += alpha * (np.abs(precision_).sum() - np.abs(np.diag(precision_)).sum())
+    return cost
+
+
+def _dual_gap(emp_cov, precision_, alpha):
+    """Expression of the dual gap convergence criterion
+
+    The specific definition is given in Duchi "Projected Subgradient Methods
+    for Learning Sparse Gaussians".
+    """
+    gap = np.sum(emp_cov * precision_)
+    gap -= precision_.shape[0]
+    gap += alpha * (np.abs(precision_).sum() - np.abs(np.diag(precision_)).sum())
+    return gap
+
+
+# The g-lasso algorithm
+def _graphical_lasso(
+    emp_cov,
+    alpha,
+    *,
+    cov_init=None,
+    mode="cd",
+    tol=1e-4,
+    enet_tol=1e-4,
+    max_iter=100,
+    verbose=False,
+    eps=np.finfo(np.float64).eps,
+):
+    _, n_features = emp_cov.shape
+    if alpha == 0:
+        # Early return without regularization
+        precision_ = linalg.inv(emp_cov)
+        cost = -2.0 * log_likelihood(emp_cov, precision_)
+        cost += n_features * np.log(2 * np.pi)
+        d_gap = np.sum(emp_cov * precision_) - n_features
+        return emp_cov, precision_, (cost, d_gap), 0
+
+    if cov_init is None:
+        covariance_ = emp_cov.copy()
+    else:
+        covariance_ = cov_init.copy()
+    # As a trivial regularization (Tikhonov like), we scale down the
+    # off-diagonal coefficients of our starting point: This is needed, as
+    # in the cross-validation the cov_init can easily be
+    # ill-conditioned, and the CV loop blows. Beside, this takes
+    # conservative stand-point on the initial conditions, and it tends to
+    # make the convergence go faster.
+    covariance_ *= 0.95
+    diagonal = emp_cov.flat[:: n_features + 1]
+    covariance_.flat[:: n_features + 1] = diagonal
+    precision_ = linalg.pinvh(covariance_)
+
+    indices = np.arange(n_features)
+    i = 0  # initialize the counter to be robust to `max_iter=0`
+    costs = list()
+    # The different l1 regression solver have different numerical errors
+    if mode == "cd":
+        errors = dict(over="raise", invalid="ignore")
+    else:
+        errors = dict(invalid="raise")
+    try:
+        # be robust to the max_iter=0 edge case, see:
+        # https://github.com/scikit-learn/scikit-learn/issues/4134
+        d_gap = np.inf
+        # set a sub_covariance buffer
+        sub_covariance = np.copy(covariance_[1:, 1:], order="C")
+        for i in range(max_iter):
+            for idx in range(n_features):
+                # To keep the contiguous matrix `sub_covariance` equal to
+                # covariance_[indices != idx].T[indices != idx]
+                # we only need to update 1 column and 1 line when idx changes
+                if idx > 0:
+                    di = idx - 1
+                    sub_covariance[di] = covariance_[di][indices != idx]
+                    sub_covariance[:, di] = covariance_[:, di][indices != idx]
+                else:
+                    sub_covariance[:] = covariance_[1:, 1:]
+                row = emp_cov[idx, indices != idx]
+                with np.errstate(**errors):
+                    if mode == "cd":
+                        # Use coordinate descent
+                        coefs = -(
+                            precision_[indices != idx, idx]
+                            / (precision_[idx, idx] + 1000 * eps)
+                        )
+                        coefs, _, _, _ = cd_fast.enet_coordinate_descent_gram(
+                            coefs,
+                            alpha,
+                            0,
+                            sub_covariance,
+                            row,
+                            row,
+                            max_iter,
+                            enet_tol,
+                            check_random_state(None),
+                            False,
+                        )
+                    else:  # mode == "lars"
+                        _, _, coefs = lars_path_gram(
+                            Xy=row,
+                            Gram=sub_covariance,
+                            n_samples=row.size,
+                            alpha_min=alpha / (n_features - 1),
+                            copy_Gram=True,
+                            eps=eps,
+                            method="lars",
+                            return_path=False,
+                        )
+                # Update the precision matrix
+                precision_[idx, idx] = 1.0 / (
+                    covariance_[idx, idx]
+                    - np.dot(covariance_[indices != idx, idx], coefs)
+                )
+                precision_[indices != idx, idx] = -precision_[idx, idx] * coefs
+                precision_[idx, indices != idx] = -precision_[idx, idx] * coefs
+                coefs = np.dot(sub_covariance, coefs)
+                covariance_[idx, indices != idx] = coefs
+                covariance_[indices != idx, idx] = coefs
+            if not np.isfinite(precision_.sum()):
+                raise FloatingPointError(
+                    "The system is too ill-conditioned for this solver"
+                )
+            d_gap = _dual_gap(emp_cov, precision_, alpha)
+            cost = _objective(emp_cov, precision_, alpha)
+            if verbose:
+                print(
+                    "[graphical_lasso] Iteration % 3i, cost % 3.2e, dual gap %.3e"
+                    % (i, cost, d_gap)
+                )
+            costs.append((cost, d_gap))
+            if np.abs(d_gap) < tol:
+                break
+            if not np.isfinite(cost) and i > 0:
+                raise FloatingPointError(
+                    "Non SPD result: the system is too ill-conditioned for this solver"
+                )
+        else:
+            warnings.warn(
+                "graphical_lasso: did not converge after %i iteration: dual gap: %.3e"
+                % (max_iter, d_gap),
+                ConvergenceWarning,
+            )
+    except FloatingPointError as e:
+        e.args = (e.args[0] + ". The system is too ill-conditioned for this solver",)
+        raise e
+
+    return covariance_, precision_, costs, i + 1
+
+
+def alpha_max(emp_cov):
+    """Find the maximum alpha for which there are some non-zeros off-diagonal.
+
+    Parameters
+    ----------
+    emp_cov : ndarray of shape (n_features, n_features)
+        The sample covariance matrix.
+
+    Notes
+    -----
+    This results from the bound for the all the Lasso that are solved
+    in GraphicalLasso: each time, the row of cov corresponds to Xy. As the
+    bound for alpha is given by `max(abs(Xy))`, the result follows.
+    """
+    A = np.copy(emp_cov)
+    A.flat[:: A.shape[0] + 1] = 0
+    return np.max(np.abs(A))
+
+
+@validate_params(
+    {
+        "emp_cov": ["array-like"],
+        "return_costs": ["boolean"],
+        "return_n_iter": ["boolean"],
+    },
+    prefer_skip_nested_validation=False,
+)
+def graphical_lasso(
+    emp_cov,
+    alpha,
+    *,
+    mode="cd",
+    tol=1e-4,
+    enet_tol=1e-4,
+    max_iter=100,
+    verbose=False,
+    return_costs=False,
+    eps=np.finfo(np.float64).eps,
+    return_n_iter=False,
+):
+    """L1-penalized covariance estimator.
+
+    Read more in the :ref:`User Guide <sparse_inverse_covariance>`.
+
+    .. versionchanged:: v0.20
+        graph_lasso has been renamed to graphical_lasso
+
+    Parameters
+    ----------
+    emp_cov : array-like of shape (n_features, n_features)
+        Empirical covariance from which to compute the covariance estimate.
+
+    alpha : float
+        The regularization parameter: the higher alpha, the more
+        regularization, the sparser the inverse covariance.
+        Range is (0, inf].
+
+    mode : {'cd', 'lars'}, default='cd'
+        The Lasso solver to use: coordinate descent or LARS. Use LARS for
+        very sparse underlying graphs, where p > n. Elsewhere prefer cd
+        which is more numerically stable.
+
+    tol : float, default=1e-4
+        The tolerance to declare convergence: if the dual gap goes below
+        this value, iterations are stopped. Range is (0, inf].
+
+    enet_tol : float, default=1e-4
+        The tolerance for the elastic net solver used to calculate the descent
+        direction. This parameter controls the accuracy of the search direction
+        for a given column update, not of the overall parameter estimate. Only
+        used for mode='cd'. Range is (0, inf].
+
+    max_iter : int, default=100
+        The maximum number of iterations.
+
+    verbose : bool, default=False
+        If verbose is True, the objective function and dual gap are
+        printed at each iteration.
+
+    return_costs : bool, default=False
+        If return_costs is True, the objective function and dual gap
+        at each iteration are returned.
+
+    eps : float, default=eps
+        The machine-precision regularization in the computation of the
+        Cholesky diagonal factors. Increase this for very ill-conditioned
+        systems. Default is `np.finfo(np.float64).eps`.
+
+    return_n_iter : bool, default=False
+        Whether or not to return the number of iterations.
+
+    Returns
+    -------
+    covariance : ndarray of shape (n_features, n_features)
+        The estimated covariance matrix.
+
+    precision : ndarray of shape (n_features, n_features)
+        The estimated (sparse) precision matrix.
+
+    costs : list of (objective, dual_gap) pairs
+        The list of values of the objective function and the dual gap at
+        each iteration. Returned only if return_costs is True.
+
+    n_iter : int
+        Number of iterations. Returned only if `return_n_iter` is set to True.
+
+    See Also
+    --------
+    GraphicalLasso : Sparse inverse covariance estimation
+        with an l1-penalized estimator.
+    GraphicalLassoCV : Sparse inverse covariance with
+        cross-validated choice of the l1 penalty.
+
+    Notes
+    -----
+    The algorithm employed to solve this problem is the GLasso algorithm,
+    from the Friedman 2008 Biostatistics paper. It is the same algorithm
+    as in the R `glasso` package.
+
+    One possible difference with the `glasso` R package is that the
+    diagonal coefficients are not penalized.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.datasets import make_sparse_spd_matrix
+    >>> from sklearn.covariance import empirical_covariance, graphical_lasso
+    >>> true_cov = make_sparse_spd_matrix(n_dim=3,random_state=42)
+    >>> rng = np.random.RandomState(42)
+    >>> X = rng.multivariate_normal(mean=np.zeros(3), cov=true_cov, size=3)
+    >>> emp_cov = empirical_covariance(X, assume_centered=True)
+    >>> emp_cov, _ = graphical_lasso(emp_cov, alpha=0.05)
+    >>> emp_cov
+    array([[ 1.68...,  0.21..., -0.20...],
+           [ 0.21...,  0.22..., -0.08...],
+           [-0.20..., -0.08...,  0.23...]])
+    """
+    model = GraphicalLasso(
+        alpha=alpha,
+        mode=mode,
+        covariance="precomputed",
+        tol=tol,
+        enet_tol=enet_tol,
+        max_iter=max_iter,
+        verbose=verbose,
+        eps=eps,
+        assume_centered=True,
+    ).fit(emp_cov)
+
+    output = [model.covariance_, model.precision_]
+    if return_costs:
+        output.append(model.costs_)
+    if return_n_iter:
+        output.append(model.n_iter_)
+    return tuple(output)
+
+
+class BaseGraphicalLasso(EmpiricalCovariance):
+    _parameter_constraints: dict = {
+        **EmpiricalCovariance._parameter_constraints,
+        "tol": [Interval(Real, 0, None, closed="right")],
+        "enet_tol": [Interval(Real, 0, None, closed="right")],
+        "max_iter": [Interval(Integral, 0, None, closed="left")],
+        "mode": [StrOptions({"cd", "lars"})],
+        "verbose": ["verbose"],
+        "eps": [Interval(Real, 0, None, closed="both")],
+    }
+    _parameter_constraints.pop("store_precision")
+
+    def __init__(
+        self,
+        tol=1e-4,
+        enet_tol=1e-4,
+        max_iter=100,
+        mode="cd",
+        verbose=False,
+        eps=np.finfo(np.float64).eps,
+        assume_centered=False,
+    ):
+        super().__init__(assume_centered=assume_centered)
+        self.tol = tol
+        self.enet_tol = enet_tol
+        self.max_iter = max_iter
+        self.mode = mode
+        self.verbose = verbose
+        self.eps = eps
+
+
+class GraphicalLasso(BaseGraphicalLasso):
+    """Sparse inverse covariance estimation with an l1-penalized estimator.
+
+    For a usage example see
+    :ref:`sphx_glr_auto_examples_applications_plot_stock_market.py`.
+
+    Read more in the :ref:`User Guide <sparse_inverse_covariance>`.
+
+    .. versionchanged:: v0.20
+        GraphLasso has been renamed to GraphicalLasso
+
+    Parameters
+    ----------
+    alpha : float, default=0.01
+        The regularization parameter: the higher alpha, the more
+        regularization, the sparser the inverse covariance.
+        Range is (0, inf].
+
+    mode : {'cd', 'lars'}, default='cd'
+        The Lasso solver to use: coordinate descent or LARS. Use LARS for
+        very sparse underlying graphs, where p > n. Elsewhere prefer cd
+        which is more numerically stable.
+
+    covariance : "precomputed", default=None
+        If covariance is "precomputed", the input data in `fit` is assumed
+        to be the covariance matrix. If `None`, the empirical covariance
+        is estimated from the data `X`.
+
+        .. versionadded:: 1.3
+
+    tol : float, default=1e-4
+        The tolerance to declare convergence: if the dual gap goes below
+        this value, iterations are stopped. Range is (0, inf].
+
+    enet_tol : float, default=1e-4
+        The tolerance for the elastic net solver used to calculate the descent
+        direction. This parameter controls the accuracy of the search direction
+        for a given column update, not of the overall parameter estimate. Only
+        used for mode='cd'. Range is (0, inf].
+
+    max_iter : int, default=100
+        The maximum number of iterations.
+
+    verbose : bool, default=False
+        If verbose is True, the objective function and dual gap are
+        plotted at each iteration.
+
+    eps : float, default=eps
+        The machine-precision regularization in the computation of the
+        Cholesky diagonal factors. Increase this for very ill-conditioned
+        systems. Default is `np.finfo(np.float64).eps`.
+
+        .. versionadded:: 1.3
+
+    assume_centered : bool, default=False
+        If True, data are not centered before computation.
+        Useful when working with data whose mean is almost, but not exactly
+        zero.
+        If False, data are centered before computation.
+
+    Attributes
+    ----------
+    location_ : ndarray of shape (n_features,)
+        Estimated location, i.e. the estimated mean.
+
+    covariance_ : ndarray of shape (n_features, n_features)
+        Estimated covariance matrix
+
+    precision_ : ndarray of shape (n_features, n_features)
+        Estimated pseudo inverse matrix.
+
+    n_iter_ : int
+        Number of iterations run.
+
+    costs_ : list of (objective, dual_gap) pairs
+        The list of values of the objective function and the dual gap at
+        each iteration. Returned only if return_costs is True.
+
+        .. versionadded:: 1.3
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    graphical_lasso : L1-penalized covariance estimator.
+    GraphicalLassoCV : Sparse inverse covariance with
+        cross-validated choice of the l1 penalty.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.covariance import GraphicalLasso
+    >>> true_cov = np.array([[0.8, 0.0, 0.2, 0.0],
+    ...                      [0.0, 0.4, 0.0, 0.0],
+    ...                      [0.2, 0.0, 0.3, 0.1],
+    ...                      [0.0, 0.0, 0.1, 0.7]])
+    >>> np.random.seed(0)
+    >>> X = np.random.multivariate_normal(mean=[0, 0, 0, 0],
+    ...                                   cov=true_cov,
+    ...                                   size=200)
+    >>> cov = GraphicalLasso().fit(X)
+    >>> np.around(cov.covariance_, decimals=3)
+    array([[0.816, 0.049, 0.218, 0.019],
+           [0.049, 0.364, 0.017, 0.034],
+           [0.218, 0.017, 0.322, 0.093],
+           [0.019, 0.034, 0.093, 0.69 ]])
+    >>> np.around(cov.location_, decimals=3)
+    array([0.073, 0.04 , 0.038, 0.143])
+    """
+
+    _parameter_constraints: dict = {
+        **BaseGraphicalLasso._parameter_constraints,
+        "alpha": [Interval(Real, 0, None, closed="both")],
+        "covariance": [StrOptions({"precomputed"}), None],
+    }
+
+    def __init__(
+        self,
+        alpha=0.01,
+        *,
+        mode="cd",
+        covariance=None,
+        tol=1e-4,
+        enet_tol=1e-4,
+        max_iter=100,
+        verbose=False,
+        eps=np.finfo(np.float64).eps,
+        assume_centered=False,
+    ):
+        super().__init__(
+            tol=tol,
+            enet_tol=enet_tol,
+            max_iter=max_iter,
+            mode=mode,
+            verbose=verbose,
+            eps=eps,
+            assume_centered=assume_centered,
+        )
+        self.alpha = alpha
+        self.covariance = covariance
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit the GraphicalLasso model to X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Data from which to compute the covariance estimate.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        # Covariance does not make sense for a single feature
+        X = validate_data(self, X, ensure_min_features=2, ensure_min_samples=2)
+
+        if self.covariance == "precomputed":
+            emp_cov = X.copy()
+            self.location_ = np.zeros(X.shape[1])
+        else:
+            emp_cov = empirical_covariance(X, assume_centered=self.assume_centered)
+            if self.assume_centered:
+                self.location_ = np.zeros(X.shape[1])
+            else:
+                self.location_ = X.mean(0)
+
+        self.covariance_, self.precision_, self.costs_, self.n_iter_ = _graphical_lasso(
+            emp_cov,
+            alpha=self.alpha,
+            cov_init=None,
+            mode=self.mode,
+            tol=self.tol,
+            enet_tol=self.enet_tol,
+            max_iter=self.max_iter,
+            verbose=self.verbose,
+            eps=self.eps,
+        )
+        return self
+
+
+# Cross-validation with GraphicalLasso
+def graphical_lasso_path(
+    X,
+    alphas,
+    cov_init=None,
+    X_test=None,
+    mode="cd",
+    tol=1e-4,
+    enet_tol=1e-4,
+    max_iter=100,
+    verbose=False,
+    eps=np.finfo(np.float64).eps,
+):
+    """l1-penalized covariance estimator along a path of decreasing alphas
+
+    Read more in the :ref:`User Guide <sparse_inverse_covariance>`.
+
+    Parameters
+    ----------
+    X : ndarray of shape (n_samples, n_features)
+        Data from which to compute the covariance estimate.
+
+    alphas : array-like of shape (n_alphas,)
+        The list of regularization parameters, decreasing order.
+
+    cov_init : array of shape (n_features, n_features), default=None
+        The initial guess for the covariance.
+
+    X_test : array of shape (n_test_samples, n_features), default=None
+        Optional test matrix to measure generalisation error.
+
+    mode : {'cd', 'lars'}, default='cd'
+        The Lasso solver to use: coordinate descent or LARS. Use LARS for
+        very sparse underlying graphs, where p > n. Elsewhere prefer cd
+        which is more numerically stable.
+
+    tol : float, default=1e-4
+        The tolerance to declare convergence: if the dual gap goes below
+        this value, iterations are stopped. The tolerance must be a positive
+        number.
+
+    enet_tol : float, default=1e-4
+        The tolerance for the elastic net solver used to calculate the descent
+        direction. This parameter controls the accuracy of the search direction
+        for a given column update, not of the overall parameter estimate. Only
+        used for mode='cd'. The tolerance must be a positive number.
+
+    max_iter : int, default=100
+        The maximum number of iterations. This parameter should be a strictly
+        positive integer.
+
+    verbose : int or bool, default=False
+        The higher the verbosity flag, the more information is printed
+        during the fitting.
+
+    eps : float, default=eps
+        The machine-precision regularization in the computation of the
+        Cholesky diagonal factors. Increase this for very ill-conditioned
+        systems. Default is `np.finfo(np.float64).eps`.
+
+        .. versionadded:: 1.3
+
+    Returns
+    -------
+    covariances_ : list of shape (n_alphas,) of ndarray of shape \
+            (n_features, n_features)
+        The estimated covariance matrices.
+
+    precisions_ : list of shape (n_alphas,) of ndarray of shape \
+            (n_features, n_features)
+        The estimated (sparse) precision matrices.
+
+    scores_ : list of shape (n_alphas,), dtype=float
+        The generalisation error (log-likelihood) on the test data.
+        Returned only if test data is passed.
+    """
+    inner_verbose = max(0, verbose - 1)
+    emp_cov = empirical_covariance(X)
+    if cov_init is None:
+        covariance_ = emp_cov.copy()
+    else:
+        covariance_ = cov_init
+    covariances_ = list()
+    precisions_ = list()
+    scores_ = list()
+    if X_test is not None:
+        test_emp_cov = empirical_covariance(X_test)
+
+    for alpha in alphas:
+        try:
+            # Capture the errors, and move on
+            covariance_, precision_, _, _ = _graphical_lasso(
+                emp_cov,
+                alpha=alpha,
+                cov_init=covariance_,
+                mode=mode,
+                tol=tol,
+                enet_tol=enet_tol,
+                max_iter=max_iter,
+                verbose=inner_verbose,
+                eps=eps,
+            )
+            covariances_.append(covariance_)
+            precisions_.append(precision_)
+            if X_test is not None:
+                this_score = log_likelihood(test_emp_cov, precision_)
+        except FloatingPointError:
+            this_score = -np.inf
+            covariances_.append(np.nan)
+            precisions_.append(np.nan)
+        if X_test is not None:
+            if not np.isfinite(this_score):
+                this_score = -np.inf
+            scores_.append(this_score)
+        if verbose == 1:
+            sys.stderr.write(".")
+        elif verbose > 1:
+            if X_test is not None:
+                print(
+                    "[graphical_lasso_path] alpha: %.2e, score: %.2e"
+                    % (alpha, this_score)
+                )
+            else:
+                print("[graphical_lasso_path] alpha: %.2e" % alpha)
+    if X_test is not None:
+        return covariances_, precisions_, scores_
+    return covariances_, precisions_
+
+
+class GraphicalLassoCV(BaseGraphicalLasso):
+    """Sparse inverse covariance w/ cross-validated choice of the l1 penalty.
+
+    See glossary entry for :term:`cross-validation estimator`.
+
+    Read more in the :ref:`User Guide <sparse_inverse_covariance>`.
+
+    .. versionchanged:: v0.20
+        GraphLassoCV has been renamed to GraphicalLassoCV
+
+    Parameters
+    ----------
+    alphas : int or array-like of shape (n_alphas,), dtype=float, default=4
+        If an integer is given, it fixes the number of points on the
+        grids of alpha to be used. If a list is given, it gives the
+        grid to be used. See the notes in the class docstring for
+        more details. Range is [1, inf) for an integer.
+        Range is (0, inf] for an array-like of floats.
+
+    n_refinements : int, default=4
+        The number of times the grid is refined. Not used if explicit
+        values of alphas are passed. Range is [1, inf).
+
+    cv : int, cross-validation generator or iterable, default=None
+        Determines the cross-validation splitting strategy.
+        Possible inputs for cv are:
+
+        - None, to use the default 5-fold cross-validation,
+        - integer, to specify the number of folds.
+        - :term:`CV splitter`,
+        - An iterable yielding (train, test) splits as arrays of indices.
+
+        For integer/None inputs :class:`~sklearn.model_selection.KFold` is used.
+
+        Refer :ref:`User Guide <cross_validation>` for the various
+        cross-validation strategies that can be used here.
+
+        .. versionchanged:: 0.20
+            ``cv`` default value if None changed from 3-fold to 5-fold.
+
+    tol : float, default=1e-4
+        The tolerance to declare convergence: if the dual gap goes below
+        this value, iterations are stopped. Range is (0, inf].
+
+    enet_tol : float, default=1e-4
+        The tolerance for the elastic net solver used to calculate the descent
+        direction. This parameter controls the accuracy of the search direction
+        for a given column update, not of the overall parameter estimate. Only
+        used for mode='cd'. Range is (0, inf].
+
+    max_iter : int, default=100
+        Maximum number of iterations.
+
+    mode : {'cd', 'lars'}, default='cd'
+        The Lasso solver to use: coordinate descent or LARS. Use LARS for
+        very sparse underlying graphs, where number of features is greater
+        than number of samples. Elsewhere prefer cd which is more numerically
+        stable.
+
+    n_jobs : int, default=None
+        Number of jobs to run in parallel.
+        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
+        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
+        for more details.
+
+        .. versionchanged:: v0.20
+           `n_jobs` default changed from 1 to None
+
+    verbose : bool, default=False
+        If verbose is True, the objective function and duality gap are
+        printed at each iteration.
+
+    eps : float, default=eps
+        The machine-precision regularization in the computation of the
+        Cholesky diagonal factors. Increase this for very ill-conditioned
+        systems. Default is `np.finfo(np.float64).eps`.
+
+        .. versionadded:: 1.3
+
+    assume_centered : bool, default=False
+        If True, data are not centered before computation.
+        Useful when working with data whose mean is almost, but not exactly
+        zero.
+        If False, data are centered before computation.
+
+    Attributes
+    ----------
+    location_ : ndarray of shape (n_features,)
+        Estimated location, i.e. the estimated mean.
+
+    covariance_ : ndarray of shape (n_features, n_features)
+        Estimated covariance matrix.
+
+    precision_ : ndarray of shape (n_features, n_features)
+        Estimated precision matrix (inverse covariance).
+
+    costs_ : list of (objective, dual_gap) pairs
+        The list of values of the objective function and the dual gap at
+        each iteration. Returned only if return_costs is True.
+
+        .. versionadded:: 1.3
+
+    alpha_ : float
+        Penalization parameter selected.
+
+    cv_results_ : dict of ndarrays
+        A dict with keys:
+
+        alphas : ndarray of shape (n_alphas,)
+            All penalization parameters explored.
+
+        split(k)_test_score : ndarray of shape (n_alphas,)
+            Log-likelihood score on left-out data across (k)th fold.
+
+            .. versionadded:: 1.0
+
+        mean_test_score : ndarray of shape (n_alphas,)
+            Mean of scores over the folds.
+
+            .. versionadded:: 1.0
+
+        std_test_score : ndarray of shape (n_alphas,)
+            Standard deviation of scores over the folds.
+
+            .. versionadded:: 1.0
+
+    n_iter_ : int
+        Number of iterations run for the optimal alpha.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    graphical_lasso : L1-penalized covariance estimator.
+    GraphicalLasso : Sparse inverse covariance estimation
+        with an l1-penalized estimator.
+
+    Notes
+    -----
+    The search for the optimal penalization parameter (`alpha`) is done on an
+    iteratively refined grid: first the cross-validated scores on a grid are
+    computed, then a new refined grid is centered around the maximum, and so
+    on.
+
+    One of the challenges which is faced here is that the solvers can
+    fail to converge to a well-conditioned estimate. The corresponding
+    values of `alpha` then come out as missing values, but the optimum may
+    be close to these missing values.
+
+    In `fit`, once the best parameter `alpha` is found through
+    cross-validation, the model is fit again using the entire training set.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.covariance import GraphicalLassoCV
+    >>> true_cov = np.array([[0.8, 0.0, 0.2, 0.0],
+    ...                      [0.0, 0.4, 0.0, 0.0],
+    ...                      [0.2, 0.0, 0.3, 0.1],
+    ...                      [0.0, 0.0, 0.1, 0.7]])
+    >>> np.random.seed(0)
+    >>> X = np.random.multivariate_normal(mean=[0, 0, 0, 0],
+    ...                                   cov=true_cov,
+    ...                                   size=200)
+    >>> cov = GraphicalLassoCV().fit(X)
+    >>> np.around(cov.covariance_, decimals=3)
+    array([[0.816, 0.051, 0.22 , 0.017],
+           [0.051, 0.364, 0.018, 0.036],
+           [0.22 , 0.018, 0.322, 0.094],
+           [0.017, 0.036, 0.094, 0.69 ]])
+    >>> np.around(cov.location_, decimals=3)
+    array([0.073, 0.04 , 0.038, 0.143])
+    """
+
+    _parameter_constraints: dict = {
+        **BaseGraphicalLasso._parameter_constraints,
+        "alphas": [Interval(Integral, 0, None, closed="left"), "array-like"],
+        "n_refinements": [Interval(Integral, 1, None, closed="left")],
+        "cv": ["cv_object"],
+        "n_jobs": [Integral, None],
+    }
+
+    def __init__(
+        self,
+        *,
+        alphas=4,
+        n_refinements=4,
+        cv=None,
+        tol=1e-4,
+        enet_tol=1e-4,
+        max_iter=100,
+        mode="cd",
+        n_jobs=None,
+        verbose=False,
+        eps=np.finfo(np.float64).eps,
+        assume_centered=False,
+    ):
+        super().__init__(
+            tol=tol,
+            enet_tol=enet_tol,
+            max_iter=max_iter,
+            mode=mode,
+            verbose=verbose,
+            eps=eps,
+            assume_centered=assume_centered,
+        )
+        self.alphas = alphas
+        self.n_refinements = n_refinements
+        self.cv = cv
+        self.n_jobs = n_jobs
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None, **params):
+        """Fit the GraphicalLasso covariance model to X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Data from which to compute the covariance estimate.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        **params : dict, default=None
+            Parameters to be passed to the CV splitter and the
+            cross_val_score function.
+
+            .. versionadded:: 1.5
+                Only available if `enable_metadata_routing=True`,
+                which can be set by using
+                ``sklearn.set_config(enable_metadata_routing=True)``.
+                See :ref:`Metadata Routing User Guide <metadata_routing>` for
+                more details.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        # Covariance does not make sense for a single feature
+        _raise_for_params(params, self, "fit")
+
+        X = validate_data(self, X, ensure_min_features=2)
+        if self.assume_centered:
+            self.location_ = np.zeros(X.shape[1])
+        else:
+            self.location_ = X.mean(0)
+        emp_cov = empirical_covariance(X, assume_centered=self.assume_centered)
+
+        cv = check_cv(self.cv, y, classifier=False)
+
+        # List of (alpha, scores, covs)
+        path = list()
+        n_alphas = self.alphas
+        inner_verbose = max(0, self.verbose - 1)
+
+        if _is_arraylike_not_scalar(n_alphas):
+            for alpha in self.alphas:
+                check_scalar(
+                    alpha,
+                    "alpha",
+                    Real,
+                    min_val=0,
+                    max_val=np.inf,
+                    include_boundaries="right",
+                )
+            alphas = self.alphas
+            n_refinements = 1
+        else:
+            n_refinements = self.n_refinements
+            alpha_1 = alpha_max(emp_cov)
+            alpha_0 = 1e-2 * alpha_1
+            alphas = np.logspace(np.log10(alpha_0), np.log10(alpha_1), n_alphas)[::-1]
+
+        if _routing_enabled():
+            routed_params = process_routing(self, "fit", **params)
+        else:
+            routed_params = Bunch(splitter=Bunch(split={}))
+
+        t0 = time.time()
+        for i in range(n_refinements):
+            with warnings.catch_warnings():
+                # No need to see the convergence warnings on this grid:
+                # they will always be points that will not converge
+                # during the cross-validation
+                warnings.simplefilter("ignore", ConvergenceWarning)
+                # Compute the cross-validated loss on the current grid
+
+                # NOTE: Warm-restarting graphical_lasso_path has been tried,
+                # and this did not allow to gain anything
+                # (same execution time with or without).
+                this_path = Parallel(n_jobs=self.n_jobs, verbose=self.verbose)(
+                    delayed(graphical_lasso_path)(
+                        X[train],
+                        alphas=alphas,
+                        X_test=X[test],
+                        mode=self.mode,
+                        tol=self.tol,
+                        enet_tol=self.enet_tol,
+                        max_iter=int(0.1 * self.max_iter),
+                        verbose=inner_verbose,
+                        eps=self.eps,
+                    )
+                    for train, test in cv.split(X, y, **routed_params.splitter.split)
+                )
+
+            # Little danse to transform the list in what we need
+            covs, _, scores = zip(*this_path)
+            covs = zip(*covs)
+            scores = zip(*scores)
+            path.extend(zip(alphas, scores, covs))
+            path = sorted(path, key=operator.itemgetter(0), reverse=True)
+
+            # Find the maximum (avoid using built in 'max' function to
+            # have a fully-reproducible selection of the smallest alpha
+            # in case of equality)
+            best_score = -np.inf
+            last_finite_idx = 0
+            for index, (alpha, scores, _) in enumerate(path):
+                this_score = np.mean(scores)
+                if this_score >= 0.1 / np.finfo(np.float64).eps:
+                    this_score = np.nan
+                if np.isfinite(this_score):
+                    last_finite_idx = index
+                if this_score >= best_score:
+                    best_score = this_score
+                    best_index = index
+
+            # Refine the grid
+            if best_index == 0:
+                # We do not need to go back: we have chosen
+                # the highest value of alpha for which there are
+                # non-zero coefficients
+                alpha_1 = path[0][0]
+                alpha_0 = path[1][0]
+            elif best_index == last_finite_idx and not best_index == len(path) - 1:
+                # We have non-converged models on the upper bound of the
+                # grid, we need to refine the grid there
+                alpha_1 = path[best_index][0]
+                alpha_0 = path[best_index + 1][0]
+            elif best_index == len(path) - 1:
+                alpha_1 = path[best_index][0]
+                alpha_0 = 0.01 * path[best_index][0]
+            else:
+                alpha_1 = path[best_index - 1][0]
+                alpha_0 = path[best_index + 1][0]
+
+            if not _is_arraylike_not_scalar(n_alphas):
+                alphas = np.logspace(np.log10(alpha_1), np.log10(alpha_0), n_alphas + 2)
+                alphas = alphas[1:-1]
+
+            if self.verbose and n_refinements > 1:
+                print(
+                    "[GraphicalLassoCV] Done refinement % 2i out of %i: % 3is"
+                    % (i + 1, n_refinements, time.time() - t0)
+                )
+
+        path = list(zip(*path))
+        grid_scores = list(path[1])
+        alphas = list(path[0])
+        # Finally, compute the score with alpha = 0
+        alphas.append(0)
+        grid_scores.append(
+            cross_val_score(
+                EmpiricalCovariance(),
+                X,
+                cv=cv,
+                n_jobs=self.n_jobs,
+                verbose=inner_verbose,
+                params=params,
+            )
+        )
+        grid_scores = np.array(grid_scores)
+
+        self.cv_results_ = {"alphas": np.array(alphas)}
+
+        for i in range(grid_scores.shape[1]):
+            self.cv_results_[f"split{i}_test_score"] = grid_scores[:, i]
+
+        self.cv_results_["mean_test_score"] = np.mean(grid_scores, axis=1)
+        self.cv_results_["std_test_score"] = np.std(grid_scores, axis=1)
+
+        best_alpha = alphas[best_index]
+        self.alpha_ = best_alpha
+
+        # Finally fit the model with the selected alpha
+        self.covariance_, self.precision_, self.costs_, self.n_iter_ = _graphical_lasso(
+            emp_cov,
+            alpha=best_alpha,
+            mode=self.mode,
+            tol=self.tol,
+            enet_tol=self.enet_tol,
+            max_iter=self.max_iter,
+            verbose=inner_verbose,
+            eps=self.eps,
+        )
+        return self
+
+    def get_metadata_routing(self):
+        """Get metadata routing of this object.
+
+        Please check :ref:`User Guide <metadata_routing>` on how the routing
+        mechanism works.
+
+        .. versionadded:: 1.5
+
+        Returns
+        -------
+        routing : MetadataRouter
+            A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating
+            routing information.
+        """
+        router = MetadataRouter(owner=self.__class__.__name__).add(
+            splitter=check_cv(self.cv),
+            method_mapping=MethodMapping().add(callee="split", caller="fit"),
+        )
+        return router

evalkit_tf437/lib/python3.10/site-packages/sklearn/covariance/_robust_covariance.py

@@ -0,0 +1,870 @@
+"""
+Robust location and covariance estimators.
+
+Here are implemented estimators that are resistant to outliers.
+
+"""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import warnings
+from numbers import Integral, Real
+
+import numpy as np
+from scipy import linalg
+from scipy.stats import chi2
+
+from ..base import _fit_context
+from ..utils import check_array, check_random_state
+from ..utils._param_validation import Interval
+from ..utils.extmath import fast_logdet
+from ..utils.validation import validate_data
+from ._empirical_covariance import EmpiricalCovariance, empirical_covariance
+
+
+# Minimum Covariance Determinant
+#   Implementing of an algorithm by Rousseeuw & Van Driessen described in
+#   (A Fast Algorithm for the Minimum Covariance Determinant Estimator,
+#   1999, American Statistical Association and the American Society
+#   for Quality, TECHNOMETRICS)
+# XXX Is this really a public function? It's not listed in the docs or
+# exported by sklearn.covariance. Deprecate?
+def c_step(
+    X,
+    n_support,
+    remaining_iterations=30,
+    initial_estimates=None,
+    verbose=False,
+    cov_computation_method=empirical_covariance,
+    random_state=None,
+):
+    """C_step procedure described in [Rouseeuw1984]_ aiming at computing MCD.
+
+    Parameters
+    ----------
+    X : array-like of shape (n_samples, n_features)
+        Data set in which we look for the n_support observations whose
+        scatter matrix has minimum determinant.
+
+    n_support : int
+        Number of observations to compute the robust estimates of location
+        and covariance from. This parameter must be greater than
+        `n_samples / 2`.
+
+    remaining_iterations : int, default=30
+        Number of iterations to perform.
+        According to [Rouseeuw1999]_, two iterations are sufficient to get
+        close to the minimum, and we never need more than 30 to reach
+        convergence.
+
+    initial_estimates : tuple of shape (2,), default=None
+        Initial estimates of location and shape from which to run the c_step
+        procedure:
+        - initial_estimates[0]: an initial location estimate
+        - initial_estimates[1]: an initial covariance estimate
+
+    verbose : bool, default=False
+        Verbose mode.
+
+    cov_computation_method : callable, \
+            default=:func:`sklearn.covariance.empirical_covariance`
+        The function which will be used to compute the covariance.
+        Must return array of shape (n_features, n_features).
+
+    random_state : int, RandomState instance or None, default=None
+        Determines the pseudo random number generator for shuffling the data.
+        Pass an int for reproducible results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    Returns
+    -------
+    location : ndarray of shape (n_features,)
+        Robust location estimates.
+
+    covariance : ndarray of shape (n_features, n_features)
+        Robust covariance estimates.
+
+    support : ndarray of shape (n_samples,)
+        A mask for the `n_support` observations whose scatter matrix has
+        minimum determinant.
+
+    References
+    ----------
+    .. [Rouseeuw1999] A Fast Algorithm for the Minimum Covariance Determinant
+        Estimator, 1999, American Statistical Association and the American
+        Society for Quality, TECHNOMETRICS
+    """
+    X = np.asarray(X)
+    random_state = check_random_state(random_state)
+    return _c_step(
+        X,
+        n_support,
+        remaining_iterations=remaining_iterations,
+        initial_estimates=initial_estimates,
+        verbose=verbose,
+        cov_computation_method=cov_computation_method,
+        random_state=random_state,
+    )
+
+
+def _c_step(
+    X,
+    n_support,
+    random_state,
+    remaining_iterations=30,
+    initial_estimates=None,
+    verbose=False,
+    cov_computation_method=empirical_covariance,
+):
+    n_samples, n_features = X.shape
+    dist = np.inf
+
+    # Initialisation
+    if initial_estimates is None:
+        # compute initial robust estimates from a random subset
+        support_indices = random_state.permutation(n_samples)[:n_support]
+    else:
+        # get initial robust estimates from the function parameters
+        location = initial_estimates[0]
+        covariance = initial_estimates[1]
+        # run a special iteration for that case (to get an initial support_indices)
+        precision = linalg.pinvh(covariance)
+        X_centered = X - location
+        dist = (np.dot(X_centered, precision) * X_centered).sum(1)
+        # compute new estimates
+        support_indices = np.argpartition(dist, n_support - 1)[:n_support]
+
+    X_support = X[support_indices]
+    location = X_support.mean(0)
+    covariance = cov_computation_method(X_support)
+
+    # Iterative procedure for Minimum Covariance Determinant computation
+    det = fast_logdet(covariance)
+    # If the data already has singular covariance, calculate the precision,
+    # as the loop below will not be entered.
+    if np.isinf(det):
+        precision = linalg.pinvh(covariance)
+
+    previous_det = np.inf
+    while det < previous_det and remaining_iterations > 0 and not np.isinf(det):
+        # save old estimates values
+        previous_location = location
+        previous_covariance = covariance
+        previous_det = det
+        previous_support_indices = support_indices
+        # compute a new support_indices from the full data set mahalanobis distances
+        precision = linalg.pinvh(covariance)
+        X_centered = X - location
+        dist = (np.dot(X_centered, precision) * X_centered).sum(axis=1)
+        # compute new estimates
+        support_indices = np.argpartition(dist, n_support - 1)[:n_support]
+        X_support = X[support_indices]
+        location = X_support.mean(axis=0)
+        covariance = cov_computation_method(X_support)
+        det = fast_logdet(covariance)
+        # update remaining iterations for early stopping
+        remaining_iterations -= 1
+
+    previous_dist = dist
+    dist = (np.dot(X - location, precision) * (X - location)).sum(axis=1)
+    # Check if best fit already found (det => 0, logdet => -inf)
+    if np.isinf(det):
+        results = location, covariance, det, support_indices, dist
+    # Check convergence
+    if np.allclose(det, previous_det):
+        # c_step procedure converged
+        if verbose:
+            print(
+                "Optimal couple (location, covariance) found before"
+                " ending iterations (%d left)" % (remaining_iterations)
+            )
+        results = location, covariance, det, support_indices, dist
+    elif det > previous_det:
+        # determinant has increased (should not happen)
+        warnings.warn(
+            "Determinant has increased; this should not happen: "
+            "log(det) > log(previous_det) (%.15f > %.15f). "
+            "You may want to try with a higher value of "
+            "support_fraction (current value: %.3f)."
+            % (det, previous_det, n_support / n_samples),
+            RuntimeWarning,
+        )
+        results = (
+            previous_location,
+            previous_covariance,
+            previous_det,
+            previous_support_indices,
+            previous_dist,
+        )
+
+    # Check early stopping
+    if remaining_iterations == 0:
+        if verbose:
+            print("Maximum number of iterations reached")
+        results = location, covariance, det, support_indices, dist
+
+    location, covariance, det, support_indices, dist = results
+    # Convert from list of indices to boolean mask.
+    support = np.bincount(support_indices, minlength=n_samples).astype(bool)
+    return location, covariance, det, support, dist
+
+
+def select_candidates(
+    X,
+    n_support,
+    n_trials,
+    select=1,
+    n_iter=30,
+    verbose=False,
+    cov_computation_method=empirical_covariance,
+    random_state=None,
+):
+    """Finds the best pure subset of observations to compute MCD from it.
+
+    The purpose of this function is to find the best sets of n_support
+    observations with respect to a minimization of their covariance
+    matrix determinant. Equivalently, it removes n_samples-n_support
+    observations to construct what we call a pure data set (i.e. not
+    containing outliers). The list of the observations of the pure
+    data set is referred to as the `support`.
+
+    Starting from a random support, the pure data set is found by the
+    c_step procedure introduced by Rousseeuw and Van Driessen in
+    [RV]_.
+
+    Parameters
+    ----------
+    X : array-like of shape (n_samples, n_features)
+        Data (sub)set in which we look for the n_support purest observations.
+
+    n_support : int
+        The number of samples the pure data set must contain.
+        This parameter must be in the range `[(n + p + 1)/2] < n_support < n`.
+
+    n_trials : int or tuple of shape (2,)
+        Number of different initial sets of observations from which to
+        run the algorithm. This parameter should be a strictly positive
+        integer.
+        Instead of giving a number of trials to perform, one can provide a
+        list of initial estimates that will be used to iteratively run
+        c_step procedures. In this case:
+        - n_trials[0]: array-like, shape (n_trials, n_features)
+          is the list of `n_trials` initial location estimates
+        - n_trials[1]: array-like, shape (n_trials, n_features, n_features)
+          is the list of `n_trials` initial covariances estimates
+
+    select : int, default=1
+        Number of best candidates results to return. This parameter must be
+        a strictly positive integer.
+
+    n_iter : int, default=30
+        Maximum number of iterations for the c_step procedure.
+        (2 is enough to be close to the final solution. "Never" exceeds 20).
+        This parameter must be a strictly positive integer.
+
+    verbose : bool, default=False
+        Control the output verbosity.
+
+    cov_computation_method : callable, \
+            default=:func:`sklearn.covariance.empirical_covariance`
+        The function which will be used to compute the covariance.
+        Must return an array of shape (n_features, n_features).
+
+    random_state : int, RandomState instance or None, default=None
+        Determines the pseudo random number generator for shuffling the data.
+        Pass an int for reproducible results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    See Also
+    ---------
+    c_step
+
+    Returns
+    -------
+    best_locations : ndarray of shape (select, n_features)
+        The `select` location estimates computed from the `select` best
+        supports found in the data set (`X`).
+
+    best_covariances : ndarray of shape (select, n_features, n_features)
+        The `select` covariance estimates computed from the `select`
+        best supports found in the data set (`X`).
+
+    best_supports : ndarray of shape (select, n_samples)
+        The `select` best supports found in the data set (`X`).
+
+    References
+    ----------
+    .. [RV] A Fast Algorithm for the Minimum Covariance Determinant
+        Estimator, 1999, American Statistical Association and the American
+        Society for Quality, TECHNOMETRICS
+    """
+    random_state = check_random_state(random_state)
+
+    if isinstance(n_trials, Integral):
+        run_from_estimates = False
+    elif isinstance(n_trials, tuple):
+        run_from_estimates = True
+        estimates_list = n_trials
+        n_trials = estimates_list[0].shape[0]
+    else:
+        raise TypeError(
+            "Invalid 'n_trials' parameter, expected tuple or  integer, got %s (%s)"
+            % (n_trials, type(n_trials))
+        )
+
+    # compute `n_trials` location and shape estimates candidates in the subset
+    all_estimates = []
+    if not run_from_estimates:
+        # perform `n_trials` computations from random initial supports
+        for j in range(n_trials):
+            all_estimates.append(
+                _c_step(
+                    X,
+                    n_support,
+                    remaining_iterations=n_iter,
+                    verbose=verbose,
+                    cov_computation_method=cov_computation_method,
+                    random_state=random_state,
+                )
+            )
+    else:
+        # perform computations from every given initial estimates
+        for j in range(n_trials):
+            initial_estimates = (estimates_list[0][j], estimates_list[1][j])
+            all_estimates.append(
+                _c_step(
+                    X,
+                    n_support,
+                    remaining_iterations=n_iter,
+                    initial_estimates=initial_estimates,
+                    verbose=verbose,
+                    cov_computation_method=cov_computation_method,
+                    random_state=random_state,
+                )
+            )
+    all_locs_sub, all_covs_sub, all_dets_sub, all_supports_sub, all_ds_sub = zip(
+        *all_estimates
+    )
+    # find the `n_best` best results among the `n_trials` ones
+    index_best = np.argsort(all_dets_sub)[:select]
+    best_locations = np.asarray(all_locs_sub)[index_best]
+    best_covariances = np.asarray(all_covs_sub)[index_best]
+    best_supports = np.asarray(all_supports_sub)[index_best]
+    best_ds = np.asarray(all_ds_sub)[index_best]
+
+    return best_locations, best_covariances, best_supports, best_ds
+
+
+def fast_mcd(
+    X,
+    support_fraction=None,
+    cov_computation_method=empirical_covariance,
+    random_state=None,
+):
+    """Estimate the Minimum Covariance Determinant matrix.
+
+    Read more in the :ref:`User Guide <robust_covariance>`.
+
+    Parameters
+    ----------
+    X : array-like of shape (n_samples, n_features)
+        The data matrix, with p features and n samples.
+
+    support_fraction : float, default=None
+        The proportion of points to be included in the support of the raw
+        MCD estimate. Default is `None`, which implies that the minimum
+        value of `support_fraction` will be used within the algorithm:
+        `(n_samples + n_features + 1) / 2 * n_samples`. This parameter must be
+        in the range (0, 1).
+
+    cov_computation_method : callable, \
+            default=:func:`sklearn.covariance.empirical_covariance`
+        The function which will be used to compute the covariance.
+        Must return an array of shape (n_features, n_features).
+
+    random_state : int, RandomState instance or None, default=None
+        Determines the pseudo random number generator for shuffling the data.
+        Pass an int for reproducible results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    Returns
+    -------
+    location : ndarray of shape (n_features,)
+        Robust location of the data.
+
+    covariance : ndarray of shape (n_features, n_features)
+        Robust covariance of the features.
+
+    support : ndarray of shape (n_samples,), dtype=bool
+        A mask of the observations that have been used to compute
+        the robust location and covariance estimates of the data set.
+
+    Notes
+    -----
+    The FastMCD algorithm has been introduced by Rousseuw and Van Driessen
+    in "A Fast Algorithm for the Minimum Covariance Determinant Estimator,
+    1999, American Statistical Association and the American Society
+    for Quality, TECHNOMETRICS".
+    The principle is to compute robust estimates and random subsets before
+    pooling them into a larger subsets, and finally into the full data set.
+    Depending on the size of the initial sample, we have one, two or three
+    such computation levels.
+
+    Note that only raw estimates are returned. If one is interested in
+    the correction and reweighting steps described in [RouseeuwVan]_,
+    see the MinCovDet object.
+
+    References
+    ----------
+
+    .. [RouseeuwVan] A Fast Algorithm for the Minimum Covariance
+        Determinant Estimator, 1999, American Statistical Association
+        and the American Society for Quality, TECHNOMETRICS
+
+    .. [Butler1993] R. W. Butler, P. L. Davies and M. Jhun,
+        Asymptotics For The Minimum Covariance Determinant Estimator,
+        The Annals of Statistics, 1993, Vol. 21, No. 3, 1385-1400
+    """
+    random_state = check_random_state(random_state)
+
+    X = check_array(X, ensure_min_samples=2, estimator="fast_mcd")
+    n_samples, n_features = X.shape
+
+    # minimum breakdown value
+    if support_fraction is None:
+        n_support = int(np.ceil(0.5 * (n_samples + n_features + 1)))
+    else:
+        n_support = int(support_fraction * n_samples)
+
+    # 1-dimensional case quick computation
+    # (Rousseeuw, P. J. and Leroy, A. M. (2005) References, in Robust
+    #  Regression and Outlier Detection, John Wiley & Sons, chapter 4)
+    if n_features == 1:
+        if n_support < n_samples:
+            # find the sample shortest halves
+            X_sorted = np.sort(np.ravel(X))
+            diff = X_sorted[n_support:] - X_sorted[: (n_samples - n_support)]
+            halves_start = np.where(diff == np.min(diff))[0]
+            # take the middle points' mean to get the robust location estimate
+            location = (
+                0.5
+                * (X_sorted[n_support + halves_start] + X_sorted[halves_start]).mean()
+            )
+            support = np.zeros(n_samples, dtype=bool)
+            X_centered = X - location
+            support[np.argsort(np.abs(X_centered), 0)[:n_support]] = True
+            covariance = np.asarray([[np.var(X[support])]])
+            location = np.array([location])
+            # get precision matrix in an optimized way
+            precision = linalg.pinvh(covariance)
+            dist = (np.dot(X_centered, precision) * (X_centered)).sum(axis=1)
+        else:
+            support = np.ones(n_samples, dtype=bool)
+            covariance = np.asarray([[np.var(X)]])
+            location = np.asarray([np.mean(X)])
+            X_centered = X - location
+            # get precision matrix in an optimized way
+            precision = linalg.pinvh(covariance)
+            dist = (np.dot(X_centered, precision) * (X_centered)).sum(axis=1)
+    # Starting FastMCD algorithm for p-dimensional case
+    if (n_samples > 500) and (n_features > 1):
+        # 1. Find candidate supports on subsets
+        # a. split the set in subsets of size ~ 300
+        n_subsets = n_samples // 300
+        n_samples_subsets = n_samples // n_subsets
+        samples_shuffle = random_state.permutation(n_samples)
+        h_subset = int(np.ceil(n_samples_subsets * (n_support / float(n_samples))))
+        # b. perform a total of 500 trials
+        n_trials_tot = 500
+        # c. select 10 best (location, covariance) for each subset
+        n_best_sub = 10
+        n_trials = max(10, n_trials_tot // n_subsets)
+        n_best_tot = n_subsets * n_best_sub
+        all_best_locations = np.zeros((n_best_tot, n_features))
+        try:
+            all_best_covariances = np.zeros((n_best_tot, n_features, n_features))
+        except MemoryError:
+            # The above is too big. Let's try with something much small
+            # (and less optimal)
+            n_best_tot = 10
+            all_best_covariances = np.zeros((n_best_tot, n_features, n_features))
+            n_best_sub = 2
+        for i in range(n_subsets):
+            low_bound = i * n_samples_subsets
+            high_bound = low_bound + n_samples_subsets
+            current_subset = X[samples_shuffle[low_bound:high_bound]]
+            best_locations_sub, best_covariances_sub, _, _ = select_candidates(
+                current_subset,
+                h_subset,
+                n_trials,
+                select=n_best_sub,
+                n_iter=2,
+                cov_computation_method=cov_computation_method,
+                random_state=random_state,
+            )
+            subset_slice = np.arange(i * n_best_sub, (i + 1) * n_best_sub)
+            all_best_locations[subset_slice] = best_locations_sub
+            all_best_covariances[subset_slice] = best_covariances_sub
+        # 2. Pool the candidate supports into a merged set
+        # (possibly the full dataset)
+        n_samples_merged = min(1500, n_samples)
+        h_merged = int(np.ceil(n_samples_merged * (n_support / float(n_samples))))
+        if n_samples > 1500:
+            n_best_merged = 10
+        else:
+            n_best_merged = 1
+        # find the best couples (location, covariance) on the merged set
+        selection = random_state.permutation(n_samples)[:n_samples_merged]
+        locations_merged, covariances_merged, supports_merged, d = select_candidates(
+            X[selection],
+            h_merged,
+            n_trials=(all_best_locations, all_best_covariances),
+            select=n_best_merged,
+            cov_computation_method=cov_computation_method,
+            random_state=random_state,
+        )
+        # 3. Finally get the overall best (locations, covariance) couple
+        if n_samples < 1500:
+            # directly get the best couple (location, covariance)
+            location = locations_merged[0]
+            covariance = covariances_merged[0]
+            support = np.zeros(n_samples, dtype=bool)
+            dist = np.zeros(n_samples)
+            support[selection] = supports_merged[0]
+            dist[selection] = d[0]
+        else:
+            # select the best couple on the full dataset
+            locations_full, covariances_full, supports_full, d = select_candidates(
+                X,
+                n_support,
+                n_trials=(locations_merged, covariances_merged),
+                select=1,
+                cov_computation_method=cov_computation_method,
+                random_state=random_state,
+            )
+            location = locations_full[0]
+            covariance = covariances_full[0]
+            support = supports_full[0]
+            dist = d[0]
+    elif n_features > 1:
+        # 1. Find the 10 best couples (location, covariance)
+        # considering two iterations
+        n_trials = 30
+        n_best = 10
+        locations_best, covariances_best, _, _ = select_candidates(
+            X,
+            n_support,
+            n_trials=n_trials,
+            select=n_best,
+            n_iter=2,
+            cov_computation_method=cov_computation_method,
+            random_state=random_state,
+        )
+        # 2. Select the best couple on the full dataset amongst the 10
+        locations_full, covariances_full, supports_full, d = select_candidates(
+            X,
+            n_support,
+            n_trials=(locations_best, covariances_best),
+            select=1,
+            cov_computation_method=cov_computation_method,
+            random_state=random_state,
+        )
+        location = locations_full[0]
+        covariance = covariances_full[0]
+        support = supports_full[0]
+        dist = d[0]
+
+    return location, covariance, support, dist
+
+
+class MinCovDet(EmpiricalCovariance):
+    """Minimum Covariance Determinant (MCD): robust estimator of covariance.
+
+    The Minimum Covariance Determinant covariance estimator is to be applied
+    on Gaussian-distributed data, but could still be relevant on data
+    drawn from a unimodal, symmetric distribution. It is not meant to be used
+    with multi-modal data (the algorithm used to fit a MinCovDet object is
+    likely to fail in such a case).
+    One should consider projection pursuit methods to deal with multi-modal
+    datasets.
+
+    Read more in the :ref:`User Guide <robust_covariance>`.
+
+    Parameters
+    ----------
+    store_precision : bool, default=True
+        Specify if the estimated precision is stored.
+
+    assume_centered : bool, default=False
+        If True, the support of the robust location and the covariance
+        estimates is computed, and a covariance estimate is recomputed from
+        it, without centering the data.
+        Useful to work with data whose mean is significantly equal to
+        zero but is not exactly zero.
+        If False, the robust location and covariance are directly computed
+        with the FastMCD algorithm without additional treatment.
+
+    support_fraction : float, default=None
+        The proportion of points to be included in the support of the raw
+        MCD estimate. Default is None, which implies that the minimum
+        value of support_fraction will be used within the algorithm:
+        `(n_samples + n_features + 1) / 2 * n_samples`. The parameter must be
+        in the range (0, 1].
+
+    random_state : int, RandomState instance or None, default=None
+        Determines the pseudo random number generator for shuffling the data.
+        Pass an int for reproducible results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    Attributes
+    ----------
+    raw_location_ : ndarray of shape (n_features,)
+        The raw robust estimated location before correction and re-weighting.
+
+    raw_covariance_ : ndarray of shape (n_features, n_features)
+        The raw robust estimated covariance before correction and re-weighting.
+
+    raw_support_ : ndarray of shape (n_samples,)
+        A mask of the observations that have been used to compute
+        the raw robust estimates of location and shape, before correction
+        and re-weighting.
+
+    location_ : ndarray of shape (n_features,)
+        Estimated robust location.
+
+    covariance_ : ndarray of shape (n_features, n_features)
+        Estimated robust covariance matrix.
+
+    precision_ : ndarray of shape (n_features, n_features)
+        Estimated pseudo inverse matrix.
+        (stored only if store_precision is True)
+
+    support_ : ndarray of shape (n_samples,)
+        A mask of the observations that have been used to compute
+        the robust estimates of location and shape.
+
+    dist_ : ndarray of shape (n_samples,)
+        Mahalanobis distances of the training set (on which :meth:`fit` is
+        called) observations.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    EllipticEnvelope : An object for detecting outliers in
+        a Gaussian distributed dataset.
+    EmpiricalCovariance : Maximum likelihood covariance estimator.
+    GraphicalLasso : Sparse inverse covariance estimation
+        with an l1-penalized estimator.
+    GraphicalLassoCV : Sparse inverse covariance with cross-validated
+        choice of the l1 penalty.
+    LedoitWolf : LedoitWolf Estimator.
+    OAS : Oracle Approximating Shrinkage Estimator.
+    ShrunkCovariance : Covariance estimator with shrinkage.
+
+    References
+    ----------
+
+    .. [Rouseeuw1984] P. J. Rousseeuw. Least median of squares regression.
+        J. Am Stat Ass, 79:871, 1984.
+    .. [Rousseeuw] A Fast Algorithm for the Minimum Covariance Determinant
+        Estimator, 1999, American Statistical Association and the American
+        Society for Quality, TECHNOMETRICS
+    .. [ButlerDavies] R. W. Butler, P. L. Davies and M. Jhun,
+        Asymptotics For The Minimum Covariance Determinant Estimator,
+        The Annals of Statistics, 1993, Vol. 21, No. 3, 1385-1400
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.covariance import MinCovDet
+    >>> from sklearn.datasets import make_gaussian_quantiles
+    >>> real_cov = np.array([[.8, .3],
+    ...                      [.3, .4]])
+    >>> rng = np.random.RandomState(0)
+    >>> X = rng.multivariate_normal(mean=[0, 0],
+    ...                                   cov=real_cov,
+    ...                                   size=500)
+    >>> cov = MinCovDet(random_state=0).fit(X)
+    >>> cov.covariance_
+    array([[0.7411..., 0.2535...],
+           [0.2535..., 0.3053...]])
+    >>> cov.location_
+    array([0.0813... , 0.0427...])
+    """
+
+    _parameter_constraints: dict = {
+        **EmpiricalCovariance._parameter_constraints,
+        "support_fraction": [Interval(Real, 0, 1, closed="right"), None],
+        "random_state": ["random_state"],
+    }
+    _nonrobust_covariance = staticmethod(empirical_covariance)
+
+    def __init__(
+        self,
+        *,
+        store_precision=True,
+        assume_centered=False,
+        support_fraction=None,
+        random_state=None,
+    ):
+        self.store_precision = store_precision
+        self.assume_centered = assume_centered
+        self.support_fraction = support_fraction
+        self.random_state = random_state
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit a Minimum Covariance Determinant with the FastMCD algorithm.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        X = validate_data(self, X, ensure_min_samples=2, estimator="MinCovDet")
+        random_state = check_random_state(self.random_state)
+        n_samples, n_features = X.shape
+        # check that the empirical covariance is full rank
+        if (linalg.svdvals(np.dot(X.T, X)) > 1e-8).sum() != n_features:
+            warnings.warn(
+                "The covariance matrix associated to your dataset is not full rank"
+            )
+        # compute and store raw estimates
+        raw_location, raw_covariance, raw_support, raw_dist = fast_mcd(
+            X,
+            support_fraction=self.support_fraction,
+            cov_computation_method=self._nonrobust_covariance,
+            random_state=random_state,
+        )
+        if self.assume_centered:
+            raw_location = np.zeros(n_features)
+            raw_covariance = self._nonrobust_covariance(
+                X[raw_support], assume_centered=True
+            )
+            # get precision matrix in an optimized way
+            precision = linalg.pinvh(raw_covariance)
+            raw_dist = np.sum(np.dot(X, precision) * X, 1)
+        self.raw_location_ = raw_location
+        self.raw_covariance_ = raw_covariance
+        self.raw_support_ = raw_support
+        self.location_ = raw_location
+        self.support_ = raw_support
+        self.dist_ = raw_dist
+        # obtain consistency at normal models
+        self.correct_covariance(X)
+        # re-weight estimator
+        self.reweight_covariance(X)
+
+        return self
+
+    def correct_covariance(self, data):
+        """Apply a correction to raw Minimum Covariance Determinant estimates.
+
+        Correction using the empirical correction factor suggested
+        by Rousseeuw and Van Driessen in [RVD]_.
+
+        Parameters
+        ----------
+        data : array-like of shape (n_samples, n_features)
+            The data matrix, with p features and n samples.
+            The data set must be the one which was used to compute
+            the raw estimates.
+
+        Returns
+        -------
+        covariance_corrected : ndarray of shape (n_features, n_features)
+            Corrected robust covariance estimate.
+
+        References
+        ----------
+
+        .. [RVD] A Fast Algorithm for the Minimum Covariance
+            Determinant Estimator, 1999, American Statistical Association
+            and the American Society for Quality, TECHNOMETRICS
+        """
+
+        # Check that the covariance of the support data is not equal to 0.
+        # Otherwise self.dist_ = 0 and thus correction = 0.
+        n_samples = len(self.dist_)
+        n_support = np.sum(self.support_)
+        if n_support < n_samples and np.allclose(self.raw_covariance_, 0):
+            raise ValueError(
+                "The covariance matrix of the support data "
+                "is equal to 0, try to increase support_fraction"
+            )
+        correction = np.median(self.dist_) / chi2(data.shape[1]).isf(0.5)
+        covariance_corrected = self.raw_covariance_ * correction
+        self.dist_ /= correction
+        return covariance_corrected
+
+    def reweight_covariance(self, data):
+        """Re-weight raw Minimum Covariance Determinant estimates.
+
+        Re-weight observations using Rousseeuw's method (equivalent to
+        deleting outlying observations from the data set before
+        computing location and covariance estimates) described
+        in [RVDriessen]_.
+
+        Parameters
+        ----------
+        data : array-like of shape (n_samples, n_features)
+            The data matrix, with p features and n samples.
+            The data set must be the one which was used to compute
+            the raw estimates.
+
+        Returns
+        -------
+        location_reweighted : ndarray of shape (n_features,)
+            Re-weighted robust location estimate.
+
+        covariance_reweighted : ndarray of shape (n_features, n_features)
+            Re-weighted robust covariance estimate.
+
+        support_reweighted : ndarray of shape (n_samples,), dtype=bool
+            A mask of the observations that have been used to compute
+            the re-weighted robust location and covariance estimates.
+
+        References
+        ----------
+
+        .. [RVDriessen] A Fast Algorithm for the Minimum Covariance
+            Determinant Estimator, 1999, American Statistical Association
+            and the American Society for Quality, TECHNOMETRICS
+        """
+        n_samples, n_features = data.shape
+        mask = self.dist_ < chi2(n_features).isf(0.025)
+        if self.assume_centered:
+            location_reweighted = np.zeros(n_features)
+        else:
+            location_reweighted = data[mask].mean(0)
+        covariance_reweighted = self._nonrobust_covariance(
+            data[mask], assume_centered=self.assume_centered
+        )
+        support_reweighted = np.zeros(n_samples, dtype=bool)
+        support_reweighted[mask] = True
+        self._set_covariance(covariance_reweighted)
+        self.location_ = location_reweighted
+        self.support_ = support_reweighted
+        X_centered = data - self.location_
+        self.dist_ = np.sum(np.dot(X_centered, self.get_precision()) * X_centered, 1)
+        return location_reweighted, covariance_reweighted, support_reweighted

evalkit_tf437/lib/python3.10/site-packages/sklearn/covariance/_shrunk_covariance.py

@@ -0,0 +1,820 @@
+"""
+Covariance estimators using shrinkage.
+
+Shrinkage corresponds to regularising `cov` using a convex combination:
+shrunk_cov = (1-shrinkage)*cov + shrinkage*structured_estimate.
+
+"""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+# avoid division truncation
+import warnings
+from numbers import Integral, Real
+
+import numpy as np
+
+from ..base import _fit_context
+from ..utils import check_array
+from ..utils._param_validation import Interval, validate_params
+from ..utils.validation import validate_data
+from . import EmpiricalCovariance, empirical_covariance
+
+
+def _ledoit_wolf(X, *, assume_centered, block_size):
+    """Estimate the shrunk Ledoit-Wolf covariance matrix."""
+    # for only one feature, the result is the same whatever the shrinkage
+    if len(X.shape) == 2 and X.shape[1] == 1:
+        if not assume_centered:
+            X = X - X.mean()
+        return np.atleast_2d((X**2).mean()), 0.0
+    n_features = X.shape[1]
+
+    # get Ledoit-Wolf shrinkage
+    shrinkage = ledoit_wolf_shrinkage(
+        X, assume_centered=assume_centered, block_size=block_size
+    )
+    emp_cov = empirical_covariance(X, assume_centered=assume_centered)
+    mu = np.sum(np.trace(emp_cov)) / n_features
+    shrunk_cov = (1.0 - shrinkage) * emp_cov
+    shrunk_cov.flat[:: n_features + 1] += shrinkage * mu
+
+    return shrunk_cov, shrinkage
+
+
+def _oas(X, *, assume_centered=False):
+    """Estimate covariance with the Oracle Approximating Shrinkage algorithm.
+
+    The formulation is based on [1]_.
+    [1] "Shrinkage algorithms for MMSE covariance estimation.",
+        Chen, Y., Wiesel, A., Eldar, Y. C., & Hero, A. O.
+        IEEE Transactions on Signal Processing, 58(10), 5016-5029, 2010.
+        https://arxiv.org/pdf/0907.4698.pdf
+    """
+    if len(X.shape) == 2 and X.shape[1] == 1:
+        # for only one feature, the result is the same whatever the shrinkage
+        if not assume_centered:
+            X = X - X.mean()
+        return np.atleast_2d((X**2).mean()), 0.0
+
+    n_samples, n_features = X.shape
+
+    emp_cov = empirical_covariance(X, assume_centered=assume_centered)
+
+    # The shrinkage is defined as:
+    # shrinkage = min(
+    # trace(S @ S.T) + trace(S)**2) / ((n + 1) (trace(S @ S.T) - trace(S)**2 / p), 1
+    # )
+    # where n and p are n_samples and n_features, respectively (cf. Eq. 23 in [1]).
+    # The factor 2 / p is omitted since it does not impact the value of the estimator
+    # for large p.
+
+    # Instead of computing trace(S)**2, we can compute the average of the squared
+    # elements of S that is equal to trace(S)**2 / p**2.
+    # See the definition of the Frobenius norm:
+    # https://en.wikipedia.org/wiki/Matrix_norm#Frobenius_norm
+    alpha = np.mean(emp_cov**2)
+    mu = np.trace(emp_cov) / n_features
+    mu_squared = mu**2
+
+    # The factor 1 / p**2 will cancel out since it is in both the numerator and
+    # denominator
+    num = alpha + mu_squared
+    den = (n_samples + 1) * (alpha - mu_squared / n_features)
+    shrinkage = 1.0 if den == 0 else min(num / den, 1.0)
+
+    # The shrunk covariance is defined as:
+    # (1 - shrinkage) * S + shrinkage * F (cf. Eq. 4 in [1])
+    # where S is the empirical covariance and F is the shrinkage target defined as
+    # F = trace(S) / n_features * np.identity(n_features) (cf. Eq. 3 in [1])
+    shrunk_cov = (1.0 - shrinkage) * emp_cov
+    shrunk_cov.flat[:: n_features + 1] += shrinkage * mu
+
+    return shrunk_cov, shrinkage
+
+
+###############################################################################
+# Public API
+# ShrunkCovariance estimator
+
+
+@validate_params(
+    {
+        "emp_cov": ["array-like"],
+        "shrinkage": [Interval(Real, 0, 1, closed="both")],
+    },
+    prefer_skip_nested_validation=True,
+)
+def shrunk_covariance(emp_cov, shrinkage=0.1):
+    """Calculate covariance matrices shrunk on the diagonal.
+
+    Read more in the :ref:`User Guide <shrunk_covariance>`.
+
+    Parameters
+    ----------
+    emp_cov : array-like of shape (..., n_features, n_features)
+        Covariance matrices to be shrunk, at least 2D ndarray.
+
+    shrinkage : float, default=0.1
+        Coefficient in the convex combination used for the computation
+        of the shrunk estimate. Range is [0, 1].
+
+    Returns
+    -------
+    shrunk_cov : ndarray of shape (..., n_features, n_features)
+        Shrunk covariance matrices.
+
+    Notes
+    -----
+    The regularized (shrunk) covariance is given by::
+
+        (1 - shrinkage) * cov + shrinkage * mu * np.identity(n_features)
+
+    where `mu = trace(cov) / n_features`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.datasets import make_gaussian_quantiles
+    >>> from sklearn.covariance import empirical_covariance, shrunk_covariance
+    >>> real_cov = np.array([[.8, .3], [.3, .4]])
+    >>> rng = np.random.RandomState(0)
+    >>> X = rng.multivariate_normal(mean=[0, 0], cov=real_cov, size=500)
+    >>> shrunk_covariance(empirical_covariance(X))
+    array([[0.73..., 0.25...],
+           [0.25..., 0.41...]])
+    """
+    emp_cov = check_array(emp_cov, allow_nd=True)
+    n_features = emp_cov.shape[-1]
+
+    shrunk_cov = (1.0 - shrinkage) * emp_cov
+    mu = np.trace(emp_cov, axis1=-2, axis2=-1) / n_features
+    mu = np.expand_dims(mu, axis=tuple(range(mu.ndim, emp_cov.ndim)))
+    shrunk_cov += shrinkage * mu * np.eye(n_features)
+
+    return shrunk_cov
+
+
+class ShrunkCovariance(EmpiricalCovariance):
+    """Covariance estimator with shrinkage.
+
+    Read more in the :ref:`User Guide <shrunk_covariance>`.
+
+    Parameters
+    ----------
+    store_precision : bool, default=True
+        Specify if the estimated precision is stored.
+
+    assume_centered : bool, default=False
+        If True, data will not be centered before computation.
+        Useful when working with data whose mean is almost, but not exactly
+        zero.
+        If False, data will be centered before computation.
+
+    shrinkage : float, default=0.1
+        Coefficient in the convex combination used for the computation
+        of the shrunk estimate. Range is [0, 1].
+
+    Attributes
+    ----------
+    covariance_ : ndarray of shape (n_features, n_features)
+        Estimated covariance matrix
+
+    location_ : ndarray of shape (n_features,)
+        Estimated location, i.e. the estimated mean.
+
+    precision_ : ndarray of shape (n_features, n_features)
+        Estimated pseudo inverse matrix.
+        (stored only if store_precision is True)
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    EllipticEnvelope : An object for detecting outliers in
+        a Gaussian distributed dataset.
+    EmpiricalCovariance : Maximum likelihood covariance estimator.
+    GraphicalLasso : Sparse inverse covariance estimation
+        with an l1-penalized estimator.
+    GraphicalLassoCV : Sparse inverse covariance with cross-validated
+        choice of the l1 penalty.
+    LedoitWolf : LedoitWolf Estimator.
+    MinCovDet : Minimum Covariance Determinant
+        (robust estimator of covariance).
+    OAS : Oracle Approximating Shrinkage Estimator.
+
+    Notes
+    -----
+    The regularized covariance is given by:
+
+    (1 - shrinkage) * cov + shrinkage * mu * np.identity(n_features)
+
+    where mu = trace(cov) / n_features
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.covariance import ShrunkCovariance
+    >>> from sklearn.datasets import make_gaussian_quantiles
+    >>> real_cov = np.array([[.8, .3],
+    ...                      [.3, .4]])
+    >>> rng = np.random.RandomState(0)
+    >>> X = rng.multivariate_normal(mean=[0, 0],
+    ...                                   cov=real_cov,
+    ...                                   size=500)
+    >>> cov = ShrunkCovariance().fit(X)
+    >>> cov.covariance_
+    array([[0.7387..., 0.2536...],
+           [0.2536..., 0.4110...]])
+    >>> cov.location_
+    array([0.0622..., 0.0193...])
+    """
+
+    _parameter_constraints: dict = {
+        **EmpiricalCovariance._parameter_constraints,
+        "shrinkage": [Interval(Real, 0, 1, closed="both")],
+    }
+
+    def __init__(self, *, store_precision=True, assume_centered=False, shrinkage=0.1):
+        super().__init__(
+            store_precision=store_precision, assume_centered=assume_centered
+        )
+        self.shrinkage = shrinkage
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit the shrunk covariance model to X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        X = validate_data(self, X)
+        # Not calling the parent object to fit, to avoid a potential
+        # matrix inversion when setting the precision
+        if self.assume_centered:
+            self.location_ = np.zeros(X.shape[1])
+        else:
+            self.location_ = X.mean(0)
+        covariance = empirical_covariance(X, assume_centered=self.assume_centered)
+        covariance = shrunk_covariance(covariance, self.shrinkage)
+        self._set_covariance(covariance)
+
+        return self
+
+
+# Ledoit-Wolf estimator
+
+
+@validate_params(
+    {
+        "X": ["array-like"],
+        "assume_centered": ["boolean"],
+        "block_size": [Interval(Integral, 1, None, closed="left")],
+    },
+    prefer_skip_nested_validation=True,
+)
+def ledoit_wolf_shrinkage(X, assume_centered=False, block_size=1000):
+    """Estimate the shrunk Ledoit-Wolf covariance matrix.
+
+    Read more in the :ref:`User Guide <shrunk_covariance>`.
+
+    Parameters
+    ----------
+    X : array-like of shape (n_samples, n_features)
+        Data from which to compute the Ledoit-Wolf shrunk covariance shrinkage.
+
+    assume_centered : bool, default=False
+        If True, data will not be centered before computation.
+        Useful to work with data whose mean is significantly equal to
+        zero but is not exactly zero.
+        If False, data will be centered before computation.
+
+    block_size : int, default=1000
+        Size of blocks into which the covariance matrix will be split.
+
+    Returns
+    -------
+    shrinkage : float
+        Coefficient in the convex combination used for the computation
+        of the shrunk estimate.
+
+    Notes
+    -----
+    The regularized (shrunk) covariance is:
+
+    (1 - shrinkage) * cov + shrinkage * mu * np.identity(n_features)
+
+    where mu = trace(cov) / n_features
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.covariance import ledoit_wolf_shrinkage
+    >>> real_cov = np.array([[.4, .2], [.2, .8]])
+    >>> rng = np.random.RandomState(0)
+    >>> X = rng.multivariate_normal(mean=[0, 0], cov=real_cov, size=50)
+    >>> shrinkage_coefficient = ledoit_wolf_shrinkage(X)
+    >>> shrinkage_coefficient
+    np.float64(0.23...)
+    """
+    X = check_array(X)
+    # for only one feature, the result is the same whatever the shrinkage
+    if len(X.shape) == 2 and X.shape[1] == 1:
+        return 0.0
+    if X.ndim == 1:
+        X = np.reshape(X, (1, -1))
+
+    if X.shape[0] == 1:
+        warnings.warn(
+            "Only one sample available. You may want to reshape your data array"
+        )
+    n_samples, n_features = X.shape
+
+    # optionally center data
+    if not assume_centered:
+        X = X - X.mean(0)
+
+    # A non-blocked version of the computation is present in the tests
+    # in tests/test_covariance.py
+
+    # number of blocks to split the covariance matrix into
+    n_splits = int(n_features / block_size)
+    X2 = X**2
+    emp_cov_trace = np.sum(X2, axis=0) / n_samples
+    mu = np.sum(emp_cov_trace) / n_features
+    beta_ = 0.0  # sum of the coefficients of <X2.T, X2>
+    delta_ = 0.0  # sum of the *squared* coefficients of <X.T, X>
+    # starting block computation
+    for i in range(n_splits):
+        for j in range(n_splits):
+            rows = slice(block_size * i, block_size * (i + 1))
+            cols = slice(block_size * j, block_size * (j + 1))
+            beta_ += np.sum(np.dot(X2.T[rows], X2[:, cols]))
+            delta_ += np.sum(np.dot(X.T[rows], X[:, cols]) ** 2)
+        rows = slice(block_size * i, block_size * (i + 1))
+        beta_ += np.sum(np.dot(X2.T[rows], X2[:, block_size * n_splits :]))
+        delta_ += np.sum(np.dot(X.T[rows], X[:, block_size * n_splits :]) ** 2)
+    for j in range(n_splits):
+        cols = slice(block_size * j, block_size * (j + 1))
+        beta_ += np.sum(np.dot(X2.T[block_size * n_splits :], X2[:, cols]))
+        delta_ += np.sum(np.dot(X.T[block_size * n_splits :], X[:, cols]) ** 2)
+    delta_ += np.sum(
+        np.dot(X.T[block_size * n_splits :], X[:, block_size * n_splits :]) ** 2
+    )
+    delta_ /= n_samples**2
+    beta_ += np.sum(
+        np.dot(X2.T[block_size * n_splits :], X2[:, block_size * n_splits :])
+    )
+    # use delta_ to compute beta
+    beta = 1.0 / (n_features * n_samples) * (beta_ / n_samples - delta_)
+    # delta is the sum of the squared coefficients of (<X.T,X> - mu*Id) / p
+    delta = delta_ - 2.0 * mu * emp_cov_trace.sum() + n_features * mu**2
+    delta /= n_features
+    # get final beta as the min between beta and delta
+    # We do this to prevent shrinking more than "1", which would invert
+    # the value of covariances
+    beta = min(beta, delta)
+    # finally get shrinkage
+    shrinkage = 0 if beta == 0 else beta / delta
+    return shrinkage
+
+
+@validate_params(
+    {"X": ["array-like"]},
+    prefer_skip_nested_validation=False,
+)
+def ledoit_wolf(X, *, assume_centered=False, block_size=1000):
+    """Estimate the shrunk Ledoit-Wolf covariance matrix.
+
+    Read more in the :ref:`User Guide <shrunk_covariance>`.
+
+    Parameters
+    ----------
+    X : array-like of shape (n_samples, n_features)
+        Data from which to compute the covariance estimate.
+
+    assume_centered : bool, default=False
+        If True, data will not be centered before computation.
+        Useful to work with data whose mean is significantly equal to
+        zero but is not exactly zero.
+        If False, data will be centered before computation.
+
+    block_size : int, default=1000
+        Size of blocks into which the covariance matrix will be split.
+        This is purely a memory optimization and does not affect results.
+
+    Returns
+    -------
+    shrunk_cov : ndarray of shape (n_features, n_features)
+        Shrunk covariance.
+
+    shrinkage : float
+        Coefficient in the convex combination used for the computation
+        of the shrunk estimate.
+
+    Notes
+    -----
+    The regularized (shrunk) covariance is:
+
+    (1 - shrinkage) * cov + shrinkage * mu * np.identity(n_features)
+
+    where mu = trace(cov) / n_features
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.covariance import empirical_covariance, ledoit_wolf
+    >>> real_cov = np.array([[.4, .2], [.2, .8]])
+    >>> rng = np.random.RandomState(0)
+    >>> X = rng.multivariate_normal(mean=[0, 0], cov=real_cov, size=50)
+    >>> covariance, shrinkage = ledoit_wolf(X)
+    >>> covariance
+    array([[0.44..., 0.16...],
+           [0.16..., 0.80...]])
+    >>> shrinkage
+    np.float64(0.23...)
+    """
+    estimator = LedoitWolf(
+        assume_centered=assume_centered,
+        block_size=block_size,
+        store_precision=False,
+    ).fit(X)
+
+    return estimator.covariance_, estimator.shrinkage_
+
+
+class LedoitWolf(EmpiricalCovariance):
+    """LedoitWolf Estimator.
+
+    Ledoit-Wolf is a particular form of shrinkage, where the shrinkage
+    coefficient is computed using O. Ledoit and M. Wolf's formula as
+    described in "A Well-Conditioned Estimator for Large-Dimensional
+    Covariance Matrices", Ledoit and Wolf, Journal of Multivariate
+    Analysis, Volume 88, Issue 2, February 2004, pages 365-411.
+
+    Read more in the :ref:`User Guide <shrunk_covariance>`.
+
+    Parameters
+    ----------
+    store_precision : bool, default=True
+        Specify if the estimated precision is stored.
+
+    assume_centered : bool, default=False
+        If True, data will not be centered before computation.
+        Useful when working with data whose mean is almost, but not exactly
+        zero.
+        If False (default), data will be centered before computation.
+
+    block_size : int, default=1000
+        Size of blocks into which the covariance matrix will be split
+        during its Ledoit-Wolf estimation. This is purely a memory
+        optimization and does not affect results.
+
+    Attributes
+    ----------
+    covariance_ : ndarray of shape (n_features, n_features)
+        Estimated covariance matrix.
+
+    location_ : ndarray of shape (n_features,)
+        Estimated location, i.e. the estimated mean.
+
+    precision_ : ndarray of shape (n_features, n_features)
+        Estimated pseudo inverse matrix.
+        (stored only if store_precision is True)
+
+    shrinkage_ : float
+        Coefficient in the convex combination used for the computation
+        of the shrunk estimate. Range is [0, 1].
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    EllipticEnvelope : An object for detecting outliers in
+        a Gaussian distributed dataset.
+    EmpiricalCovariance : Maximum likelihood covariance estimator.
+    GraphicalLasso : Sparse inverse covariance estimation
+        with an l1-penalized estimator.
+    GraphicalLassoCV : Sparse inverse covariance with cross-validated
+        choice of the l1 penalty.
+    MinCovDet : Minimum Covariance Determinant
+        (robust estimator of covariance).
+    OAS : Oracle Approximating Shrinkage Estimator.
+    ShrunkCovariance : Covariance estimator with shrinkage.
+
+    Notes
+    -----
+    The regularised covariance is:
+
+    (1 - shrinkage) * cov + shrinkage * mu * np.identity(n_features)
+
+    where mu = trace(cov) / n_features
+    and shrinkage is given by the Ledoit and Wolf formula (see References)
+
+    References
+    ----------
+    "A Well-Conditioned Estimator for Large-Dimensional Covariance Matrices",
+    Ledoit and Wolf, Journal of Multivariate Analysis, Volume 88, Issue 2,
+    February 2004, pages 365-411.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.covariance import LedoitWolf
+    >>> real_cov = np.array([[.4, .2],
+    ...                      [.2, .8]])
+    >>> np.random.seed(0)
+    >>> X = np.random.multivariate_normal(mean=[0, 0],
+    ...                                   cov=real_cov,
+    ...                                   size=50)
+    >>> cov = LedoitWolf().fit(X)
+    >>> cov.covariance_
+    array([[0.4406..., 0.1616...],
+           [0.1616..., 0.8022...]])
+    >>> cov.location_
+    array([ 0.0595... , -0.0075...])
+
+    See also :ref:`sphx_glr_auto_examples_covariance_plot_covariance_estimation.py`
+    for a more detailed example.
+    """
+
+    _parameter_constraints: dict = {
+        **EmpiricalCovariance._parameter_constraints,
+        "block_size": [Interval(Integral, 1, None, closed="left")],
+    }
+
+    def __init__(self, *, store_precision=True, assume_centered=False, block_size=1000):
+        super().__init__(
+            store_precision=store_precision, assume_centered=assume_centered
+        )
+        self.block_size = block_size
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit the Ledoit-Wolf shrunk covariance model to X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        # Not calling the parent object to fit, to avoid computing the
+        # covariance matrix (and potentially the precision)
+        X = validate_data(self, X)
+        if self.assume_centered:
+            self.location_ = np.zeros(X.shape[1])
+        else:
+            self.location_ = X.mean(0)
+        covariance, shrinkage = _ledoit_wolf(
+            X - self.location_, assume_centered=True, block_size=self.block_size
+        )
+        self.shrinkage_ = shrinkage
+        self._set_covariance(covariance)
+
+        return self
+
+
+# OAS estimator
+@validate_params(
+    {"X": ["array-like"]},
+    prefer_skip_nested_validation=False,
+)
+def oas(X, *, assume_centered=False):
+    """Estimate covariance with the Oracle Approximating Shrinkage.
+
+    Read more in the :ref:`User Guide <shrunk_covariance>`.
+
+    Parameters
+    ----------
+    X : array-like of shape (n_samples, n_features)
+        Data from which to compute the covariance estimate.
+
+    assume_centered : bool, default=False
+      If True, data will not be centered before computation.
+      Useful to work with data whose mean is significantly equal to
+      zero but is not exactly zero.
+      If False, data will be centered before computation.
+
+    Returns
+    -------
+    shrunk_cov : array-like of shape (n_features, n_features)
+        Shrunk covariance.
+
+    shrinkage : float
+        Coefficient in the convex combination used for the computation
+        of the shrunk estimate.
+
+    Notes
+    -----
+    The regularised covariance is:
+
+    (1 - shrinkage) * cov + shrinkage * mu * np.identity(n_features),
+
+    where mu = trace(cov) / n_features and shrinkage is given by the OAS formula
+    (see [1]_).
+
+    The shrinkage formulation implemented here differs from Eq. 23 in [1]_. In
+    the original article, formula (23) states that 2/p (p being the number of
+    features) is multiplied by Trace(cov*cov) in both the numerator and
+    denominator, but this operation is omitted because for a large p, the value
+    of 2/p is so small that it doesn't affect the value of the estimator.
+
+    References
+    ----------
+    .. [1] :arxiv:`"Shrinkage algorithms for MMSE covariance estimation.",
+           Chen, Y., Wiesel, A., Eldar, Y. C., & Hero, A. O.
+           IEEE Transactions on Signal Processing, 58(10), 5016-5029, 2010.
+           <0907.4698>`
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.covariance import oas
+    >>> rng = np.random.RandomState(0)
+    >>> real_cov = [[.8, .3], [.3, .4]]
+    >>> X = rng.multivariate_normal(mean=[0, 0], cov=real_cov, size=500)
+    >>> shrunk_cov, shrinkage = oas(X)
+    >>> shrunk_cov
+    array([[0.7533..., 0.2763...],
+           [0.2763..., 0.3964...]])
+    >>> shrinkage
+    np.float64(0.0195...)
+    """
+    estimator = OAS(
+        assume_centered=assume_centered,
+    ).fit(X)
+    return estimator.covariance_, estimator.shrinkage_
+
+
+class OAS(EmpiricalCovariance):
+    """Oracle Approximating Shrinkage Estimator.
+
+    Read more in the :ref:`User Guide <shrunk_covariance>`.
+
+    Parameters
+    ----------
+    store_precision : bool, default=True
+        Specify if the estimated precision is stored.
+
+    assume_centered : bool, default=False
+        If True, data will not be centered before computation.
+        Useful when working with data whose mean is almost, but not exactly
+        zero.
+        If False (default), data will be centered before computation.
+
+    Attributes
+    ----------
+    covariance_ : ndarray of shape (n_features, n_features)
+        Estimated covariance matrix.
+
+    location_ : ndarray of shape (n_features,)
+        Estimated location, i.e. the estimated mean.
+
+    precision_ : ndarray of shape (n_features, n_features)
+        Estimated pseudo inverse matrix.
+        (stored only if store_precision is True)
+
+    shrinkage_ : float
+      coefficient in the convex combination used for the computation
+      of the shrunk estimate. Range is [0, 1].
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    EllipticEnvelope : An object for detecting outliers in
+        a Gaussian distributed dataset.
+    EmpiricalCovariance : Maximum likelihood covariance estimator.
+    GraphicalLasso : Sparse inverse covariance estimation
+        with an l1-penalized estimator.
+    GraphicalLassoCV : Sparse inverse covariance with cross-validated
+        choice of the l1 penalty.
+    LedoitWolf : LedoitWolf Estimator.
+    MinCovDet : Minimum Covariance Determinant
+        (robust estimator of covariance).
+    ShrunkCovariance : Covariance estimator with shrinkage.
+
+    Notes
+    -----
+    The regularised covariance is:
+
+    (1 - shrinkage) * cov + shrinkage * mu * np.identity(n_features),
+
+    where mu = trace(cov) / n_features and shrinkage is given by the OAS formula
+    (see [1]_).
+
+    The shrinkage formulation implemented here differs from Eq. 23 in [1]_. In
+    the original article, formula (23) states that 2/p (p being the number of
+    features) is multiplied by Trace(cov*cov) in both the numerator and
+    denominator, but this operation is omitted because for a large p, the value
+    of 2/p is so small that it doesn't affect the value of the estimator.
+
+    References
+    ----------
+    .. [1] :arxiv:`"Shrinkage algorithms for MMSE covariance estimation.",
+           Chen, Y., Wiesel, A., Eldar, Y. C., & Hero, A. O.
+           IEEE Transactions on Signal Processing, 58(10), 5016-5029, 2010.
+           <0907.4698>`
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.covariance import OAS
+    >>> from sklearn.datasets import make_gaussian_quantiles
+    >>> real_cov = np.array([[.8, .3],
+    ...                      [.3, .4]])
+    >>> rng = np.random.RandomState(0)
+    >>> X = rng.multivariate_normal(mean=[0, 0],
+    ...                             cov=real_cov,
+    ...                             size=500)
+    >>> oas = OAS().fit(X)
+    >>> oas.covariance_
+    array([[0.7533..., 0.2763...],
+           [0.2763..., 0.3964...]])
+    >>> oas.precision_
+    array([[ 1.7833..., -1.2431... ],
+           [-1.2431...,  3.3889...]])
+    >>> oas.shrinkage_
+    np.float64(0.0195...)
+
+    See also :ref:`sphx_glr_auto_examples_covariance_plot_covariance_estimation.py`
+    for a more detailed example.
+    """
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit the Oracle Approximating Shrinkage covariance model to X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        X = validate_data(self, X)
+        # Not calling the parent object to fit, to avoid computing the
+        # covariance matrix (and potentially the precision)
+        if self.assume_centered:
+            self.location_ = np.zeros(X.shape[1])
+        else:
+            self.location_ = X.mean(0)
+
+        covariance, shrinkage = _oas(X - self.location_, assume_centered=True)
+        self.shrinkage_ = shrinkage
+        self._set_covariance(covariance)
+
+        return self

evalkit_tf437/lib/python3.10/site-packages/sklearn/covariance/tests/test_covariance.py

@@ -0,0 +1,374 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import numpy as np
+import pytest
+
+from sklearn import datasets
+from sklearn.covariance import (
+    OAS,
+    EmpiricalCovariance,
+    LedoitWolf,
+    ShrunkCovariance,
+    empirical_covariance,
+    ledoit_wolf,
+    ledoit_wolf_shrinkage,
+    oas,
+    shrunk_covariance,
+)
+from sklearn.covariance._shrunk_covariance import _ledoit_wolf
+from sklearn.utils._testing import (
+    assert_allclose,
+    assert_almost_equal,
+    assert_array_almost_equal,
+    assert_array_equal,
+)
+
+from .._shrunk_covariance import _oas
+
+X, _ = datasets.load_diabetes(return_X_y=True)
+X_1d = X[:, 0]
+n_samples, n_features = X.shape
+
+
+def test_covariance():
+    # Tests Covariance module on a simple dataset.
+    # test covariance fit from data
+    cov = EmpiricalCovariance()
+    cov.fit(X)
+    emp_cov = empirical_covariance(X)
+    assert_array_almost_equal(emp_cov, cov.covariance_, 4)
+    assert_almost_equal(cov.error_norm(emp_cov), 0)
+    assert_almost_equal(cov.error_norm(emp_cov, norm="spectral"), 0)
+    assert_almost_equal(cov.error_norm(emp_cov, norm="frobenius"), 0)
+    assert_almost_equal(cov.error_norm(emp_cov, scaling=False), 0)
+    assert_almost_equal(cov.error_norm(emp_cov, squared=False), 0)
+    with pytest.raises(NotImplementedError):
+        cov.error_norm(emp_cov, norm="foo")
+    # Mahalanobis distances computation test
+    mahal_dist = cov.mahalanobis(X)
+    assert np.amin(mahal_dist) > 0
+
+    # test with n_features = 1
+    X_1d = X[:, 0].reshape((-1, 1))
+    cov = EmpiricalCovariance()
+    cov.fit(X_1d)
+    assert_array_almost_equal(empirical_covariance(X_1d), cov.covariance_, 4)
+    assert_almost_equal(cov.error_norm(empirical_covariance(X_1d)), 0)
+    assert_almost_equal(cov.error_norm(empirical_covariance(X_1d), norm="spectral"), 0)
+
+    # test with one sample
+    # Create X with 1 sample and 5 features
+    X_1sample = np.arange(5).reshape(1, 5)
+    cov = EmpiricalCovariance()
+    warn_msg = "Only one sample available. You may want to reshape your data array"
+    with pytest.warns(UserWarning, match=warn_msg):
+        cov.fit(X_1sample)
+
+    assert_array_almost_equal(cov.covariance_, np.zeros(shape=(5, 5), dtype=np.float64))
+
+    # test integer type
+    X_integer = np.asarray([[0, 1], [1, 0]])
+    result = np.asarray([[0.25, -0.25], [-0.25, 0.25]])
+    assert_array_almost_equal(empirical_covariance(X_integer), result)
+
+    # test centered case
+    cov = EmpiricalCovariance(assume_centered=True)
+    cov.fit(X)
+    assert_array_equal(cov.location_, np.zeros(X.shape[1]))
+
+
+@pytest.mark.parametrize("n_matrices", [1, 3])
+def test_shrunk_covariance_func(n_matrices):
+    """Check `shrunk_covariance` function."""
+
+    n_features = 2
+    cov = np.ones((n_features, n_features))
+    cov_target = np.array([[1, 0.5], [0.5, 1]])
+
+    if n_matrices > 1:
+        cov = np.repeat(cov[np.newaxis, ...], n_matrices, axis=0)
+        cov_target = np.repeat(cov_target[np.newaxis, ...], n_matrices, axis=0)
+
+    cov_shrunk = shrunk_covariance(cov, 0.5)
+    assert_allclose(cov_shrunk, cov_target)
+
+
+def test_shrunk_covariance():
+    """Check consistency between `ShrunkCovariance` and `shrunk_covariance`."""
+
+    # Tests ShrunkCovariance module on a simple dataset.
+    # compare shrunk covariance obtained from data and from MLE estimate
+    cov = ShrunkCovariance(shrinkage=0.5)
+    cov.fit(X)
+    assert_array_almost_equal(
+        shrunk_covariance(empirical_covariance(X), shrinkage=0.5), cov.covariance_, 4
+    )
+
+    # same test with shrinkage not provided
+    cov = ShrunkCovariance()
+    cov.fit(X)
+    assert_array_almost_equal(
+        shrunk_covariance(empirical_covariance(X)), cov.covariance_, 4
+    )
+
+    # same test with shrinkage = 0 (<==> empirical_covariance)
+    cov = ShrunkCovariance(shrinkage=0.0)
+    cov.fit(X)
+    assert_array_almost_equal(empirical_covariance(X), cov.covariance_, 4)
+
+    # test with n_features = 1
+    X_1d = X[:, 0].reshape((-1, 1))
+    cov = ShrunkCovariance(shrinkage=0.3)
+    cov.fit(X_1d)
+    assert_array_almost_equal(empirical_covariance(X_1d), cov.covariance_, 4)
+
+    # test shrinkage coeff on a simple data set (without saving precision)
+    cov = ShrunkCovariance(shrinkage=0.5, store_precision=False)
+    cov.fit(X)
+    assert cov.precision_ is None
+
+
+def test_ledoit_wolf():
+    # Tests LedoitWolf module on a simple dataset.
+    # test shrinkage coeff on a simple data set
+    X_centered = X - X.mean(axis=0)
+    lw = LedoitWolf(assume_centered=True)
+    lw.fit(X_centered)
+    shrinkage_ = lw.shrinkage_
+
+    score_ = lw.score(X_centered)
+    assert_almost_equal(
+        ledoit_wolf_shrinkage(X_centered, assume_centered=True), shrinkage_
+    )
+    assert_almost_equal(
+        ledoit_wolf_shrinkage(X_centered, assume_centered=True, block_size=6),
+        shrinkage_,
+    )
+    # compare shrunk covariance obtained from data and from MLE estimate
+    lw_cov_from_mle, lw_shrinkage_from_mle = ledoit_wolf(
+        X_centered, assume_centered=True
+    )
+    assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4)
+    assert_almost_equal(lw_shrinkage_from_mle, lw.shrinkage_)
+    # compare estimates given by LW and ShrunkCovariance
+    scov = ShrunkCovariance(shrinkage=lw.shrinkage_, assume_centered=True)
+    scov.fit(X_centered)
+    assert_array_almost_equal(scov.covariance_, lw.covariance_, 4)
+
+    # test with n_features = 1
+    X_1d = X[:, 0].reshape((-1, 1))
+    lw = LedoitWolf(assume_centered=True)
+    lw.fit(X_1d)
+    lw_cov_from_mle, lw_shrinkage_from_mle = ledoit_wolf(X_1d, assume_centered=True)
+    assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4)
+    assert_almost_equal(lw_shrinkage_from_mle, lw.shrinkage_)
+    assert_array_almost_equal((X_1d**2).sum() / n_samples, lw.covariance_, 4)
+
+    # test shrinkage coeff on a simple data set (without saving precision)
+    lw = LedoitWolf(store_precision=False, assume_centered=True)
+    lw.fit(X_centered)
+    assert_almost_equal(lw.score(X_centered), score_, 4)
+    assert lw.precision_ is None
+
+    # Same tests without assuming centered data
+    # test shrinkage coeff on a simple data set
+    lw = LedoitWolf()
+    lw.fit(X)
+    assert_almost_equal(lw.shrinkage_, shrinkage_, 4)
+    assert_almost_equal(lw.shrinkage_, ledoit_wolf_shrinkage(X))
+    assert_almost_equal(lw.shrinkage_, ledoit_wolf(X)[1])
+    assert_almost_equal(
+        lw.shrinkage_, _ledoit_wolf(X=X, assume_centered=False, block_size=10000)[1]
+    )
+    assert_almost_equal(lw.score(X), score_, 4)
+    # compare shrunk covariance obtained from data and from MLE estimate
+    lw_cov_from_mle, lw_shrinkage_from_mle = ledoit_wolf(X)
+    assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4)
+    assert_almost_equal(lw_shrinkage_from_mle, lw.shrinkage_)
+    # compare estimates given by LW and ShrunkCovariance
+    scov = ShrunkCovariance(shrinkage=lw.shrinkage_)
+    scov.fit(X)
+    assert_array_almost_equal(scov.covariance_, lw.covariance_, 4)
+
+    # test with n_features = 1
+    X_1d = X[:, 0].reshape((-1, 1))
+    lw = LedoitWolf()
+    lw.fit(X_1d)
+    assert_allclose(
+        X_1d.var(ddof=0),
+        _ledoit_wolf(X=X_1d, assume_centered=False, block_size=10000)[0],
+    )
+    lw_cov_from_mle, lw_shrinkage_from_mle = ledoit_wolf(X_1d)
+    assert_array_almost_equal(lw_cov_from_mle, lw.covariance_, 4)
+    assert_almost_equal(lw_shrinkage_from_mle, lw.shrinkage_)
+    assert_array_almost_equal(empirical_covariance(X_1d), lw.covariance_, 4)
+
+    # test with one sample
+    # warning should be raised when using only 1 sample
+    X_1sample = np.arange(5).reshape(1, 5)
+    lw = LedoitWolf()
+
+    warn_msg = "Only one sample available. You may want to reshape your data array"
+    with pytest.warns(UserWarning, match=warn_msg):
+        lw.fit(X_1sample)
+
+    assert_array_almost_equal(lw.covariance_, np.zeros(shape=(5, 5), dtype=np.float64))
+
+    # test shrinkage coeff on a simple data set (without saving precision)
+    lw = LedoitWolf(store_precision=False)
+    lw.fit(X)
+    assert_almost_equal(lw.score(X), score_, 4)
+    assert lw.precision_ is None
+
+
+def _naive_ledoit_wolf_shrinkage(X):
+    # A simple implementation of the formulas from Ledoit & Wolf
+
+    # The computation below achieves the following computations of the
+    # "O. Ledoit and M. Wolf, A Well-Conditioned Estimator for
+    # Large-Dimensional Covariance Matrices"
+    # beta and delta are given in the beginning of section 3.2
+    n_samples, n_features = X.shape
+    emp_cov = empirical_covariance(X, assume_centered=False)
+    mu = np.trace(emp_cov) / n_features
+    delta_ = emp_cov.copy()
+    delta_.flat[:: n_features + 1] -= mu
+    delta = (delta_**2).sum() / n_features
+    X2 = X**2
+    beta_ = (
+        1.0
+        / (n_features * n_samples)
+        * np.sum(np.dot(X2.T, X2) / n_samples - emp_cov**2)
+    )
+
+    beta = min(beta_, delta)
+    shrinkage = beta / delta
+    return shrinkage
+
+
+def test_ledoit_wolf_small():
+    # Compare our blocked implementation to the naive implementation
+    X_small = X[:, :4]
+    lw = LedoitWolf()
+    lw.fit(X_small)
+    shrinkage_ = lw.shrinkage_
+
+    assert_almost_equal(shrinkage_, _naive_ledoit_wolf_shrinkage(X_small))
+
+
+def test_ledoit_wolf_large():
+    # test that ledoit_wolf doesn't error on data that is wider than block_size
+    rng = np.random.RandomState(0)
+    # use a number of features that is larger than the block-size
+    X = rng.normal(size=(10, 20))
+    lw = LedoitWolf(block_size=10).fit(X)
+    # check that covariance is about diagonal (random normal noise)
+    assert_almost_equal(lw.covariance_, np.eye(20), 0)
+    cov = lw.covariance_
+
+    # check that the result is consistent with not splitting data into blocks.
+    lw = LedoitWolf(block_size=25).fit(X)
+    assert_almost_equal(lw.covariance_, cov)
+
+
+@pytest.mark.parametrize(
+    "ledoit_wolf_fitting_function", [LedoitWolf().fit, ledoit_wolf_shrinkage]
+)
+def test_ledoit_wolf_empty_array(ledoit_wolf_fitting_function):
+    """Check that we validate X and raise proper error with 0-sample array."""
+    X_empty = np.zeros((0, 2))
+    with pytest.raises(ValueError, match="Found array with 0 sample"):
+        ledoit_wolf_fitting_function(X_empty)
+
+
+def test_oas():
+    # Tests OAS module on a simple dataset.
+    # test shrinkage coeff on a simple data set
+    X_centered = X - X.mean(axis=0)
+    oa = OAS(assume_centered=True)
+    oa.fit(X_centered)
+    shrinkage_ = oa.shrinkage_
+    score_ = oa.score(X_centered)
+    # compare shrunk covariance obtained from data and from MLE estimate
+    oa_cov_from_mle, oa_shrinkage_from_mle = oas(X_centered, assume_centered=True)
+    assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4)
+    assert_almost_equal(oa_shrinkage_from_mle, oa.shrinkage_)
+    # compare estimates given by OAS and ShrunkCovariance
+    scov = ShrunkCovariance(shrinkage=oa.shrinkage_, assume_centered=True)
+    scov.fit(X_centered)
+    assert_array_almost_equal(scov.covariance_, oa.covariance_, 4)
+
+    # test with n_features = 1
+    X_1d = X[:, 0:1]
+    oa = OAS(assume_centered=True)
+    oa.fit(X_1d)
+    oa_cov_from_mle, oa_shrinkage_from_mle = oas(X_1d, assume_centered=True)
+    assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4)
+    assert_almost_equal(oa_shrinkage_from_mle, oa.shrinkage_)
+    assert_array_almost_equal((X_1d**2).sum() / n_samples, oa.covariance_, 4)
+
+    # test shrinkage coeff on a simple data set (without saving precision)
+    oa = OAS(store_precision=False, assume_centered=True)
+    oa.fit(X_centered)
+    assert_almost_equal(oa.score(X_centered), score_, 4)
+    assert oa.precision_ is None
+
+    # Same tests without assuming centered data--------------------------------
+    # test shrinkage coeff on a simple data set
+    oa = OAS()
+    oa.fit(X)
+    assert_almost_equal(oa.shrinkage_, shrinkage_, 4)
+    assert_almost_equal(oa.score(X), score_, 4)
+    # compare shrunk covariance obtained from data and from MLE estimate
+    oa_cov_from_mle, oa_shrinkage_from_mle = oas(X)
+    assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4)
+    assert_almost_equal(oa_shrinkage_from_mle, oa.shrinkage_)
+    # compare estimates given by OAS and ShrunkCovariance
+    scov = ShrunkCovariance(shrinkage=oa.shrinkage_)
+    scov.fit(X)
+    assert_array_almost_equal(scov.covariance_, oa.covariance_, 4)
+
+    # test with n_features = 1
+    X_1d = X[:, 0].reshape((-1, 1))
+    oa = OAS()
+    oa.fit(X_1d)
+    oa_cov_from_mle, oa_shrinkage_from_mle = oas(X_1d)
+    assert_array_almost_equal(oa_cov_from_mle, oa.covariance_, 4)
+    assert_almost_equal(oa_shrinkage_from_mle, oa.shrinkage_)
+    assert_array_almost_equal(empirical_covariance(X_1d), oa.covariance_, 4)
+
+    # test with one sample
+    # warning should be raised when using only 1 sample
+    X_1sample = np.arange(5).reshape(1, 5)
+    oa = OAS()
+    warn_msg = "Only one sample available. You may want to reshape your data array"
+    with pytest.warns(UserWarning, match=warn_msg):
+        oa.fit(X_1sample)
+
+    assert_array_almost_equal(oa.covariance_, np.zeros(shape=(5, 5), dtype=np.float64))
+
+    # test shrinkage coeff on a simple data set (without saving precision)
+    oa = OAS(store_precision=False)
+    oa.fit(X)
+    assert_almost_equal(oa.score(X), score_, 4)
+    assert oa.precision_ is None
+
+    # test function _oas without assuming centered data
+    X_1f = X[:, 0:1]
+    oa = OAS()
+    oa.fit(X_1f)
+    # compare shrunk covariance obtained from data and from MLE estimate
+    _oa_cov_from_mle, _oa_shrinkage_from_mle = _oas(X_1f)
+    assert_array_almost_equal(_oa_cov_from_mle, oa.covariance_, 4)
+    assert_almost_equal(_oa_shrinkage_from_mle, oa.shrinkage_)
+    assert_array_almost_equal((X_1f**2).sum() / n_samples, oa.covariance_, 4)
+
+
+def test_EmpiricalCovariance_validates_mahalanobis():
+    """Checks that EmpiricalCovariance validates data with mahalanobis."""
+    cov = EmpiricalCovariance().fit(X)
+
+    msg = f"X has 2 features, but \\w+ is expecting {X.shape[1]} features as input"
+    with pytest.raises(ValueError, match=msg):
+        cov.mahalanobis(X[:, :2])

evalkit_tf437/lib/python3.10/site-packages/sklearn/covariance/tests/test_elliptic_envelope.py

@@ -0,0 +1,52 @@
+"""
+Testing for Elliptic Envelope algorithm (sklearn.covariance.elliptic_envelope).
+"""
+
+import numpy as np
+import pytest
+
+from sklearn.covariance import EllipticEnvelope
+from sklearn.exceptions import NotFittedError
+from sklearn.utils._testing import (
+    assert_almost_equal,
+    assert_array_almost_equal,
+    assert_array_equal,
+)
+
+
+def test_elliptic_envelope(global_random_seed):
+    rnd = np.random.RandomState(global_random_seed)
+    X = rnd.randn(100, 10)
+    clf = EllipticEnvelope(contamination=0.1)
+    with pytest.raises(NotFittedError):
+        clf.predict(X)
+    with pytest.raises(NotFittedError):
+        clf.decision_function(X)
+    clf.fit(X)
+    y_pred = clf.predict(X)
+    scores = clf.score_samples(X)
+    decisions = clf.decision_function(X)
+
+    assert_array_almost_equal(scores, -clf.mahalanobis(X))
+    assert_array_almost_equal(clf.mahalanobis(X), clf.dist_)
+    assert_almost_equal(
+        clf.score(X, np.ones(100)), (100 - y_pred[y_pred == -1].size) / 100.0
+    )
+    assert sum(y_pred == -1) == sum(decisions < 0)
+
+
+def test_score_samples():
+    X_train = [[1, 1], [1, 2], [2, 1]]
+    clf1 = EllipticEnvelope(contamination=0.2).fit(X_train)
+    clf2 = EllipticEnvelope().fit(X_train)
+    assert_array_equal(
+        clf1.score_samples([[2.0, 2.0]]),
+        clf1.decision_function([[2.0, 2.0]]) + clf1.offset_,
+    )
+    assert_array_equal(
+        clf2.score_samples([[2.0, 2.0]]),
+        clf2.decision_function([[2.0, 2.0]]) + clf2.offset_,
+    )
+    assert_array_equal(
+        clf1.score_samples([[2.0, 2.0]]), clf2.score_samples([[2.0, 2.0]])
+    )

evalkit_tf437/lib/python3.10/site-packages/sklearn/covariance/tests/test_graphical_lasso.py

@@ -0,0 +1,318 @@
+"""Test the graphical_lasso module."""
+
+import sys
+from io import StringIO
+
+import numpy as np
+import pytest
+from numpy.testing import assert_allclose
+from scipy import linalg
+
+from sklearn import config_context, datasets
+from sklearn.covariance import (
+    GraphicalLasso,
+    GraphicalLassoCV,
+    empirical_covariance,
+    graphical_lasso,
+)
+from sklearn.datasets import make_sparse_spd_matrix
+from sklearn.model_selection import GroupKFold
+from sklearn.utils import check_random_state
+from sklearn.utils._testing import (
+    _convert_container,
+    assert_array_almost_equal,
+    assert_array_less,
+)
+
+
+def test_graphical_lassos(random_state=1):
+    """Test the graphical lasso solvers.
+
+    This checks is unstable for some random seeds where the covariance found with "cd"
+    and "lars" solvers are different (4 cases / 100 tries).
+    """
+    # Sample data from a sparse multivariate normal
+    dim = 20
+    n_samples = 100
+    random_state = check_random_state(random_state)
+    prec = make_sparse_spd_matrix(dim, alpha=0.95, random_state=random_state)
+    cov = linalg.inv(prec)
+    X = random_state.multivariate_normal(np.zeros(dim), cov, size=n_samples)
+    emp_cov = empirical_covariance(X)
+
+    for alpha in (0.0, 0.1, 0.25):
+        covs = dict()
+        icovs = dict()
+        for method in ("cd", "lars"):
+            cov_, icov_, costs = graphical_lasso(
+                emp_cov, return_costs=True, alpha=alpha, mode=method
+            )
+            covs[method] = cov_
+            icovs[method] = icov_
+            costs, dual_gap = np.array(costs).T
+            # Check that the costs always decrease (doesn't hold if alpha == 0)
+            if not alpha == 0:
+                # use 1e-12 since the cost can be exactly 0
+                assert_array_less(np.diff(costs), 1e-12)
+        # Check that the 2 approaches give similar results
+        assert_allclose(covs["cd"], covs["lars"], atol=5e-4)
+        assert_allclose(icovs["cd"], icovs["lars"], atol=5e-4)
+
+    # Smoke test the estimator
+    model = GraphicalLasso(alpha=0.25).fit(X)
+    model.score(X)
+    assert_array_almost_equal(model.covariance_, covs["cd"], decimal=4)
+    assert_array_almost_equal(model.covariance_, covs["lars"], decimal=4)
+
+    # For a centered matrix, assume_centered could be chosen True or False
+    # Check that this returns indeed the same result for centered data
+    Z = X - X.mean(0)
+    precs = list()
+    for assume_centered in (False, True):
+        prec_ = GraphicalLasso(assume_centered=assume_centered).fit(Z).precision_
+        precs.append(prec_)
+    assert_array_almost_equal(precs[0], precs[1])
+
+
+def test_graphical_lasso_when_alpha_equals_0():
+    """Test graphical_lasso's early return condition when alpha=0."""
+    X = np.random.randn(100, 10)
+    emp_cov = empirical_covariance(X, assume_centered=True)
+
+    model = GraphicalLasso(alpha=0, covariance="precomputed").fit(emp_cov)
+    assert_allclose(model.precision_, np.linalg.inv(emp_cov))
+
+    _, precision = graphical_lasso(emp_cov, alpha=0)
+    assert_allclose(precision, np.linalg.inv(emp_cov))
+
+
+@pytest.mark.parametrize("mode", ["cd", "lars"])
+def test_graphical_lasso_n_iter(mode):
+    X, _ = datasets.make_classification(n_samples=5_000, n_features=20, random_state=0)
+    emp_cov = empirical_covariance(X)
+
+    _, _, n_iter = graphical_lasso(
+        emp_cov, 0.2, mode=mode, max_iter=2, return_n_iter=True
+    )
+    assert n_iter == 2
+
+
+def test_graphical_lasso_iris():
+    # Hard-coded solution from R glasso package for alpha=1.0
+    # (need to set penalize.diagonal to FALSE)
+    cov_R = np.array(
+        [
+            [0.68112222, 0.0000000, 0.265820, 0.02464314],
+            [0.00000000, 0.1887129, 0.000000, 0.00000000],
+            [0.26582000, 0.0000000, 3.095503, 0.28697200],
+            [0.02464314, 0.0000000, 0.286972, 0.57713289],
+        ]
+    )
+    icov_R = np.array(
+        [
+            [1.5190747, 0.000000, -0.1304475, 0.0000000],
+            [0.0000000, 5.299055, 0.0000000, 0.0000000],
+            [-0.1304475, 0.000000, 0.3498624, -0.1683946],
+            [0.0000000, 0.000000, -0.1683946, 1.8164353],
+        ]
+    )
+    X = datasets.load_iris().data
+    emp_cov = empirical_covariance(X)
+    for method in ("cd", "lars"):
+        cov, icov = graphical_lasso(emp_cov, alpha=1.0, return_costs=False, mode=method)
+        assert_array_almost_equal(cov, cov_R)
+        assert_array_almost_equal(icov, icov_R)
+
+
+def test_graph_lasso_2D():
+    # Hard-coded solution from Python skggm package
+    # obtained by calling `quic(emp_cov, lam=.1, tol=1e-8)`
+    cov_skggm = np.array([[3.09550269, 1.186972], [1.186972, 0.57713289]])
+
+    icov_skggm = np.array([[1.52836773, -3.14334831], [-3.14334831, 8.19753385]])
+    X = datasets.load_iris().data[:, 2:]
+    emp_cov = empirical_covariance(X)
+    for method in ("cd", "lars"):
+        cov, icov = graphical_lasso(emp_cov, alpha=0.1, return_costs=False, mode=method)
+        assert_array_almost_equal(cov, cov_skggm)
+        assert_array_almost_equal(icov, icov_skggm)
+
+
+def test_graphical_lasso_iris_singular():
+    # Small subset of rows to test the rank-deficient case
+    # Need to choose samples such that none of the variances are zero
+    indices = np.arange(10, 13)
+
+    # Hard-coded solution from R glasso package for alpha=0.01
+    cov_R = np.array(
+        [
+            [0.08, 0.056666662595, 0.00229729713223, 0.00153153142149],
+            [0.056666662595, 0.082222222222, 0.00333333333333, 0.00222222222222],
+            [0.002297297132, 0.003333333333, 0.00666666666667, 0.00009009009009],
+            [0.001531531421, 0.002222222222, 0.00009009009009, 0.00222222222222],
+        ]
+    )
+    icov_R = np.array(
+        [
+            [24.42244057, -16.831679593, 0.0, 0.0],
+            [-16.83168201, 24.351841681, -6.206896552, -12.5],
+            [0.0, -6.206896171, 153.103448276, 0.0],
+            [0.0, -12.499999143, 0.0, 462.5],
+        ]
+    )
+    X = datasets.load_iris().data[indices, :]
+    emp_cov = empirical_covariance(X)
+    for method in ("cd", "lars"):
+        cov, icov = graphical_lasso(
+            emp_cov, alpha=0.01, return_costs=False, mode=method
+        )
+        assert_array_almost_equal(cov, cov_R, decimal=5)
+        assert_array_almost_equal(icov, icov_R, decimal=5)
+
+
+def test_graphical_lasso_cv(random_state=1):
+    # Sample data from a sparse multivariate normal
+    dim = 5
+    n_samples = 6
+    random_state = check_random_state(random_state)
+    prec = make_sparse_spd_matrix(dim, alpha=0.96, random_state=random_state)
+    cov = linalg.inv(prec)
+    X = random_state.multivariate_normal(np.zeros(dim), cov, size=n_samples)
+    # Capture stdout, to smoke test the verbose mode
+    orig_stdout = sys.stdout
+    try:
+        sys.stdout = StringIO()
+        # We need verbose very high so that Parallel prints on stdout
+        GraphicalLassoCV(verbose=100, alphas=5, tol=1e-1).fit(X)
+    finally:
+        sys.stdout = orig_stdout
+
+
+@pytest.mark.parametrize("alphas_container_type", ["list", "tuple", "array"])
+def test_graphical_lasso_cv_alphas_iterable(alphas_container_type):
+    """Check that we can pass an array-like to `alphas`.
+
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/22489
+    """
+    true_cov = np.array(
+        [
+            [0.8, 0.0, 0.2, 0.0],
+            [0.0, 0.4, 0.0, 0.0],
+            [0.2, 0.0, 0.3, 0.1],
+            [0.0, 0.0, 0.1, 0.7],
+        ]
+    )
+    rng = np.random.RandomState(0)
+    X = rng.multivariate_normal(mean=[0, 0, 0, 0], cov=true_cov, size=200)
+    alphas = _convert_container([0.02, 0.03], alphas_container_type)
+    GraphicalLassoCV(alphas=alphas, tol=1e-1, n_jobs=1).fit(X)
+
+
+@pytest.mark.parametrize(
+    "alphas,err_type,err_msg",
+    [
+        ([-0.02, 0.03], ValueError, "must be > 0"),
+        ([0, 0.03], ValueError, "must be > 0"),
+        (["not_number", 0.03], TypeError, "must be an instance of float"),
+    ],
+)
+def test_graphical_lasso_cv_alphas_invalid_array(alphas, err_type, err_msg):
+    """Check that if an array-like containing a value
+    outside of (0, inf] is passed to `alphas`, a ValueError is raised.
+    Check if a string is passed, a TypeError is raised.
+    """
+    true_cov = np.array(
+        [
+            [0.8, 0.0, 0.2, 0.0],
+            [0.0, 0.4, 0.0, 0.0],
+            [0.2, 0.0, 0.3, 0.1],
+            [0.0, 0.0, 0.1, 0.7],
+        ]
+    )
+    rng = np.random.RandomState(0)
+    X = rng.multivariate_normal(mean=[0, 0, 0, 0], cov=true_cov, size=200)
+
+    with pytest.raises(err_type, match=err_msg):
+        GraphicalLassoCV(alphas=alphas, tol=1e-1, n_jobs=1).fit(X)
+
+
+def test_graphical_lasso_cv_scores():
+    splits = 4
+    n_alphas = 5
+    n_refinements = 3
+    true_cov = np.array(
+        [
+            [0.8, 0.0, 0.2, 0.0],
+            [0.0, 0.4, 0.0, 0.0],
+            [0.2, 0.0, 0.3, 0.1],
+            [0.0, 0.0, 0.1, 0.7],
+        ]
+    )
+    rng = np.random.RandomState(0)
+    X = rng.multivariate_normal(mean=[0, 0, 0, 0], cov=true_cov, size=200)
+    cov = GraphicalLassoCV(cv=splits, alphas=n_alphas, n_refinements=n_refinements).fit(
+        X
+    )
+
+    _assert_graphical_lasso_cv_scores(
+        cov=cov,
+        n_splits=splits,
+        n_refinements=n_refinements,
+        n_alphas=n_alphas,
+    )
+
+
+@config_context(enable_metadata_routing=True)
+def test_graphical_lasso_cv_scores_with_routing(global_random_seed):
+    """Check that `GraphicalLassoCV` internally dispatches metadata to
+    the splitter.
+    """
+    splits = 5
+    n_alphas = 5
+    n_refinements = 3
+    true_cov = np.array(
+        [
+            [0.8, 0.0, 0.2, 0.0],
+            [0.0, 0.4, 0.0, 0.0],
+            [0.2, 0.0, 0.3, 0.1],
+            [0.0, 0.0, 0.1, 0.7],
+        ]
+    )
+    rng = np.random.RandomState(global_random_seed)
+    X = rng.multivariate_normal(mean=[0, 0, 0, 0], cov=true_cov, size=300)
+    n_samples = X.shape[0]
+    groups = rng.randint(0, 5, n_samples)
+    params = {"groups": groups}
+    cv = GroupKFold(n_splits=splits)
+    cv.set_split_request(groups=True)
+
+    cov = GraphicalLassoCV(cv=cv, alphas=n_alphas, n_refinements=n_refinements).fit(
+        X, **params
+    )
+
+    _assert_graphical_lasso_cv_scores(
+        cov=cov,
+        n_splits=splits,
+        n_refinements=n_refinements,
+        n_alphas=n_alphas,
+    )
+
+
+def _assert_graphical_lasso_cv_scores(cov, n_splits, n_refinements, n_alphas):
+    cv_results = cov.cv_results_
+    # alpha and one for each split
+
+    total_alphas = n_refinements * n_alphas + 1
+    keys = ["alphas"]
+    split_keys = [f"split{i}_test_score" for i in range(n_splits)]
+    for key in keys + split_keys:
+        assert key in cv_results
+        assert len(cv_results[key]) == total_alphas
+
+    cv_scores = np.asarray([cov.cv_results_[key] for key in split_keys])
+    expected_mean = cv_scores.mean(axis=0)
+    expected_std = cv_scores.std(axis=0)
+
+    assert_allclose(cov.cv_results_["mean_test_score"], expected_mean)
+    assert_allclose(cov.cv_results_["std_test_score"], expected_std)

evalkit_tf437/lib/python3.10/site-packages/sklearn/covariance/tests/test_robust_covariance.py

@@ -0,0 +1,168 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import itertools
+
+import numpy as np
+import pytest
+
+from sklearn import datasets
+from sklearn.covariance import MinCovDet, empirical_covariance, fast_mcd
+from sklearn.utils._testing import assert_array_almost_equal
+
+X = datasets.load_iris().data
+X_1d = X[:, 0]
+n_samples, n_features = X.shape
+
+
+def test_mcd(global_random_seed):
+    # Tests the FastMCD algorithm implementation
+    # Small data set
+    # test without outliers (random independent normal data)
+    launch_mcd_on_dataset(100, 5, 0, 0.02, 0.1, 75, global_random_seed)
+    # test with a contaminated data set (medium contamination)
+    launch_mcd_on_dataset(100, 5, 20, 0.3, 0.3, 65, global_random_seed)
+    # test with a contaminated data set (strong contamination)
+    launch_mcd_on_dataset(100, 5, 40, 0.1, 0.1, 50, global_random_seed)
+
+    # Medium data set
+    launch_mcd_on_dataset(1000, 5, 450, 0.1, 0.1, 540, global_random_seed)
+
+    # Large data set
+    launch_mcd_on_dataset(1700, 5, 800, 0.1, 0.1, 870, global_random_seed)
+
+    # 1D data set
+    launch_mcd_on_dataset(500, 1, 100, 0.02, 0.02, 350, global_random_seed)
+
+
+def test_fast_mcd_on_invalid_input():
+    X = np.arange(100)
+    msg = "Expected 2D array, got 1D array instead"
+    with pytest.raises(ValueError, match=msg):
+        fast_mcd(X)
+
+
+def test_mcd_class_on_invalid_input():
+    X = np.arange(100)
+    mcd = MinCovDet()
+    msg = "Expected 2D array, got 1D array instead"
+    with pytest.raises(ValueError, match=msg):
+        mcd.fit(X)
+
+
+def launch_mcd_on_dataset(
+    n_samples, n_features, n_outliers, tol_loc, tol_cov, tol_support, seed
+):
+    rand_gen = np.random.RandomState(seed)
+    data = rand_gen.randn(n_samples, n_features)
+    # add some outliers
+    outliers_index = rand_gen.permutation(n_samples)[:n_outliers]
+    outliers_offset = 10.0 * (rand_gen.randint(2, size=(n_outliers, n_features)) - 0.5)
+    data[outliers_index] += outliers_offset
+    inliers_mask = np.ones(n_samples).astype(bool)
+    inliers_mask[outliers_index] = False
+
+    pure_data = data[inliers_mask]
+    # compute MCD by fitting an object
+    mcd_fit = MinCovDet(random_state=seed).fit(data)
+    T = mcd_fit.location_
+    S = mcd_fit.covariance_
+    H = mcd_fit.support_
+    # compare with the estimates learnt from the inliers
+    error_location = np.mean((pure_data.mean(0) - T) ** 2)
+    assert error_location < tol_loc
+    error_cov = np.mean((empirical_covariance(pure_data) - S) ** 2)
+    assert error_cov < tol_cov
+    assert np.sum(H) >= tol_support
+    assert_array_almost_equal(mcd_fit.mahalanobis(data), mcd_fit.dist_)
+
+
+def test_mcd_issue1127():
+    # Check that the code does not break with X.shape = (3, 1)
+    # (i.e. n_support = n_samples)
+    rnd = np.random.RandomState(0)
+    X = rnd.normal(size=(3, 1))
+    mcd = MinCovDet()
+    mcd.fit(X)
+
+
+def test_mcd_issue3367(global_random_seed):
+    # Check that MCD completes when the covariance matrix is singular
+    # i.e. one of the rows and columns are all zeros
+    rand_gen = np.random.RandomState(global_random_seed)
+
+    # Think of these as the values for X and Y -> 10 values between -5 and 5
+    data_values = np.linspace(-5, 5, 10).tolist()
+    # Get the cartesian product of all possible coordinate pairs from above set
+    data = np.array(list(itertools.product(data_values, data_values)))
+
+    # Add a third column that's all zeros to make our data a set of point
+    # within a plane, which means that the covariance matrix will be singular
+    data = np.hstack((data, np.zeros((data.shape[0], 1))))
+
+    # The below line of code should raise an exception if the covariance matrix
+    # is singular. As a further test, since we have points in XYZ, the
+    # principle components (Eigenvectors) of these directly relate to the
+    # geometry of the points. Since it's a plane, we should be able to test
+    # that the Eigenvector that corresponds to the smallest Eigenvalue is the
+    # plane normal, specifically [0, 0, 1], since everything is in the XY plane
+    # (as I've set it up above). To do this one would start by:
+    #
+    #     evals, evecs = np.linalg.eigh(mcd_fit.covariance_)
+    #     normal = evecs[:, np.argmin(evals)]
+    #
+    # After which we need to assert that our `normal` is equal to [0, 0, 1].
+    # Do note that there is floating point error associated with this, so it's
+    # best to subtract the two and then compare some small tolerance (e.g.
+    # 1e-12).
+    MinCovDet(random_state=rand_gen).fit(data)
+
+
+def test_mcd_support_covariance_is_zero():
+    # Check that MCD returns a ValueError with informative message when the
+    # covariance of the support data is equal to 0.
+    X_1 = np.array([0.5, 0.1, 0.1, 0.1, 0.957, 0.1, 0.1, 0.1, 0.4285, 0.1])
+    X_1 = X_1.reshape(-1, 1)
+    X_2 = np.array([0.5, 0.3, 0.3, 0.3, 0.957, 0.3, 0.3, 0.3, 0.4285, 0.3])
+    X_2 = X_2.reshape(-1, 1)
+    msg = (
+        "The covariance matrix of the support data is equal to 0, try to "
+        "increase support_fraction"
+    )
+    for X in [X_1, X_2]:
+        with pytest.raises(ValueError, match=msg):
+            MinCovDet().fit(X)
+
+
+def test_mcd_increasing_det_warning(global_random_seed):
+    # Check that a warning is raised if we observe increasing determinants
+    # during the c_step. In theory the sequence of determinants should be
+    # decreasing. Increasing determinants are likely due to ill-conditioned
+    # covariance matrices that result in poor precision matrices.
+
+    X = [
+        [5.1, 3.5, 1.4, 0.2],
+        [4.9, 3.0, 1.4, 0.2],
+        [4.7, 3.2, 1.3, 0.2],
+        [4.6, 3.1, 1.5, 0.2],
+        [5.0, 3.6, 1.4, 0.2],
+        [4.6, 3.4, 1.4, 0.3],
+        [5.0, 3.4, 1.5, 0.2],
+        [4.4, 2.9, 1.4, 0.2],
+        [4.9, 3.1, 1.5, 0.1],
+        [5.4, 3.7, 1.5, 0.2],
+        [4.8, 3.4, 1.6, 0.2],
+        [4.8, 3.0, 1.4, 0.1],
+        [4.3, 3.0, 1.1, 0.1],
+        [5.1, 3.5, 1.4, 0.3],
+        [5.7, 3.8, 1.7, 0.3],
+        [5.4, 3.4, 1.7, 0.2],
+        [4.6, 3.6, 1.0, 0.2],
+        [5.0, 3.0, 1.6, 0.2],
+        [5.2, 3.5, 1.5, 0.2],
+    ]
+
+    mcd = MinCovDet(support_fraction=0.5, random_state=global_random_seed)
+    warn_msg = "Determinant has increased"
+    with pytest.warns(RuntimeWarning, match=warn_msg):
+        mcd.fit(X)