Add files using upload-large-folder tool

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/units/tests/test_dimensions.py

@@ -0,0 +1,150 @@
+from sympy.physics.units.systems.si import dimsys_SI
+
+from sympy.core.numbers import pi
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, atan2, cos)
+from sympy.physics.units.dimensions import Dimension
+from sympy.physics.units.definitions.dimension_definitions import (
+    length, time, mass, force, pressure, angle
+)
+from sympy.physics.units import foot
+from sympy.testing.pytest import raises
+
+
+def test_Dimension_definition():
+    assert dimsys_SI.get_dimensional_dependencies(length) == {length: 1}
+    assert length.name == Symbol("length")
+    assert length.symbol == Symbol("L")
+
+    halflength = sqrt(length)
+    assert dimsys_SI.get_dimensional_dependencies(halflength) == {length: S.Half}
+
+
+def test_Dimension_error_definition():
+    # tuple with more or less than two entries
+    raises(TypeError, lambda: Dimension(("length", 1, 2)))
+    raises(TypeError, lambda: Dimension(["length"]))
+
+    # non-number power
+    raises(TypeError, lambda: Dimension({"length": "a"}))
+
+    # non-number with named argument
+    raises(TypeError, lambda: Dimension({"length": (1, 2)}))
+
+    # symbol should by Symbol or str
+    raises(AssertionError, lambda: Dimension("length", symbol=1))
+
+
+def test_str():
+    assert str(Dimension("length")) == "Dimension(length)"
+    assert str(Dimension("length", "L")) == "Dimension(length, L)"
+
+
+def test_Dimension_properties():
+    assert dimsys_SI.is_dimensionless(length) is False
+    assert dimsys_SI.is_dimensionless(length/length) is True
+    assert dimsys_SI.is_dimensionless(Dimension("undefined")) is False
+
+    assert length.has_integer_powers(dimsys_SI) is True
+    assert (length**(-1)).has_integer_powers(dimsys_SI) is True
+    assert (length**1.5).has_integer_powers(dimsys_SI) is False
+
+
+def test_Dimension_add_sub():
+    assert length + length == length
+    assert length - length == length
+    assert -length == length
+
+    raises(TypeError, lambda: length + foot)
+    raises(TypeError, lambda: foot + length)
+    raises(TypeError, lambda: length - foot)
+    raises(TypeError, lambda: foot - length)
+
+    # issue 14547 - only raise error for dimensional args; allow
+    # others to pass
+    x = Symbol('x')
+    e = length + x
+    assert e == x + length and e.is_Add and set(e.args) == {length, x}
+    e = length + 1
+    assert e == 1 + length == 1 - length and e.is_Add and set(e.args) == {length, 1}
+
+    assert dimsys_SI.get_dimensional_dependencies(mass * length / time**2 + force) == \
+            {length: 1, mass: 1, time: -2}
+    assert dimsys_SI.get_dimensional_dependencies(mass * length / time**2 + force -
+                                                   pressure * length**2) == \
+            {length: 1, mass: 1, time: -2}
+
+    raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(mass * length / time**2 + pressure))
+
+def test_Dimension_mul_div_exp():
+    assert 2*length == length*2 == length/2 == length
+    assert 2/length == 1/length
+    x = Symbol('x')
+    m = x*length
+    assert m == length*x and m.is_Mul and set(m.args) == {x, length}
+    d = x/length
+    assert d == x*length**-1 and d.is_Mul and set(d.args) == {x, 1/length}
+    d = length/x
+    assert d == length*x**-1 and d.is_Mul and set(d.args) == {1/x, length}
+
+    velo = length / time
+
+    assert (length * length) == length ** 2
+
+    assert dimsys_SI.get_dimensional_dependencies(length * length) == {length: 2}
+    assert dimsys_SI.get_dimensional_dependencies(length ** 2) == {length: 2}
+    assert dimsys_SI.get_dimensional_dependencies(length * time) == {length: 1, time: 1}
+    assert dimsys_SI.get_dimensional_dependencies(velo) == {length: 1, time: -1}
+    assert dimsys_SI.get_dimensional_dependencies(velo ** 2) == {length: 2, time: -2}
+
+    assert dimsys_SI.get_dimensional_dependencies(length / length) == {}
+    assert dimsys_SI.get_dimensional_dependencies(velo / length * time) == {}
+    assert dimsys_SI.get_dimensional_dependencies(length ** -1) == {length: -1}
+    assert dimsys_SI.get_dimensional_dependencies(velo ** -1.5) == {length: -1.5, time: 1.5}
+
+    length_a = length**"a"
+    assert dimsys_SI.get_dimensional_dependencies(length_a) == {length: Symbol("a")}
+
+    assert dimsys_SI.get_dimensional_dependencies(length**pi) == {length: pi}
+    assert dimsys_SI.get_dimensional_dependencies(length**(length/length)) == {length: Dimension(1)}
+
+    raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(length**length))
+
+    assert length != 1
+    assert length / length != 1
+
+    length_0 = length ** 0
+    assert dimsys_SI.get_dimensional_dependencies(length_0) == {}
+
+    # issue 18738
+    a = Symbol('a')
+    b = Symbol('b')
+    c = sqrt(a**2 + b**2)
+    c_dim = c.subs({a: length, b: length})
+    assert dimsys_SI.equivalent_dims(c_dim, length)
+
+def test_Dimension_functions():
+    raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(cos(length)))
+    raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(acos(angle)))
+    raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(atan2(length, time)))
+    raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(log(length)))
+    raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(log(100, length)))
+    raises(TypeError, lambda: dimsys_SI.get_dimensional_dependencies(log(length, 10)))
+
+    assert dimsys_SI.get_dimensional_dependencies(pi) == {}
+
+    assert dimsys_SI.get_dimensional_dependencies(cos(1)) == {}
+    assert dimsys_SI.get_dimensional_dependencies(cos(angle)) == {}
+
+    assert dimsys_SI.get_dimensional_dependencies(atan2(length, length)) == {}
+
+    assert dimsys_SI.get_dimensional_dependencies(log(length / length, length / length)) == {}
+
+    assert dimsys_SI.get_dimensional_dependencies(Abs(length)) == {length: 1}
+    assert dimsys_SI.get_dimensional_dependencies(Abs(length / length)) == {}
+
+    assert dimsys_SI.get_dimensional_dependencies(sqrt(-1)) == {}

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/units/tests/test_dimensionsystem.py

@@ -0,0 +1,95 @@
+from sympy.core.symbol import symbols
+from sympy.matrices.dense import (Matrix, eye)
+from sympy.physics.units.definitions.dimension_definitions import (
+    action, current, length, mass, time,
+    velocity)
+from sympy.physics.units.dimensions import DimensionSystem
+
+
+def test_extend():
+    ms = DimensionSystem((length, time), (velocity,))
+
+    mks = ms.extend((mass,), (action,))
+
+    res = DimensionSystem((length, time, mass), (velocity, action))
+    assert mks.base_dims == res.base_dims
+    assert mks.derived_dims == res.derived_dims
+
+
+def test_list_dims():
+    dimsys = DimensionSystem((length, time, mass))
+
+    assert dimsys.list_can_dims == (length, mass, time)
+
+
+def test_dim_can_vector():
+    dimsys = DimensionSystem(
+        [length, mass, time],
+        [velocity, action],
+        {
+            velocity: {length: 1, time: -1}
+        }
+    )
+
+    assert dimsys.dim_can_vector(length) == Matrix([1, 0, 0])
+    assert dimsys.dim_can_vector(velocity) == Matrix([1, 0, -1])
+
+    dimsys = DimensionSystem(
+        (length, velocity, action),
+        (mass, time),
+        {
+            time: {length: 1, velocity: -1}
+        }
+    )
+
+    assert dimsys.dim_can_vector(length) == Matrix([0, 1, 0])
+    assert dimsys.dim_can_vector(velocity) == Matrix([0, 0, 1])
+    assert dimsys.dim_can_vector(time) == Matrix([0, 1, -1])
+
+    dimsys = DimensionSystem(
+        (length, mass, time),
+        (velocity, action),
+        {velocity: {length: 1, time: -1},
+         action: {mass: 1, length: 2, time: -1}})
+
+    assert dimsys.dim_vector(length) == Matrix([1, 0, 0])
+    assert dimsys.dim_vector(velocity) == Matrix([1, 0, -1])
+
+
+def test_inv_can_transf_matrix():
+    dimsys = DimensionSystem((length, mass, time))
+    assert dimsys.inv_can_transf_matrix == eye(3)
+
+
+def test_can_transf_matrix():
+    dimsys = DimensionSystem((length, mass, time))
+    assert dimsys.can_transf_matrix == eye(3)
+
+    dimsys = DimensionSystem((length, velocity, action))
+    assert dimsys.can_transf_matrix == eye(3)
+
+    dimsys = DimensionSystem((length, time), (velocity,), {velocity: {length: 1, time: -1}})
+    assert dimsys.can_transf_matrix == eye(2)
+
+
+def test_is_consistent():
+    assert DimensionSystem((length, time)).is_consistent is True
+
+
+def test_print_dim_base():
+    mksa = DimensionSystem(
+        (length, time, mass, current),
+        (action,),
+        {action: {mass: 1, length: 2, time: -1}})
+    L, M, T = symbols("L M T")
+    assert mksa.print_dim_base(action) == L**2*M/T
+
+
+def test_dim():
+    dimsys = DimensionSystem(
+        (length, mass, time),
+        (velocity, action),
+        {velocity: {length: 1, time: -1},
+         action: {mass: 1, length: 2, time: -1}}
+    )
+    assert dimsys.dim == 3

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/units/tests/test_prefixes.py

@@ -0,0 +1,86 @@
+from sympy.core.mul import Mul
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.physics.units import Quantity, length, meter, W
+from sympy.physics.units.prefixes import PREFIXES, Prefix, prefix_unit, kilo, \
+    kibi
+from sympy.physics.units.systems import SI
+
+x = Symbol('x')
+
+
+def test_prefix_operations():
+    m = PREFIXES['m']
+    k = PREFIXES['k']
+    M = PREFIXES['M']
+
+    dodeca = Prefix('dodeca', 'dd', 1, base=12)
+
+    assert m * k is S.One
+    assert m * W == W / 1000
+    assert k * k == M
+    assert 1 / m == k
+    assert k / m == M
+
+    assert dodeca * dodeca == 144
+    assert 1 / dodeca == S.One / 12
+    assert k / dodeca == S(1000) / 12
+    assert dodeca / dodeca is S.One
+
+    m = Quantity("fake_meter")
+    SI.set_quantity_dimension(m, S.One)
+    SI.set_quantity_scale_factor(m, S.One)
+
+    assert dodeca * m == 12 * m
+    assert dodeca / m == 12 / m
+
+    expr1 = kilo * 3
+    assert isinstance(expr1, Mul)
+    assert expr1.args == (3, kilo)
+
+    expr2 = kilo * x
+    assert isinstance(expr2, Mul)
+    assert expr2.args == (x, kilo)
+
+    expr3 = kilo / 3
+    assert isinstance(expr3, Mul)
+    assert expr3.args == (Rational(1, 3), kilo)
+    assert expr3.args == (S.One/3, kilo)
+
+    expr4 = kilo / x
+    assert isinstance(expr4, Mul)
+    assert expr4.args == (1/x, kilo)
+
+
+def test_prefix_unit():
+    m = Quantity("fake_meter", abbrev="m")
+    m.set_global_relative_scale_factor(1, meter)
+
+    pref = {"m": PREFIXES["m"], "c": PREFIXES["c"], "d": PREFIXES["d"]}
+
+    q1 = Quantity("millifake_meter", abbrev="mm")
+    q2 = Quantity("centifake_meter", abbrev="cm")
+    q3 = Quantity("decifake_meter", abbrev="dm")
+
+    SI.set_quantity_dimension(q1, length)
+
+    SI.set_quantity_scale_factor(q1, PREFIXES["m"])
+    SI.set_quantity_scale_factor(q1, PREFIXES["c"])
+    SI.set_quantity_scale_factor(q1, PREFIXES["d"])
+
+    res = [q1, q2, q3]
+
+    prefs = prefix_unit(m, pref)
+    assert set(prefs) == set(res)
+    assert {v.abbrev for v in prefs} == set(symbols("mm,cm,dm"))
+
+
+def test_bases():
+    assert kilo.base == 10
+    assert kibi.base == 2
+
+
+def test_repr():
+    assert eval(repr(kilo)) == kilo
+    assert eval(repr(kibi)) == kibi

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/units/tests/test_quantities.py

@@ -0,0 +1,575 @@
+import warnings
+
+from sympy.core.add import Add
+from sympy.core.function import (Function, diff)
+from sympy.core.numbers import (Number, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.integrals.integrals import integrate
+from sympy.physics.units import (amount_of_substance, area, convert_to, find_unit,
+                                 volume, kilometer, joule, molar_gas_constant,
+                                 vacuum_permittivity, elementary_charge, volt,
+                                 ohm)
+from sympy.physics.units.definitions import (amu, au, centimeter, coulomb,
+    day, foot, grams, hour, inch, kg, km, m, meter, millimeter,
+    minute, quart, s, second, speed_of_light, bit,
+    byte, kibibyte, mebibyte, gibibyte, tebibyte, pebibyte, exbibyte,
+    kilogram, gravitational_constant, electron_rest_mass)
+
+from sympy.physics.units.definitions.dimension_definitions import (
+    Dimension, charge, length, time, temperature, pressure,
+    energy, mass
+)
+from sympy.physics.units.prefixes import PREFIXES, kilo
+from sympy.physics.units.quantities import PhysicalConstant, Quantity
+from sympy.physics.units.systems import SI
+from sympy.testing.pytest import raises
+
+k = PREFIXES["k"]
+
+
+def test_str_repr():
+    assert str(kg) == "kilogram"
+
+
+def test_eq():
+    # simple test
+    assert 10*m == 10*m
+    assert 10*m != 10*s
+
+
+def test_convert_to():
+    q = Quantity("q1")
+    q.set_global_relative_scale_factor(S(5000), meter)
+
+    assert q.convert_to(m) == 5000*m
+
+    assert speed_of_light.convert_to(m / s) == 299792458 * m / s
+    assert day.convert_to(s) == 86400*s
+
+    # Wrong dimension to convert:
+    assert q.convert_to(s) == q
+    assert speed_of_light.convert_to(m) == speed_of_light
+
+    expr = joule*second
+    conv = convert_to(expr, joule)
+    assert conv == joule*second
+
+
+def test_Quantity_definition():
+    q = Quantity("s10", abbrev="sabbr")
+    q.set_global_relative_scale_factor(10, second)
+    u = Quantity("u", abbrev="dam")
+    u.set_global_relative_scale_factor(10, meter)
+    km = Quantity("km")
+    km.set_global_relative_scale_factor(kilo, meter)
+    v = Quantity("u")
+    v.set_global_relative_scale_factor(5*kilo, meter)
+
+    assert q.scale_factor == 10
+    assert q.dimension == time
+    assert q.abbrev == Symbol("sabbr")
+
+    assert u.dimension == length
+    assert u.scale_factor == 10
+    assert u.abbrev == Symbol("dam")
+
+    assert km.scale_factor == 1000
+    assert km.func(*km.args) == km
+    assert km.func(*km.args).args == km.args
+
+    assert v.dimension == length
+    assert v.scale_factor == 5000
+
+
+def test_abbrev():
+    u = Quantity("u")
+    u.set_global_relative_scale_factor(S.One, meter)
+
+    assert u.name == Symbol("u")
+    assert u.abbrev == Symbol("u")
+
+    u = Quantity("u", abbrev="om")
+    u.set_global_relative_scale_factor(S(2), meter)
+
+    assert u.name == Symbol("u")
+    assert u.abbrev == Symbol("om")
+    assert u.scale_factor == 2
+    assert isinstance(u.scale_factor, Number)
+
+    u = Quantity("u", abbrev="ikm")
+    u.set_global_relative_scale_factor(3*kilo, meter)
+
+    assert u.abbrev == Symbol("ikm")
+    assert u.scale_factor == 3000
+
+
+def test_print():
+    u = Quantity("unitname", abbrev="dam")
+    assert repr(u) == "unitname"
+    assert str(u) == "unitname"
+
+
+def test_Quantity_eq():
+    u = Quantity("u", abbrev="dam")
+    v = Quantity("v1")
+    assert u != v
+    v = Quantity("v2", abbrev="ds")
+    assert u != v
+    v = Quantity("v3", abbrev="dm")
+    assert u != v
+
+
+def test_add_sub():
+    u = Quantity("u")
+    v = Quantity("v")
+    w = Quantity("w")
+
+    u.set_global_relative_scale_factor(S(10), meter)
+    v.set_global_relative_scale_factor(S(5), meter)
+    w.set_global_relative_scale_factor(S(2), second)
+
+    assert isinstance(u + v, Add)
+    assert (u + v.convert_to(u)) == (1 + S.Half)*u
+    assert isinstance(u - v, Add)
+    assert (u - v.convert_to(u)) == S.Half*u
+
+
+def test_quantity_abs():
+    v_w1 = Quantity('v_w1')
+    v_w2 = Quantity('v_w2')
+    v_w3 = Quantity('v_w3')
+
+    v_w1.set_global_relative_scale_factor(1, meter/second)
+    v_w2.set_global_relative_scale_factor(1, meter/second)
+    v_w3.set_global_relative_scale_factor(1, meter/second)
+
+    expr = v_w3 - Abs(v_w1 - v_w2)
+
+    assert SI.get_dimensional_expr(v_w1) == (length/time).name
+
+    Dq = Dimension(SI.get_dimensional_expr(expr))
+
+    assert SI.get_dimension_system().get_dimensional_dependencies(Dq) == {
+        length: 1,
+        time: -1,
+    }
+    assert meter == sqrt(meter**2)
+
+
+def test_check_unit_consistency():
+    u = Quantity("u")
+    v = Quantity("v")
+    w = Quantity("w")
+
+    u.set_global_relative_scale_factor(S(10), meter)
+    v.set_global_relative_scale_factor(S(5), meter)
+    w.set_global_relative_scale_factor(S(2), second)
+
+    def check_unit_consistency(expr):
+        SI._collect_factor_and_dimension(expr)
+
+    raises(ValueError, lambda: check_unit_consistency(u + w))
+    raises(ValueError, lambda: check_unit_consistency(u - w))
+    raises(ValueError, lambda: check_unit_consistency(u + 1))
+    raises(ValueError, lambda: check_unit_consistency(u - 1))
+    raises(ValueError, lambda: check_unit_consistency(1 - exp(u / w)))
+
+
+def test_mul_div():
+    u = Quantity("u")
+    v = Quantity("v")
+    t = Quantity("t")
+    ut = Quantity("ut")
+    v2 = Quantity("v")
+
+    u.set_global_relative_scale_factor(S(10), meter)
+    v.set_global_relative_scale_factor(S(5), meter)
+    t.set_global_relative_scale_factor(S(2), second)
+    ut.set_global_relative_scale_factor(S(20), meter*second)
+    v2.set_global_relative_scale_factor(S(5), meter/second)
+
+    assert 1 / u == u**(-1)
+    assert u / 1 == u
+
+    v1 = u / t
+    v2 = v
+
+    # Pow only supports structural equality:
+    assert v1 != v2
+    assert v1 == v2.convert_to(v1)
+
+    # TODO: decide whether to allow such expression in the future
+    # (requires somehow manipulating the core).
+    # assert u / Quantity('l2', dimension=length, scale_factor=2) == 5
+
+    assert u * 1 == u
+
+    ut1 = u * t
+    ut2 = ut
+
+    # Mul only supports structural equality:
+    assert ut1 != ut2
+    assert ut1 == ut2.convert_to(ut1)
+
+    # Mul only supports structural equality:
+    lp1 = Quantity("lp1")
+    lp1.set_global_relative_scale_factor(S(2), 1/meter)
+    assert u * lp1 != 20
+
+    assert u**0 == 1
+    assert u**1 == u
+
+    # TODO: Pow only support structural equality:
+    u2 = Quantity("u2")
+    u3 = Quantity("u3")
+    u2.set_global_relative_scale_factor(S(100), meter**2)
+    u3.set_global_relative_scale_factor(Rational(1, 10), 1/meter)
+
+    assert u ** 2 != u2
+    assert u ** -1 != u3
+
+    assert u ** 2 == u2.convert_to(u)
+    assert u ** -1 == u3.convert_to(u)
+
+
+def test_units():
+    assert convert_to((5*m/s * day) / km, 1) == 432
+    assert convert_to(foot / meter, meter) == Rational(3048, 10000)
+    # amu is a pure mass so mass/mass gives a number, not an amount (mol)
+    # TODO: need better simplification routine:
+    assert str(convert_to(grams/amu, grams).n(2)) == '6.0e+23'
+
+    # Light from the sun needs about 8.3 minutes to reach earth
+    t = (1*au / speed_of_light) / minute
+    # TODO: need a better way to simplify expressions containing units:
+    t = convert_to(convert_to(t, meter / minute), meter)
+    assert t.simplify() == Rational(49865956897, 5995849160)
+
+    # TODO: fix this, it should give `m` without `Abs`
+    assert sqrt(m**2) == m
+    assert (sqrt(m))**2 == m
+
+    t = Symbol('t')
+    assert integrate(t*m/s, (t, 1*s, 5*s)) == 12*m*s
+    assert (t * m/s).integrate((t, 1*s, 5*s)) == 12*m*s
+
+
+def test_issue_quart():
+    assert convert_to(4 * quart / inch ** 3, meter) == 231
+    assert convert_to(4 * quart / inch ** 3, millimeter) == 231
+
+def test_electron_rest_mass():
+    assert convert_to(electron_rest_mass, kilogram) == 9.1093837015e-31*kilogram
+    assert convert_to(electron_rest_mass, grams) == 9.1093837015e-28*grams
+
+def test_issue_5565():
+    assert (m < s).is_Relational
+
+
+def test_find_unit():
+    assert find_unit('coulomb') == ['coulomb', 'coulombs', 'coulomb_constant']
+    assert find_unit(coulomb) == ['C', 'coulomb', 'coulombs', 'planck_charge', 'elementary_charge']
+    assert find_unit(charge) == ['C', 'coulomb', 'coulombs', 'planck_charge', 'elementary_charge']
+    assert find_unit(inch) == [
+        'm', 'au', 'cm', 'dm', 'ft', 'km', 'ly', 'mi', 'mm', 'nm', 'pm', 'um', 'yd',
+        'nmi', 'feet', 'foot', 'inch', 'mile', 'yard', 'meter', 'miles', 'yards',
+        'inches', 'meters', 'micron', 'microns', 'angstrom', 'angstroms', 'decimeter',
+        'kilometer', 'lightyear', 'nanometer', 'picometer', 'centimeter', 'decimeters',
+        'kilometers', 'lightyears', 'micrometer', 'millimeter', 'nanometers', 'picometers',
+        'centimeters', 'micrometers', 'millimeters', 'nautical_mile', 'planck_length',
+        'nautical_miles', 'astronomical_unit', 'astronomical_units']
+    assert find_unit(inch**-1) == ['D', 'dioptre', 'optical_power']
+    assert find_unit(length**-1) == ['D', 'dioptre', 'optical_power']
+    assert find_unit(inch ** 2) == ['ha', 'hectare', 'planck_area']
+    assert find_unit(inch ** 3) == [
+        'L', 'l', 'cL', 'cl', 'dL', 'dl', 'mL', 'ml', 'liter', 'quart', 'liters', 'quarts',
+        'deciliter', 'centiliter', 'deciliters', 'milliliter',
+        'centiliters', 'milliliters', 'planck_volume']
+    assert find_unit('voltage') == ['V', 'v', 'volt', 'volts', 'planck_voltage']
+    assert find_unit(grams) == ['g', 't', 'Da', 'kg', 'me', 'mg', 'ug', 'amu', 'mmu', 'amus',
+                                'gram', 'mmus', 'grams', 'pound', 'tonne', 'dalton', 'pounds',
+                                'kilogram', 'kilograms', 'microgram', 'milligram', 'metric_ton',
+                                'micrograms', 'milligrams', 'planck_mass', 'milli_mass_unit', 'atomic_mass_unit',
+                                'electron_rest_mass', 'atomic_mass_constant']
+
+
+def test_Quantity_derivative():
+    x = symbols("x")
+    assert diff(x*meter, x) == meter
+    assert diff(x**3*meter**2, x) == 3*x**2*meter**2
+    assert diff(meter, meter) == 1
+    assert diff(meter**2, meter) == 2*meter
+
+
+def test_quantity_postprocessing():
+    q1 = Quantity('q1')
+    q2 = Quantity('q2')
+
+    SI.set_quantity_dimension(q1, length*pressure**2*temperature/time)
+    SI.set_quantity_dimension(q2, energy*pressure*temperature/(length**2*time))
+
+    assert q1 + q2
+    q = q1 + q2
+    Dq = Dimension(SI.get_dimensional_expr(q))
+    assert SI.get_dimension_system().get_dimensional_dependencies(Dq) == {
+        length: -1,
+        mass: 2,
+        temperature: 1,
+        time: -5,
+    }
+
+
+def test_factor_and_dimension():
+    assert (3000, Dimension(1)) == SI._collect_factor_and_dimension(3000)
+    assert (1001, length) == SI._collect_factor_and_dimension(meter + km)
+    assert (2, length/time) == SI._collect_factor_and_dimension(
+        meter/second + 36*km/(10*hour))
+
+    x, y = symbols('x y')
+    assert (x + y/100, length) == SI._collect_factor_and_dimension(
+        x*m + y*centimeter)
+
+    cH = Quantity('cH')
+    SI.set_quantity_dimension(cH, amount_of_substance/volume)
+
+    pH = -log(cH)
+
+    assert (1, volume/amount_of_substance) == SI._collect_factor_and_dimension(
+        exp(pH))
+
+    v_w1 = Quantity('v_w1')
+    v_w2 = Quantity('v_w2')
+
+    v_w1.set_global_relative_scale_factor(Rational(3, 2), meter/second)
+    v_w2.set_global_relative_scale_factor(2, meter/second)
+
+    expr = Abs(v_w1/2 - v_w2)
+    assert (Rational(5, 4), length/time) == \
+        SI._collect_factor_and_dimension(expr)
+
+    expr = Rational(5, 2)*second/meter*v_w1 - 3000
+    assert (-(2996 + Rational(1, 4)), Dimension(1)) == \
+        SI._collect_factor_and_dimension(expr)
+
+    expr = v_w1**(v_w2/v_w1)
+    assert ((Rational(3, 2))**Rational(4, 3), (length/time)**Rational(4, 3)) == \
+        SI._collect_factor_and_dimension(expr)
+
+
+def test_dimensional_expr_of_derivative():
+    l = Quantity('l')
+    t = Quantity('t')
+    t1 = Quantity('t1')
+    l.set_global_relative_scale_factor(36, km)
+    t.set_global_relative_scale_factor(1, hour)
+    t1.set_global_relative_scale_factor(1, second)
+    x = Symbol('x')
+    y = Symbol('y')
+    f = Function('f')
+    dfdx = f(x, y).diff(x, y)
+    dl_dt = dfdx.subs({f(x, y): l, x: t, y: t1})
+    assert SI.get_dimensional_expr(dl_dt) ==\
+        SI.get_dimensional_expr(l / t / t1) ==\
+        Symbol("length")/Symbol("time")**2
+    assert SI._collect_factor_and_dimension(dl_dt) ==\
+        SI._collect_factor_and_dimension(l / t / t1) ==\
+        (10, length/time**2)
+
+
+def test_get_dimensional_expr_with_function():
+    v_w1 = Quantity('v_w1')
+    v_w2 = Quantity('v_w2')
+    v_w1.set_global_relative_scale_factor(1, meter/second)
+    v_w2.set_global_relative_scale_factor(1, meter/second)
+
+    assert SI.get_dimensional_expr(sin(v_w1)) == \
+        sin(SI.get_dimensional_expr(v_w1))
+    assert SI.get_dimensional_expr(sin(v_w1/v_w2)) == 1
+
+
+def test_binary_information():
+    assert convert_to(kibibyte, byte) == 1024*byte
+    assert convert_to(mebibyte, byte) == 1024**2*byte
+    assert convert_to(gibibyte, byte) == 1024**3*byte
+    assert convert_to(tebibyte, byte) == 1024**4*byte
+    assert convert_to(pebibyte, byte) == 1024**5*byte
+    assert convert_to(exbibyte, byte) == 1024**6*byte
+
+    assert kibibyte.convert_to(bit) == 8*1024*bit
+    assert byte.convert_to(bit) == 8*bit
+
+    a = 10*kibibyte*hour
+
+    assert convert_to(a, byte) == 10240*byte*hour
+    assert convert_to(a, minute) == 600*kibibyte*minute
+    assert convert_to(a, [byte, minute]) == 614400*byte*minute
+
+
+def test_conversion_with_2_nonstandard_dimensions():
+    good_grade = Quantity("good_grade")
+    kilo_good_grade = Quantity("kilo_good_grade")
+    centi_good_grade = Quantity("centi_good_grade")
+
+    kilo_good_grade.set_global_relative_scale_factor(1000, good_grade)
+    centi_good_grade.set_global_relative_scale_factor(S.One/10**5, kilo_good_grade)
+
+    charity_points = Quantity("charity_points")
+    milli_charity_points = Quantity("milli_charity_points")
+    missions = Quantity("missions")
+
+    milli_charity_points.set_global_relative_scale_factor(S.One/1000, charity_points)
+    missions.set_global_relative_scale_factor(251, charity_points)
+
+    assert convert_to(
+        kilo_good_grade*milli_charity_points*millimeter,
+        [centi_good_grade, missions, centimeter]
+    ) == S.One * 10**5 / (251*1000) / 10 * centi_good_grade*missions*centimeter
+
+
+def test_eval_subs():
+    energy, mass, force = symbols('energy mass force')
+    expr1 = energy/mass
+    units = {energy: kilogram*meter**2/second**2, mass: kilogram}
+    assert expr1.subs(units) == meter**2/second**2
+    expr2 = force/mass
+    units = {force:gravitational_constant*kilogram**2/meter**2, mass:kilogram}
+    assert expr2.subs(units) == gravitational_constant*kilogram/meter**2
+
+
+def test_issue_14932():
+    assert (log(inch) - log(2)).simplify() == log(inch/2)
+    assert (log(inch) - log(foot)).simplify() == -log(12)
+    p = symbols('p', positive=True)
+    assert (log(inch) - log(p)).simplify() == log(inch/p)
+
+
+def test_issue_14547():
+    # the root issue is that an argument with dimensions should
+    # not raise an error when the `arg - 1` calculation is
+    # performed in the assumptions system
+    from sympy.physics.units import foot, inch
+    from sympy.core.relational import Eq
+    assert log(foot).is_zero is None
+    assert log(foot).is_positive is None
+    assert log(foot).is_nonnegative is None
+    assert log(foot).is_negative is None
+    assert log(foot).is_algebraic is None
+    assert log(foot).is_rational is None
+    # doesn't raise error
+    assert Eq(log(foot), log(inch)) is not None  # might be False or unevaluated
+
+    x = Symbol('x')
+    e = foot + x
+    assert e.is_Add and set(e.args) == {foot, x}
+    e = foot + 1
+    assert e.is_Add and set(e.args) == {foot, 1}
+
+
+def test_issue_22164():
+    warnings.simplefilter("error")
+    dm = Quantity("dm")
+    SI.set_quantity_dimension(dm, length)
+    SI.set_quantity_scale_factor(dm, 1)
+
+    bad_exp = Quantity("bad_exp")
+    SI.set_quantity_dimension(bad_exp, length)
+    SI.set_quantity_scale_factor(bad_exp, 1)
+
+    expr = dm ** bad_exp
+
+    # deprecation warning is not expected here
+    SI._collect_factor_and_dimension(expr)
+
+
+def test_issue_22819():
+    from sympy.physics.units import tonne, gram, Da
+    from sympy.physics.units.systems.si import dimsys_SI
+    assert tonne.convert_to(gram) == 1000000*gram
+    assert dimsys_SI.get_dimensional_dependencies(area) == {length: 2}
+    assert Da.scale_factor == 1.66053906660000e-24
+
+
+def test_issue_20288():
+    from sympy.core.numbers import E
+    from sympy.physics.units import energy
+    u = Quantity('u')
+    v = Quantity('v')
+    SI.set_quantity_dimension(u, energy)
+    SI.set_quantity_dimension(v, energy)
+    u.set_global_relative_scale_factor(1, joule)
+    v.set_global_relative_scale_factor(1, joule)
+    expr = 1 + exp(u**2/v**2)
+    assert SI._collect_factor_and_dimension(expr) == (1 + E, Dimension(1))
+
+
+def test_issue_24062():
+    from sympy.core.numbers import E
+    from sympy.physics.units import impedance, capacitance, time, ohm, farad, second
+
+    R = Quantity('R')
+    C = Quantity('C')
+    T = Quantity('T')
+    SI.set_quantity_dimension(R, impedance)
+    SI.set_quantity_dimension(C, capacitance)
+    SI.set_quantity_dimension(T, time)
+    R.set_global_relative_scale_factor(1, ohm)
+    C.set_global_relative_scale_factor(1, farad)
+    T.set_global_relative_scale_factor(1, second)
+    expr = T / (R * C)
+    dim = SI._collect_factor_and_dimension(expr)[1]
+    assert SI.get_dimension_system().is_dimensionless(dim)
+
+    exp_expr = 1 + exp(expr)
+    assert SI._collect_factor_and_dimension(exp_expr) == (1 + E, Dimension(1))
+
+def test_issue_24211():
+    from sympy.physics.units import time, velocity, acceleration, second, meter
+    V1 = Quantity('V1')
+    SI.set_quantity_dimension(V1, velocity)
+    SI.set_quantity_scale_factor(V1, 1 * meter / second)
+    A1 = Quantity('A1')
+    SI.set_quantity_dimension(A1, acceleration)
+    SI.set_quantity_scale_factor(A1, 1 * meter / second**2)
+    T1 = Quantity('T1')
+    SI.set_quantity_dimension(T1, time)
+    SI.set_quantity_scale_factor(T1, 1 * second)
+
+    expr = A1*T1 + V1
+    # should not throw ValueError here
+    SI._collect_factor_and_dimension(expr)
+
+
+def test_prefixed_property():
+    assert not meter.is_prefixed
+    assert not joule.is_prefixed
+    assert not day.is_prefixed
+    assert not second.is_prefixed
+    assert not volt.is_prefixed
+    assert not ohm.is_prefixed
+    assert centimeter.is_prefixed
+    assert kilometer.is_prefixed
+    assert kilogram.is_prefixed
+    assert pebibyte.is_prefixed
+
+def test_physics_constant():
+    from sympy.physics.units import definitions
+
+    for name in dir(definitions):
+        quantity = getattr(definitions, name)
+        if not isinstance(quantity, Quantity):
+            continue
+        if name.endswith('_constant'):
+            assert isinstance(quantity, PhysicalConstant), f"{quantity} must be PhysicalConstant, but is {type(quantity)}"
+            assert quantity.is_physical_constant, f"{name} is not marked as physics constant when it should be"
+
+    for const in [gravitational_constant, molar_gas_constant, vacuum_permittivity, speed_of_light, elementary_charge]:
+        assert isinstance(const, PhysicalConstant), f"{const} must be PhysicalConstant, but is {type(const)}"
+        assert const.is_physical_constant, f"{const} is not marked as physics constant when it should be"
+
+    assert not meter.is_physical_constant
+    assert not joule.is_physical_constant

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/units/tests/test_unit_system_cgs_gauss.py

@@ -0,0 +1,55 @@
+from sympy.concrete.tests.test_sums_products import NS
+
+from sympy.core.singleton import S
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.physics.units import convert_to, coulomb_constant, elementary_charge, gravitational_constant, planck
+from sympy.physics.units.definitions.unit_definitions import angstrom, statcoulomb, coulomb, second, gram, centimeter, erg, \
+    newton, joule, dyne, speed_of_light, meter, farad, henry, statvolt, volt, ohm
+from sympy.physics.units.systems import SI
+from sympy.physics.units.systems.cgs import cgs_gauss
+
+
+def test_conversion_to_from_si():
+    assert convert_to(statcoulomb, coulomb, cgs_gauss) == coulomb/2997924580
+    assert convert_to(coulomb, statcoulomb, cgs_gauss) == 2997924580*statcoulomb
+    assert convert_to(statcoulomb, sqrt(gram*centimeter**3)/second, cgs_gauss) == centimeter**(S(3)/2)*sqrt(gram)/second
+    assert convert_to(coulomb, sqrt(gram*centimeter**3)/second, cgs_gauss) == 2997924580*centimeter**(S(3)/2)*sqrt(gram)/second
+
+    # SI units have an additional base unit, no conversion in case of electromagnetism:
+    assert convert_to(coulomb, statcoulomb, SI) == coulomb
+    assert convert_to(statcoulomb, coulomb, SI) == statcoulomb
+
+    # SI without electromagnetism:
+    assert convert_to(erg, joule, SI) == joule/10**7
+    assert convert_to(erg, joule, cgs_gauss) == joule/10**7
+    assert convert_to(joule, erg, SI) == 10**7*erg
+    assert convert_to(joule, erg, cgs_gauss) == 10**7*erg
+
+
+    assert convert_to(dyne, newton, SI) == newton/10**5
+    assert convert_to(dyne, newton, cgs_gauss) == newton/10**5
+    assert convert_to(newton, dyne, SI) == 10**5*dyne
+    assert convert_to(newton, dyne, cgs_gauss) == 10**5*dyne
+
+
+def test_cgs_gauss_convert_constants():
+
+    assert convert_to(speed_of_light, centimeter/second, cgs_gauss) == 29979245800*centimeter/second
+
+    assert convert_to(coulomb_constant, 1, cgs_gauss) == 1
+    assert convert_to(coulomb_constant, newton*meter**2/coulomb**2, cgs_gauss) == 22468879468420441*meter**2*newton/(2500000*coulomb**2)
+    assert convert_to(coulomb_constant, newton*meter**2/coulomb**2, SI) == 22468879468420441*meter**2*newton/(2500000*coulomb**2)
+    assert convert_to(coulomb_constant, dyne*centimeter**2/statcoulomb**2, cgs_gauss) == centimeter**2*dyne/statcoulomb**2
+    assert convert_to(coulomb_constant, 1, SI) == coulomb_constant
+    assert NS(convert_to(coulomb_constant, newton*meter**2/coulomb**2, SI)) == '8987551787.36818*meter**2*newton/coulomb**2'
+
+    assert convert_to(elementary_charge, statcoulomb, cgs_gauss)
+    assert convert_to(angstrom, centimeter, cgs_gauss) == 1*centimeter/10**8
+    assert convert_to(gravitational_constant, dyne*centimeter**2/gram**2, cgs_gauss)
+    assert NS(convert_to(planck, erg*second, cgs_gauss)) == '6.62607015e-27*erg*second'
+
+    spc = 25000*second/(22468879468420441*centimeter)
+    assert convert_to(ohm, second/centimeter, cgs_gauss) == spc
+    assert convert_to(henry, second**2/centimeter, cgs_gauss) == spc*second
+    assert convert_to(volt, statvolt, cgs_gauss) == 10**6*statvolt/299792458
+    assert convert_to(farad, centimeter, cgs_gauss) == 299792458**2*centimeter/10**5

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/units/tests/test_unitsystem.py

@@ -0,0 +1,86 @@
+from sympy.physics.units import DimensionSystem, joule, second, ampere
+
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.physics.units.definitions import c, kg, m, s
+from sympy.physics.units.definitions.dimension_definitions import length, time
+from sympy.physics.units.quantities import Quantity
+from sympy.physics.units.unitsystem import UnitSystem
+from sympy.physics.units.util import convert_to
+
+
+def test_definition():
+    # want to test if the system can have several units of the same dimension
+    dm = Quantity("dm")
+    base = (m, s)
+    # base_dim = (m.dimension, s.dimension)
+    ms = UnitSystem(base, (c, dm), "MS", "MS system")
+    ms.set_quantity_dimension(dm, length)
+    ms.set_quantity_scale_factor(dm, Rational(1, 10))
+
+    assert set(ms._base_units) == set(base)
+    assert set(ms._units) == {m, s, c, dm}
+    # assert ms._units == DimensionSystem._sort_dims(base + (velocity,))
+    assert ms.name == "MS"
+    assert ms.descr == "MS system"
+
+
+def test_str_repr():
+    assert str(UnitSystem((m, s), name="MS")) == "MS"
+    assert str(UnitSystem((m, s))) == "UnitSystem((meter, second))"
+
+    assert repr(UnitSystem((m, s))) == "<UnitSystem: (%s, %s)>" % (m, s)
+
+
+def test_convert_to():
+    A = Quantity("A")
+    A.set_global_relative_scale_factor(S.One, ampere)
+
+    Js = Quantity("Js")
+    Js.set_global_relative_scale_factor(S.One, joule*second)
+
+    mksa = UnitSystem((m, kg, s, A), (Js,))
+    assert convert_to(Js, mksa._base_units) == m**2*kg*s**-1/1000
+
+
+def test_extend():
+    ms = UnitSystem((m, s), (c,))
+    Js = Quantity("Js")
+    Js.set_global_relative_scale_factor(1, joule*second)
+    mks = ms.extend((kg,), (Js,))
+
+    res = UnitSystem((m, s, kg), (c, Js))
+    assert set(mks._base_units) == set(res._base_units)
+    assert set(mks._units) == set(res._units)
+
+
+def test_dim():
+    dimsys = UnitSystem((m, kg, s), (c,))
+    assert dimsys.dim == 3
+
+
+def test_is_consistent():
+    dimension_system = DimensionSystem([length, time])
+    us = UnitSystem([m, s], dimension_system=dimension_system)
+    assert us.is_consistent == True
+
+
+def test_get_units_non_prefixed():
+    from sympy.physics.units import volt, ohm
+    unit_system = UnitSystem.get_unit_system("SI")
+    units = unit_system.get_units_non_prefixed()
+    for prefix in ["giga", "tera", "peta", "exa", "zetta", "yotta", "kilo", "hecto", "deca", "deci", "centi", "milli", "micro", "nano", "pico", "femto", "atto", "zepto", "yocto"]:
+        for unit in units:
+            assert isinstance(unit, Quantity), f"{unit} must be a Quantity, not {type(unit)}"
+            assert not unit.is_prefixed, f"{unit} is marked as prefixed"
+            assert not unit.is_physical_constant, f"{unit} is marked as physics constant"
+            assert not unit.name.name.startswith(prefix), f"Unit {unit.name} has prefix {prefix}"
+    assert volt in units
+    assert ohm in units
+
+def test_derived_units_must_exist_in_unit_system():
+    for unit_system in UnitSystem._unit_systems.values():
+        for preferred_unit in unit_system.derived_units.values():
+            units = preferred_unit.atoms(Quantity)
+            for unit in units:
+                assert unit in unit_system._units, f"Unit {unit} is not in unit system {unit_system}"

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/units/tests/test_util.py

@@ -0,0 +1,178 @@
+from sympy.core.containers import Tuple
+from sympy.core.numbers import pi
+from sympy.core.power import Pow
+from sympy.core.symbol import symbols
+from sympy.core.sympify import sympify
+from sympy.printing.str import sstr
+from sympy.physics.units import (
+    G, centimeter, coulomb, day, degree, gram, hbar, hour, inch, joule, kelvin,
+    kilogram, kilometer, length, meter, mile, minute, newton, planck,
+    planck_length, planck_mass, planck_temperature, planck_time, radians,
+    second, speed_of_light, steradian, time, km)
+from sympy.physics.units.util import convert_to, check_dimensions
+from sympy.testing.pytest import raises
+from sympy.functions.elementary.miscellaneous import sqrt
+
+
+def NS(e, n=15, **options):
+    return sstr(sympify(e).evalf(n, **options), full_prec=True)
+
+
+L = length
+T = time
+
+
+def test_dim_simplify_add():
+    # assert Add(L, L) == L
+    assert L + L == L
+
+
+def test_dim_simplify_mul():
+    # assert Mul(L, T) == L*T
+    assert L*T == L*T
+
+
+def test_dim_simplify_pow():
+    assert Pow(L, 2) == L**2
+
+
+def test_dim_simplify_rec():
+    # assert Mul(Add(L, L), T) == L*T
+    assert (L + L) * T == L*T
+
+
+def test_convert_to_quantities():
+    assert convert_to(3, meter) == 3
+
+    assert convert_to(mile, kilometer) == 25146*kilometer/15625
+    assert convert_to(meter/second, speed_of_light) == speed_of_light/299792458
+    assert convert_to(299792458*meter/second, speed_of_light) == speed_of_light
+    assert convert_to(2*299792458*meter/second, speed_of_light) == 2*speed_of_light
+    assert convert_to(speed_of_light, meter/second) == 299792458*meter/second
+    assert convert_to(2*speed_of_light, meter/second) == 599584916*meter/second
+    assert convert_to(day, second) == 86400*second
+    assert convert_to(2*hour, minute) == 120*minute
+    assert convert_to(mile, meter) == 201168*meter/125
+    assert convert_to(mile/hour, kilometer/hour) == 25146*kilometer/(15625*hour)
+    assert convert_to(3*newton, meter/second) == 3*newton
+    assert convert_to(3*newton, kilogram*meter/second**2) == 3*meter*kilogram/second**2
+    assert convert_to(kilometer + mile, meter) == 326168*meter/125
+    assert convert_to(2*kilometer + 3*mile, meter) == 853504*meter/125
+    assert convert_to(inch**2, meter**2) == 16129*meter**2/25000000
+    assert convert_to(3*inch**2, meter) == 48387*meter**2/25000000
+    assert convert_to(2*kilometer/hour + 3*mile/hour, meter/second) == 53344*meter/(28125*second)
+    assert convert_to(2*kilometer/hour + 3*mile/hour, centimeter/second) == 213376*centimeter/(1125*second)
+    assert convert_to(kilometer * (mile + kilometer), meter) == 2609344 * meter ** 2
+
+    assert convert_to(steradian, coulomb) == steradian
+    assert convert_to(radians, degree) == 180*degree/pi
+    assert convert_to(radians, [meter, degree]) == 180*degree/pi
+    assert convert_to(pi*radians, degree) == 180*degree
+    assert convert_to(pi, degree) == 180*degree
+
+    # https://github.com/sympy/sympy/issues/26263
+    assert convert_to(sqrt(meter**2 + meter**2.0), meter) == sqrt(meter**2 + meter**2.0)
+    assert convert_to((meter**2 + meter**2.0)**2, meter) == (meter**2 + meter**2.0)**2
+
+
+def test_convert_to_tuples_of_quantities():
+    from sympy.core.symbol import symbols
+
+    alpha, beta = symbols('alpha beta')
+
+    assert convert_to(speed_of_light, [meter, second]) == 299792458 * meter / second
+    assert convert_to(speed_of_light, (meter, second)) == 299792458 * meter / second
+    assert convert_to(speed_of_light, Tuple(meter, second)) == 299792458 * meter / second
+    assert convert_to(joule, [meter, kilogram, second]) == kilogram*meter**2/second**2
+    assert convert_to(joule, [centimeter, gram, second]) == 10000000*centimeter**2*gram/second**2
+    assert convert_to(299792458*meter/second, [speed_of_light]) == speed_of_light
+    assert convert_to(speed_of_light / 2, [meter, second, kilogram]) == meter/second*299792458 / 2
+    # This doesn't make physically sense, but let's keep it as a conversion test:
+    assert convert_to(2 * speed_of_light, [meter, second, kilogram]) == 2 * 299792458 * meter / second
+    assert convert_to(G, [G, speed_of_light, planck]) == 1.0*G
+
+    assert NS(convert_to(meter, [G, speed_of_light, hbar]), n=7) == '6.187142e+34*gravitational_constant**0.5000000*hbar**0.5000000/speed_of_light**1.500000'
+    assert NS(convert_to(planck_mass, kilogram), n=7) == '2.176434e-8*kilogram'
+    assert NS(convert_to(planck_length, meter), n=7) == '1.616255e-35*meter'
+    assert NS(convert_to(planck_time, second), n=6) == '5.39125e-44*second'
+    assert NS(convert_to(planck_temperature, kelvin), n=7) == '1.416784e+32*kelvin'
+    assert NS(convert_to(convert_to(meter, [G, speed_of_light, planck]), meter), n=10) == '1.000000000*meter'
+
+    # similar to https://github.com/sympy/sympy/issues/26263
+    assert convert_to(sqrt(meter**2 + second**2.0), [meter, second]) == sqrt(meter**2 + second**2.0)
+    assert convert_to((meter**2 + second**2.0)**2, [meter, second]) == (meter**2 + second**2.0)**2
+
+    # similar to https://github.com/sympy/sympy/issues/21463
+    assert convert_to(1/(beta*meter + meter), 1/meter) == 1/(beta*meter + meter)
+    assert convert_to(1/(beta*meter + alpha*meter), 1/kilometer) == (1/(kilometer*beta/1000 + alpha*kilometer/1000))
+
+def test_eval_simplify():
+    from sympy.physics.units import cm, mm, km, m, K, kilo
+    from sympy.core.symbol import symbols
+
+    x, y = symbols('x y')
+
+    assert (cm/mm).simplify() == 10
+    assert (km/m).simplify() == 1000
+    assert (km/cm).simplify() == 100000
+    assert (10*x*K*km**2/m/cm).simplify() == 1000000000*x*kelvin
+    assert (cm/km/m).simplify() == 1/(10000000*centimeter)
+
+    assert (3*kilo*meter).simplify() == 3000*meter
+    assert (4*kilo*meter/(2*kilometer)).simplify() == 2
+    assert (4*kilometer**2/(kilo*meter)**2).simplify() == 4
+
+
+def test_quantity_simplify():
+    from sympy.physics.units.util import quantity_simplify
+    from sympy.physics.units import kilo, foot
+    from sympy.core.symbol import symbols
+
+    x, y = symbols('x y')
+
+    assert quantity_simplify(x*(8*kilo*newton*meter + y)) == x*(8000*meter*newton + y)
+    assert quantity_simplify(foot*inch*(foot + inch)) == foot**2*(foot + foot/12)/12
+    assert quantity_simplify(foot*inch*(foot*foot + inch*(foot + inch))) == foot**2*(foot**2 + foot/12*(foot + foot/12))/12
+    assert quantity_simplify(2**(foot/inch*kilo/1000)*inch) == 4096*foot/12
+    assert quantity_simplify(foot**2*inch + inch**2*foot) == 13*foot**3/144
+
+def test_quantity_simplify_across_dimensions():
+    from sympy.physics.units.util import quantity_simplify
+    from sympy.physics.units import ampere, ohm, volt, joule, pascal, farad, second, watt, siemens, henry, tesla, weber, hour, newton
+
+    assert quantity_simplify(ampere*ohm, across_dimensions=True, unit_system="SI") == volt
+    assert quantity_simplify(6*ampere*ohm, across_dimensions=True, unit_system="SI") == 6*volt
+    assert quantity_simplify(volt/ampere, across_dimensions=True, unit_system="SI") == ohm
+    assert quantity_simplify(volt/ohm, across_dimensions=True, unit_system="SI") == ampere
+    assert quantity_simplify(joule/meter**3, across_dimensions=True, unit_system="SI") == pascal
+    assert quantity_simplify(farad*ohm, across_dimensions=True, unit_system="SI") == second
+    assert quantity_simplify(joule/second, across_dimensions=True, unit_system="SI") == watt
+    assert quantity_simplify(meter**3/second, across_dimensions=True, unit_system="SI") == meter**3/second
+    assert quantity_simplify(joule/second, across_dimensions=True, unit_system="SI") == watt
+
+    assert quantity_simplify(joule/coulomb, across_dimensions=True, unit_system="SI") == volt
+    assert quantity_simplify(volt/ampere, across_dimensions=True, unit_system="SI") == ohm
+    assert quantity_simplify(ampere/volt, across_dimensions=True, unit_system="SI") == siemens
+    assert quantity_simplify(coulomb/volt, across_dimensions=True, unit_system="SI") == farad
+    assert quantity_simplify(volt*second/ampere, across_dimensions=True, unit_system="SI") == henry
+    assert quantity_simplify(volt*second/meter**2, across_dimensions=True, unit_system="SI") == tesla
+    assert quantity_simplify(joule/ampere, across_dimensions=True, unit_system="SI") == weber
+
+    assert quantity_simplify(5*kilometer/hour, across_dimensions=True, unit_system="SI") == 25*meter/(18*second)
+    assert quantity_simplify(5*kilogram*meter/second**2, across_dimensions=True, unit_system="SI") == 5*newton
+
+def test_check_dimensions():
+    x = symbols('x')
+    assert check_dimensions(inch + x) == inch + x
+    assert check_dimensions(length + x) == length + x
+    # after subs we get 2*length; check will clear the constant
+    assert check_dimensions((length + x).subs(x, length)) == length
+    assert check_dimensions(newton*meter + joule) == joule + meter*newton
+    raises(ValueError, lambda: check_dimensions(inch + 1))
+    raises(ValueError, lambda: check_dimensions(length + 1))
+    raises(ValueError, lambda: check_dimensions(length + time))
+    raises(ValueError, lambda: check_dimensions(meter + second))
+    raises(ValueError, lambda: check_dimensions(2 * meter + second))
+    raises(ValueError, lambda: check_dimensions(2 * meter + 3 * second))
+    raises(ValueError, lambda: check_dimensions(1 / second + 1 / meter))
+    raises(ValueError, lambda: check_dimensions(2 * meter*(mile + centimeter) + km))

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/vector/__init__.py

@@ -0,0 +1,36 @@
+__all__ = [
+    'CoordinateSym', 'ReferenceFrame',
+
+    'Dyadic',
+
+    'Vector',
+
+    'Point',
+
+    'cross', 'dot', 'express', 'time_derivative', 'outer',
+    'kinematic_equations', 'get_motion_params', 'partial_velocity',
+    'dynamicsymbols',
+
+    'vprint', 'vsstrrepr', 'vsprint', 'vpprint', 'vlatex', 'init_vprinting',
+
+    'curl', 'divergence', 'gradient', 'is_conservative', 'is_solenoidal',
+    'scalar_potential', 'scalar_potential_difference',
+
+]
+from .frame import CoordinateSym, ReferenceFrame
+
+from .dyadic import Dyadic
+
+from .vector import Vector
+
+from .point import Point
+
+from .functions import (cross, dot, express, time_derivative, outer,
+        kinematic_equations, get_motion_params, partial_velocity,
+        dynamicsymbols)
+
+from .printing import (vprint, vsstrrepr, vsprint, vpprint, vlatex,
+        init_vprinting)
+
+from .fieldfunctions import (curl, divergence, gradient, is_conservative,
+        is_solenoidal, scalar_potential, scalar_potential_difference)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/vector/dyadic.py

@@ -0,0 +1,545 @@
+from sympy import sympify, Add, ImmutableMatrix as Matrix
+from sympy.core.evalf import EvalfMixin
+from sympy.printing.defaults import Printable
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+__all__ = ['Dyadic']
+
+
+class Dyadic(Printable, EvalfMixin):
+    """A Dyadic object.
+
+    See:
+    https://en.wikipedia.org/wiki/Dyadic_tensor
+    Kane, T., Levinson, D. Dynamics Theory and Applications. 1985 McGraw-Hill
+
+    A more powerful way to represent a rigid body's inertia. While it is more
+    complex, by choosing Dyadic components to be in body fixed basis vectors,
+    the resulting matrix is equivalent to the inertia tensor.
+
+    """
+
+    is_number = False
+
+    def __init__(self, inlist):
+        """
+        Just like Vector's init, you should not call this unless creating a
+        zero dyadic.
+
+        zd = Dyadic(0)
+
+        Stores a Dyadic as a list of lists; the inner list has the measure
+        number and the two unit vectors; the outerlist holds each unique
+        unit vector pair.
+
+        """
+
+        self.args = []
+        if inlist == 0:
+            inlist = []
+        while len(inlist) != 0:
+            added = 0
+            for i, v in enumerate(self.args):
+                if ((str(inlist[0][1]) == str(self.args[i][1])) and
+                        (str(inlist[0][2]) == str(self.args[i][2]))):
+                    self.args[i] = (self.args[i][0] + inlist[0][0],
+                                    inlist[0][1], inlist[0][2])
+                    inlist.remove(inlist[0])
+                    added = 1
+                    break
+            if added != 1:
+                self.args.append(inlist[0])
+                inlist.remove(inlist[0])
+        i = 0
+        # This code is to remove empty parts from the list
+        while i < len(self.args):
+            if ((self.args[i][0] == 0) | (self.args[i][1] == 0) |
+                    (self.args[i][2] == 0)):
+                self.args.remove(self.args[i])
+                i -= 1
+            i += 1
+
+    @property
+    def func(self):
+        """Returns the class Dyadic. """
+        return Dyadic
+
+    def __add__(self, other):
+        """The add operator for Dyadic. """
+        other = _check_dyadic(other)
+        return Dyadic(self.args + other.args)
+
+    __radd__ = __add__
+
+    def __mul__(self, other):
+        """Multiplies the Dyadic by a sympifyable expression.
+
+        Parameters
+        ==========
+
+        other : Sympafiable
+            The scalar to multiply this Dyadic with
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, outer
+        >>> N = ReferenceFrame('N')
+        >>> d = outer(N.x, N.x)
+        >>> 5 * d
+        5*(N.x|N.x)
+
+        """
+        newlist = list(self.args)
+        other = sympify(other)
+        for i in range(len(newlist)):
+            newlist[i] = (other * newlist[i][0], newlist[i][1],
+                          newlist[i][2])
+        return Dyadic(newlist)
+
+    __rmul__ = __mul__
+
+    def dot(self, other):
+        """The inner product operator for a Dyadic and a Dyadic or Vector.
+
+        Parameters
+        ==========
+
+        other : Dyadic or Vector
+            The other Dyadic or Vector to take the inner product with
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, outer
+        >>> N = ReferenceFrame('N')
+        >>> D1 = outer(N.x, N.y)
+        >>> D2 = outer(N.y, N.y)
+        >>> D1.dot(D2)
+        (N.x|N.y)
+        >>> D1.dot(N.y)
+        N.x
+
+        """
+        from sympy.physics.vector.vector import Vector, _check_vector
+        if isinstance(other, Dyadic):
+            other = _check_dyadic(other)
+            ol = Dyadic(0)
+            for v in self.args:
+                for v2 in other.args:
+                    ol += v[0] * v2[0] * (v[2].dot(v2[1])) * (v[1].outer(v2[2]))
+        else:
+            other = _check_vector(other)
+            ol = Vector(0)
+            for v in self.args:
+                ol += v[0] * v[1] * (v[2].dot(other))
+        return ol
+
+    # NOTE : supports non-advertised Dyadic & Dyadic, Dyadic & Vector notation
+    __and__ = dot
+
+    def __truediv__(self, other):
+        """Divides the Dyadic by a sympifyable expression. """
+        return self.__mul__(1 / other)
+
+    def __eq__(self, other):
+        """Tests for equality.
+
+        Is currently weak; needs stronger comparison testing
+
+        """
+
+        if other == 0:
+            other = Dyadic(0)
+        other = _check_dyadic(other)
+        if (self.args == []) and (other.args == []):
+            return True
+        elif (self.args == []) or (other.args == []):
+            return False
+        return set(self.args) == set(other.args)
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __neg__(self):
+        return self * -1
+
+    def _latex(self, printer):
+        ar = self.args  # just to shorten things
+        if len(ar) == 0:
+            return str(0)
+        ol = []  # output list, to be concatenated to a string
+        for v in ar:
+            # if the coef of the dyadic is 1, we skip the 1
+            if v[0] == 1:
+                ol.append(' + ' + printer._print(v[1]) + r"\otimes " +
+                          printer._print(v[2]))
+            # if the coef of the dyadic is -1, we skip the 1
+            elif v[0] == -1:
+                ol.append(' - ' +
+                          printer._print(v[1]) +
+                          r"\otimes " +
+                          printer._print(v[2]))
+            # If the coefficient of the dyadic is not 1 or -1,
+            # we might wrap it in parentheses, for readability.
+            elif v[0] != 0:
+                arg_str = printer._print(v[0])
+                if isinstance(v[0], Add):
+                    arg_str = '(%s)' % arg_str
+                if arg_str.startswith('-'):
+                    arg_str = arg_str[1:]
+                    str_start = ' - '
+                else:
+                    str_start = ' + '
+                ol.append(str_start + arg_str + printer._print(v[1]) +
+                          r"\otimes " + printer._print(v[2]))
+        outstr = ''.join(ol)
+        if outstr.startswith(' + '):
+            outstr = outstr[3:]
+        elif outstr.startswith(' '):
+            outstr = outstr[1:]
+        return outstr
+
+    def _pretty(self, printer):
+        e = self
+
+        class Fake:
+            baseline = 0
+
+            def render(self, *args, **kwargs):
+                ar = e.args  # just to shorten things
+                mpp = printer
+                if len(ar) == 0:
+                    return str(0)
+                bar = "\N{CIRCLED TIMES}" if printer._use_unicode else "|"
+                ol = []  # output list, to be concatenated to a string
+                for v in ar:
+                    # if the coef of the dyadic is 1, we skip the 1
+                    if v[0] == 1:
+                        ol.extend([" + ",
+                                  mpp.doprint(v[1]),
+                                  bar,
+                                  mpp.doprint(v[2])])
+
+                    # if the coef of the dyadic is -1, we skip the 1
+                    elif v[0] == -1:
+                        ol.extend([" - ",
+                                  mpp.doprint(v[1]),
+                                  bar,
+                                  mpp.doprint(v[2])])
+
+                    # If the coefficient of the dyadic is not 1 or -1,
+                    # we might wrap it in parentheses, for readability.
+                    elif v[0] != 0:
+                        if isinstance(v[0], Add):
+                            arg_str = mpp._print(
+                                v[0]).parens()[0]
+                        else:
+                            arg_str = mpp.doprint(v[0])
+                        if arg_str.startswith("-"):
+                            arg_str = arg_str[1:]
+                            str_start = " - "
+                        else:
+                            str_start = " + "
+                        ol.extend([str_start, arg_str, " ",
+                                  mpp.doprint(v[1]),
+                                  bar,
+                                  mpp.doprint(v[2])])
+
+                outstr = "".join(ol)
+                if outstr.startswith(" + "):
+                    outstr = outstr[3:]
+                elif outstr.startswith(" "):
+                    outstr = outstr[1:]
+                return outstr
+        return Fake()
+
+    def __rsub__(self, other):
+        return (-1 * self) + other
+
+    def _sympystr(self, printer):
+        """Printing method. """
+        ar = self.args  # just to shorten things
+        if len(ar) == 0:
+            return printer._print(0)
+        ol = []  # output list, to be concatenated to a string
+        for v in ar:
+            # if the coef of the dyadic is 1, we skip the 1
+            if v[0] == 1:
+                ol.append(' + (' + printer._print(v[1]) + '|' +
+                          printer._print(v[2]) + ')')
+            # if the coef of the dyadic is -1, we skip the 1
+            elif v[0] == -1:
+                ol.append(' - (' + printer._print(v[1]) + '|' +
+                          printer._print(v[2]) + ')')
+            # If the coefficient of the dyadic is not 1 or -1,
+            # we might wrap it in parentheses, for readability.
+            elif v[0] != 0:
+                arg_str = printer._print(v[0])
+                if isinstance(v[0], Add):
+                    arg_str = "(%s)" % arg_str
+                if arg_str[0] == '-':
+                    arg_str = arg_str[1:]
+                    str_start = ' - '
+                else:
+                    str_start = ' + '
+                ol.append(str_start + arg_str + '*(' +
+                          printer._print(v[1]) +
+                          '|' + printer._print(v[2]) + ')')
+        outstr = ''.join(ol)
+        if outstr.startswith(' + '):
+            outstr = outstr[3:]
+        elif outstr.startswith(' '):
+            outstr = outstr[1:]
+        return outstr
+
+    def __sub__(self, other):
+        """The subtraction operator. """
+        return self.__add__(other * -1)
+
+    def cross(self, other):
+        """Returns the dyadic resulting from the dyadic vector cross product:
+        Dyadic x Vector.
+
+        Parameters
+        ==========
+        other : Vector
+            Vector to cross with.
+
+        Examples
+        ========
+        >>> from sympy.physics.vector import ReferenceFrame, outer, cross
+        >>> N = ReferenceFrame('N')
+        >>> d = outer(N.x, N.x)
+        >>> cross(d, N.y)
+        (N.x|N.z)
+
+        """
+        from sympy.physics.vector.vector import _check_vector
+        other = _check_vector(other)
+        ol = Dyadic(0)
+        for v in self.args:
+            ol += v[0] * (v[1].outer((v[2].cross(other))))
+        return ol
+
+    # NOTE : supports non-advertised Dyadic ^ Vector notation
+    __xor__ = cross
+
+    def express(self, frame1, frame2=None):
+        """Expresses this Dyadic in alternate frame(s)
+
+        The first frame is the list side expression, the second frame is the
+        right side; if Dyadic is in form A.x|B.y, you can express it in two
+        different frames. If no second frame is given, the Dyadic is
+        expressed in only one frame.
+
+        Calls the global express function
+
+        Parameters
+        ==========
+
+        frame1 : ReferenceFrame
+            The frame to express the left side of the Dyadic in
+        frame2 : ReferenceFrame
+            If provided, the frame to express the right side of the Dyadic in
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, outer, dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> N = ReferenceFrame('N')
+        >>> q = dynamicsymbols('q')
+        >>> B = N.orientnew('B', 'Axis', [q, N.z])
+        >>> d = outer(N.x, N.x)
+        >>> d.express(B, N)
+        cos(q)*(B.x|N.x) - sin(q)*(B.y|N.x)
+
+        """
+        from sympy.physics.vector.functions import express
+        return express(self, frame1, frame2)
+
+    def to_matrix(self, reference_frame, second_reference_frame=None):
+        """Returns the matrix form of the dyadic with respect to one or two
+        reference frames.
+
+        Parameters
+        ----------
+        reference_frame : ReferenceFrame
+            The reference frame that the rows and columns of the matrix
+            correspond to. If a second reference frame is provided, this
+            only corresponds to the rows of the matrix.
+        second_reference_frame : ReferenceFrame, optional, default=None
+            The reference frame that the columns of the matrix correspond
+            to.
+
+        Returns
+        -------
+        matrix : ImmutableMatrix, shape(3,3)
+            The matrix that gives the 2D tensor form.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, trigsimp
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> from sympy.physics.mechanics import inertia
+        >>> Ixx, Iyy, Izz, Ixy, Iyz, Ixz = symbols('Ixx, Iyy, Izz, Ixy, Iyz, Ixz')
+        >>> N = ReferenceFrame('N')
+        >>> inertia_dyadic = inertia(N, Ixx, Iyy, Izz, Ixy, Iyz, Ixz)
+        >>> inertia_dyadic.to_matrix(N)
+        Matrix([
+        [Ixx, Ixy, Ixz],
+        [Ixy, Iyy, Iyz],
+        [Ixz, Iyz, Izz]])
+        >>> beta = symbols('beta')
+        >>> A = N.orientnew('A', 'Axis', (beta, N.x))
+        >>> trigsimp(inertia_dyadic.to_matrix(A))
+        Matrix([
+        [                           Ixx,                                           Ixy*cos(beta) + Ixz*sin(beta),                                           -Ixy*sin(beta) + Ixz*cos(beta)],
+        [ Ixy*cos(beta) + Ixz*sin(beta), Iyy*cos(2*beta)/2 + Iyy/2 + Iyz*sin(2*beta) - Izz*cos(2*beta)/2 + Izz/2,                 -Iyy*sin(2*beta)/2 + Iyz*cos(2*beta) + Izz*sin(2*beta)/2],
+        [-Ixy*sin(beta) + Ixz*cos(beta),                -Iyy*sin(2*beta)/2 + Iyz*cos(2*beta) + Izz*sin(2*beta)/2, -Iyy*cos(2*beta)/2 + Iyy/2 - Iyz*sin(2*beta) + Izz*cos(2*beta)/2 + Izz/2]])
+
+        """
+
+        if second_reference_frame is None:
+            second_reference_frame = reference_frame
+
+        return Matrix([i.dot(self).dot(j) for i in reference_frame for j in
+                      second_reference_frame]).reshape(3, 3)
+
+    def doit(self, **hints):
+        """Calls .doit() on each term in the Dyadic"""
+        return sum([Dyadic([(v[0].doit(**hints), v[1], v[2])])
+                    for v in self.args], Dyadic(0))
+
+    def dt(self, frame):
+        """Take the time derivative of this Dyadic in a frame.
+
+        This function calls the global time_derivative method
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame
+            The frame to take the time derivative in
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, outer, dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> N = ReferenceFrame('N')
+        >>> q = dynamicsymbols('q')
+        >>> B = N.orientnew('B', 'Axis', [q, N.z])
+        >>> d = outer(N.x, N.x)
+        >>> d.dt(B)
+        - q'*(N.y|N.x) - q'*(N.x|N.y)
+
+        """
+        from sympy.physics.vector.functions import time_derivative
+        return time_derivative(self, frame)
+
+    def simplify(self):
+        """Returns a simplified Dyadic."""
+        out = Dyadic(0)
+        for v in self.args:
+            out += Dyadic([(v[0].simplify(), v[1], v[2])])
+        return out
+
+    def subs(self, *args, **kwargs):
+        """Substitution on the Dyadic.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> from sympy import Symbol
+        >>> N = ReferenceFrame('N')
+        >>> s = Symbol('s')
+        >>> a = s*(N.x|N.x)
+        >>> a.subs({s: 2})
+        2*(N.x|N.x)
+
+        """
+
+        return sum([Dyadic([(v[0].subs(*args, **kwargs), v[1], v[2])])
+                    for v in self.args], Dyadic(0))
+
+    def applyfunc(self, f):
+        """Apply a function to each component of a Dyadic."""
+        if not callable(f):
+            raise TypeError("`f` must be callable.")
+
+        out = Dyadic(0)
+        for a, b, c in self.args:
+            out += f(a) * (b.outer(c))
+        return out
+
+    def _eval_evalf(self, prec):
+        if not self.args:
+            return self
+        new_args = []
+        dps = prec_to_dps(prec)
+        for inlist in self.args:
+            new_inlist = list(inlist)
+            new_inlist[0] = inlist[0].evalf(n=dps)
+            new_args.append(tuple(new_inlist))
+        return Dyadic(new_args)
+
+    def xreplace(self, rule):
+        """
+        Replace occurrences of objects within the measure numbers of the
+        Dyadic.
+
+        Parameters
+        ==========
+
+        rule : dict-like
+            Expresses a replacement rule.
+
+        Returns
+        =======
+
+        Dyadic
+            Result of the replacement.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, pi
+        >>> from sympy.physics.vector import ReferenceFrame, outer
+        >>> N = ReferenceFrame('N')
+        >>> D = outer(N.x, N.x)
+        >>> x, y, z = symbols('x y z')
+        >>> ((1 + x*y) * D).xreplace({x: pi})
+        (pi*y + 1)*(N.x|N.x)
+        >>> ((1 + x*y) * D).xreplace({x: pi, y: 2})
+        (1 + 2*pi)*(N.x|N.x)
+
+        Replacements occur only if an entire node in the expression tree is
+        matched:
+
+        >>> ((x*y + z) * D).xreplace({x*y: pi})
+        (z + pi)*(N.x|N.x)
+        >>> ((x*y*z) * D).xreplace({x*y: pi})
+        x*y*z*(N.x|N.x)
+
+        """
+
+        new_args = []
+        for inlist in self.args:
+            new_inlist = list(inlist)
+            new_inlist[0] = new_inlist[0].xreplace(rule)
+            new_args.append(tuple(new_inlist))
+        return Dyadic(new_args)
+
+
+def _check_dyadic(other):
+    if not isinstance(other, Dyadic):
+        raise TypeError('A Dyadic must be supplied')
+    return other

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/vector/fieldfunctions.py

@@ -0,0 +1,313 @@
+from sympy.core.function import diff
+from sympy.core.singleton import S
+from sympy.integrals.integrals import integrate
+from sympy.physics.vector import Vector, express
+from sympy.physics.vector.frame import _check_frame
+from sympy.physics.vector.vector import _check_vector
+
+
+__all__ = ['curl', 'divergence', 'gradient', 'is_conservative',
+           'is_solenoidal', 'scalar_potential',
+           'scalar_potential_difference']
+
+
+def curl(vect, frame):
+    """
+    Returns the curl of a vector field computed wrt the coordinate
+    symbols of the given frame.
+
+    Parameters
+    ==========
+
+    vect : Vector
+        The vector operand
+
+    frame : ReferenceFrame
+        The reference frame to calculate the curl in
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame
+    >>> from sympy.physics.vector import curl
+    >>> R = ReferenceFrame('R')
+    >>> v1 = R[1]*R[2]*R.x + R[0]*R[2]*R.y + R[0]*R[1]*R.z
+    >>> curl(v1, R)
+    0
+    >>> v2 = R[0]*R[1]*R[2]*R.x
+    >>> curl(v2, R)
+    R_x*R_y*R.y - R_x*R_z*R.z
+
+    """
+
+    _check_vector(vect)
+    if vect == 0:
+        return Vector(0)
+    vect = express(vect, frame, variables=True)
+    # A mechanical approach to avoid looping overheads
+    vectx = vect.dot(frame.x)
+    vecty = vect.dot(frame.y)
+    vectz = vect.dot(frame.z)
+    outvec = Vector(0)
+    outvec += (diff(vectz, frame[1]) - diff(vecty, frame[2])) * frame.x
+    outvec += (diff(vectx, frame[2]) - diff(vectz, frame[0])) * frame.y
+    outvec += (diff(vecty, frame[0]) - diff(vectx, frame[1])) * frame.z
+    return outvec
+
+
+def divergence(vect, frame):
+    """
+    Returns the divergence of a vector field computed wrt the coordinate
+    symbols of the given frame.
+
+    Parameters
+    ==========
+
+    vect : Vector
+        The vector operand
+
+    frame : ReferenceFrame
+        The reference frame to calculate the divergence in
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame
+    >>> from sympy.physics.vector import divergence
+    >>> R = ReferenceFrame('R')
+    >>> v1 = R[0]*R[1]*R[2] * (R.x+R.y+R.z)
+    >>> divergence(v1, R)
+    R_x*R_y + R_x*R_z + R_y*R_z
+    >>> v2 = 2*R[1]*R[2]*R.y
+    >>> divergence(v2, R)
+    2*R_z
+
+    """
+
+    _check_vector(vect)
+    if vect == 0:
+        return S.Zero
+    vect = express(vect, frame, variables=True)
+    vectx = vect.dot(frame.x)
+    vecty = vect.dot(frame.y)
+    vectz = vect.dot(frame.z)
+    out = S.Zero
+    out += diff(vectx, frame[0])
+    out += diff(vecty, frame[1])
+    out += diff(vectz, frame[2])
+    return out
+
+
+def gradient(scalar, frame):
+    """
+    Returns the vector gradient of a scalar field computed wrt the
+    coordinate symbols of the given frame.
+
+    Parameters
+    ==========
+
+    scalar : sympifiable
+        The scalar field to take the gradient of
+
+    frame : ReferenceFrame
+        The frame to calculate the gradient in
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame
+    >>> from sympy.physics.vector import gradient
+    >>> R = ReferenceFrame('R')
+    >>> s1 = R[0]*R[1]*R[2]
+    >>> gradient(s1, R)
+    R_y*R_z*R.x + R_x*R_z*R.y + R_x*R_y*R.z
+    >>> s2 = 5*R[0]**2*R[2]
+    >>> gradient(s2, R)
+    10*R_x*R_z*R.x + 5*R_x**2*R.z
+
+    """
+
+    _check_frame(frame)
+    outvec = Vector(0)
+    scalar = express(scalar, frame, variables=True)
+    for i, x in enumerate(frame):
+        outvec += diff(scalar, frame[i]) * x  # noqa: PLR1736
+    return outvec
+
+
+def is_conservative(field):
+    """
+    Checks if a field is conservative.
+
+    Parameters
+    ==========
+
+    field : Vector
+        The field to check for conservative property
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame
+    >>> from sympy.physics.vector import is_conservative
+    >>> R = ReferenceFrame('R')
+    >>> is_conservative(R[1]*R[2]*R.x + R[0]*R[2]*R.y + R[0]*R[1]*R.z)
+    True
+    >>> is_conservative(R[2] * R.y)
+    False
+
+    """
+
+    # Field is conservative irrespective of frame
+    # Take the first frame in the result of the separate method of Vector
+    if field == Vector(0):
+        return True
+    frame = list(field.separate())[0]
+    return curl(field, frame).simplify() == Vector(0)
+
+
+def is_solenoidal(field):
+    """
+    Checks if a field is solenoidal.
+
+    Parameters
+    ==========
+
+    field : Vector
+        The field to check for solenoidal property
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame
+    >>> from sympy.physics.vector import is_solenoidal
+    >>> R = ReferenceFrame('R')
+    >>> is_solenoidal(R[1]*R[2]*R.x + R[0]*R[2]*R.y + R[0]*R[1]*R.z)
+    True
+    >>> is_solenoidal(R[1] * R.y)
+    False
+
+    """
+
+    # Field is solenoidal irrespective of frame
+    # Take the first frame in the result of the separate method in Vector
+    if field == Vector(0):
+        return True
+    frame = list(field.separate())[0]
+    return divergence(field, frame).simplify() is S.Zero
+
+
+def scalar_potential(field, frame):
+    """
+    Returns the scalar potential function of a field in a given frame
+    (without the added integration constant).
+
+    Parameters
+    ==========
+
+    field : Vector
+        The vector field whose scalar potential function is to be
+        calculated
+
+    frame : ReferenceFrame
+        The frame to do the calculation in
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame
+    >>> from sympy.physics.vector import scalar_potential, gradient
+    >>> R = ReferenceFrame('R')
+    >>> scalar_potential(R.z, R) == R[2]
+    True
+    >>> scalar_field = 2*R[0]**2*R[1]*R[2]
+    >>> grad_field = gradient(scalar_field, R)
+    >>> scalar_potential(grad_field, R)
+    2*R_x**2*R_y*R_z
+
+    """
+
+    # Check whether field is conservative
+    if not is_conservative(field):
+        raise ValueError("Field is not conservative")
+    if field == Vector(0):
+        return S.Zero
+    # Express the field exntirely in frame
+    # Substitute coordinate variables also
+    _check_frame(frame)
+    field = express(field, frame, variables=True)
+    # Make a list of dimensions of the frame
+    dimensions = list(frame)
+    # Calculate scalar potential function
+    temp_function = integrate(field.dot(dimensions[0]), frame[0])
+    for i, dim in enumerate(dimensions[1:]):
+        partial_diff = diff(temp_function, frame[i + 1])
+        partial_diff = field.dot(dim) - partial_diff
+        temp_function += integrate(partial_diff, frame[i + 1])
+    return temp_function
+
+
+def scalar_potential_difference(field, frame, point1, point2, origin):
+    """
+    Returns the scalar potential difference between two points in a
+    certain frame, wrt a given field.
+
+    If a scalar field is provided, its values at the two points are
+    considered. If a conservative vector field is provided, the values
+    of its scalar potential function at the two points are used.
+
+    Returns (potential at position 2) - (potential at position 1)
+
+    Parameters
+    ==========
+
+    field : Vector/sympyfiable
+        The field to calculate wrt
+
+    frame : ReferenceFrame
+        The frame to do the calculations in
+
+    point1 : Point
+        The initial Point in given frame
+
+    position2 : Point
+        The second Point in the given frame
+
+    origin : Point
+        The Point to use as reference point for position vector
+        calculation
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame, Point
+    >>> from sympy.physics.vector import scalar_potential_difference
+    >>> R = ReferenceFrame('R')
+    >>> O = Point('O')
+    >>> P = O.locatenew('P', R[0]*R.x + R[1]*R.y + R[2]*R.z)
+    >>> vectfield = 4*R[0]*R[1]*R.x + 2*R[0]**2*R.y
+    >>> scalar_potential_difference(vectfield, R, O, P, O)
+    2*R_x**2*R_y
+    >>> Q = O.locatenew('O', 3*R.x + R.y + 2*R.z)
+    >>> scalar_potential_difference(vectfield, R, P, Q, O)
+    -2*R_x**2*R_y + 18
+
+    """
+
+    _check_frame(frame)
+    if isinstance(field, Vector):
+        # Get the scalar potential function
+        scalar_fn = scalar_potential(field, frame)
+    else:
+        # Field is a scalar
+        scalar_fn = field
+    # Express positions in required frame
+    position1 = express(point1.pos_from(origin), frame, variables=True)
+    position2 = express(point2.pos_from(origin), frame, variables=True)
+    # Get the two positions as substitution dicts for coordinate variables
+    subs_dict1 = {}
+    subs_dict2 = {}
+    for i, x in enumerate(frame):
+        subs_dict1[frame[i]] = x.dot(position1)
+        subs_dict2[frame[i]] = x.dot(position2)
+    return scalar_fn.subs(subs_dict2) - scalar_fn.subs(subs_dict1)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/vector/frame.py

@@ -0,0 +1,1575 @@
+from sympy import (diff, expand, sin, cos, sympify, eye, zeros,
+                                ImmutableMatrix as Matrix, MatrixBase)
+from sympy.core.symbol import Symbol
+from sympy.simplify.trigsimp import trigsimp
+from sympy.physics.vector.vector import Vector, _check_vector
+from sympy.utilities.misc import translate
+
+from warnings import warn
+
+__all__ = ['CoordinateSym', 'ReferenceFrame']
+
+
+class CoordinateSym(Symbol):
+    """
+    A coordinate symbol/base scalar associated wrt a Reference Frame.
+
+    Ideally, users should not instantiate this class. Instances of
+    this class must only be accessed through the corresponding frame
+    as 'frame[index]'.
+
+    CoordinateSyms having the same frame and index parameters are equal
+    (even though they may be instantiated separately).
+
+    Parameters
+    ==========
+
+    name : string
+        The display name of the CoordinateSym
+
+    frame : ReferenceFrame
+        The reference frame this base scalar belongs to
+
+    index : 0, 1 or 2
+        The index of the dimension denoted by this coordinate variable
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame, CoordinateSym
+    >>> A = ReferenceFrame('A')
+    >>> A[1]
+    A_y
+    >>> type(A[0])
+    <class 'sympy.physics.vector.frame.CoordinateSym'>
+    >>> a_y = CoordinateSym('a_y', A, 1)
+    >>> a_y == A[1]
+    True
+
+    """
+
+    def __new__(cls, name, frame, index):
+        # We can't use the cached Symbol.__new__ because this class depends on
+        # frame and index, which are not passed to Symbol.__xnew__.
+        assumptions = {}
+        super()._sanitize(assumptions, cls)
+        obj = super().__xnew__(cls, name, **assumptions)
+        _check_frame(frame)
+        if index not in range(0, 3):
+            raise ValueError("Invalid index specified")
+        obj._id = (frame, index)
+        return obj
+
+    def __getnewargs_ex__(self):
+        return (self.name, *self._id), {}
+
+    @property
+    def frame(self):
+        return self._id[0]
+
+    def __eq__(self, other):
+        # Check if the other object is a CoordinateSym of the same frame and
+        # same index
+        if isinstance(other, CoordinateSym):
+            if other._id == self._id:
+                return True
+        return False
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __hash__(self):
+        return (self._id[0].__hash__(), self._id[1]).__hash__()
+
+
+class ReferenceFrame:
+    """A reference frame in classical mechanics.
+
+    ReferenceFrame is a class used to represent a reference frame in classical
+    mechanics. It has a standard basis of three unit vectors in the frame's
+    x, y, and z directions.
+
+    It also can have a rotation relative to a parent frame; this rotation is
+    defined by a direction cosine matrix relating this frame's basis vectors to
+    the parent frame's basis vectors.  It can also have an angular velocity
+    vector, defined in another frame.
+
+    """
+    _count = 0
+
+    def __init__(self, name, indices=None, latexs=None, variables=None):
+        """ReferenceFrame initialization method.
+
+        A ReferenceFrame has a set of orthonormal basis vectors, along with
+        orientations relative to other ReferenceFrames and angular velocities
+        relative to other ReferenceFrames.
+
+        Parameters
+        ==========
+
+        indices : tuple of str
+            Enables the reference frame's basis unit vectors to be accessed by
+            Python's square bracket indexing notation using the provided three
+            indice strings and alters the printing of the unit vectors to
+            reflect this choice.
+        latexs : tuple of str
+            Alters the LaTeX printing of the reference frame's basis unit
+            vectors to the provided three valid LaTeX strings.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, vlatex
+        >>> N = ReferenceFrame('N')
+        >>> N.x
+        N.x
+        >>> O = ReferenceFrame('O', indices=('1', '2', '3'))
+        >>> O.x
+        O['1']
+        >>> O['1']
+        O['1']
+        >>> P = ReferenceFrame('P', latexs=('A1', 'A2', 'A3'))
+        >>> vlatex(P.x)
+        'A1'
+
+        ``symbols()`` can be used to create multiple Reference Frames in one
+        step, for example:
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> from sympy import symbols
+        >>> A, B, C = symbols('A B C', cls=ReferenceFrame)
+        >>> D, E = symbols('D E', cls=ReferenceFrame, indices=('1', '2', '3'))
+        >>> A[0]
+        A_x
+        >>> D.x
+        D['1']
+        >>> E.y
+        E['2']
+        >>> type(A) == type(D)
+        True
+
+        Unit dyads for the ReferenceFrame can be accessed through the attributes ``xx``, ``xy``, etc. For example:
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> N.yz
+        (N.y|N.z)
+        >>> N.zx
+        (N.z|N.x)
+        >>> P = ReferenceFrame('P', indices=['1', '2', '3'])
+        >>> P.xx
+        (P['1']|P['1'])
+        >>> P.zy
+        (P['3']|P['2'])
+
+        Unit dyadic is also accessible via the ``u`` attribute:
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> N.u
+        (N.x|N.x) + (N.y|N.y) + (N.z|N.z)
+        >>> P = ReferenceFrame('P', indices=['1', '2', '3'])
+        >>> P.u
+        (P['1']|P['1']) + (P['2']|P['2']) + (P['3']|P['3'])
+
+        """
+
+        if not isinstance(name, str):
+            raise TypeError('Need to supply a valid name')
+        # The if statements below are for custom printing of basis-vectors for
+        # each frame.
+        # First case, when custom indices are supplied
+        if indices is not None:
+            if not isinstance(indices, (tuple, list)):
+                raise TypeError('Supply the indices as a list')
+            if len(indices) != 3:
+                raise ValueError('Supply 3 indices')
+            for i in indices:
+                if not isinstance(i, str):
+                    raise TypeError('Indices must be strings')
+            self.str_vecs = [(name + '[\'' + indices[0] + '\']'),
+                             (name + '[\'' + indices[1] + '\']'),
+                             (name + '[\'' + indices[2] + '\']')]
+            self.pretty_vecs = [(name.lower() + "_" + indices[0]),
+                                (name.lower() + "_" + indices[1]),
+                                (name.lower() + "_" + indices[2])]
+            self.latex_vecs = [(r"\mathbf{\hat{%s}_{%s}}" % (name.lower(),
+                                                             indices[0])),
+                               (r"\mathbf{\hat{%s}_{%s}}" % (name.lower(),
+                                                             indices[1])),
+                               (r"\mathbf{\hat{%s}_{%s}}" % (name.lower(),
+                                                             indices[2]))]
+            self.indices = indices
+        # Second case, when no custom indices are supplied
+        else:
+            self.str_vecs = [(name + '.x'), (name + '.y'), (name + '.z')]
+            self.pretty_vecs = [name.lower() + "_x",
+                                name.lower() + "_y",
+                                name.lower() + "_z"]
+            self.latex_vecs = [(r"\mathbf{\hat{%s}_x}" % name.lower()),
+                               (r"\mathbf{\hat{%s}_y}" % name.lower()),
+                               (r"\mathbf{\hat{%s}_z}" % name.lower())]
+            self.indices = ['x', 'y', 'z']
+        # Different step, for custom latex basis vectors
+        if latexs is not None:
+            if not isinstance(latexs, (tuple, list)):
+                raise TypeError('Supply the indices as a list')
+            if len(latexs) != 3:
+                raise ValueError('Supply 3 indices')
+            for i in latexs:
+                if not isinstance(i, str):
+                    raise TypeError('Latex entries must be strings')
+            self.latex_vecs = latexs
+        self.name = name
+        self._var_dict = {}
+        # The _dcm_dict dictionary will only store the dcms of adjacent
+        # parent-child relationships. The _dcm_cache dictionary will store
+        # calculated dcm along with all content of _dcm_dict for faster
+        # retrieval of dcms.
+        self._dcm_dict = {}
+        self._dcm_cache = {}
+        self._ang_vel_dict = {}
+        self._ang_acc_dict = {}
+        self._dlist = [self._dcm_dict, self._ang_vel_dict, self._ang_acc_dict]
+        self._cur = 0
+        self._x = Vector([(Matrix([1, 0, 0]), self)])
+        self._y = Vector([(Matrix([0, 1, 0]), self)])
+        self._z = Vector([(Matrix([0, 0, 1]), self)])
+        # Associate coordinate symbols wrt this frame
+        if variables is not None:
+            if not isinstance(variables, (tuple, list)):
+                raise TypeError('Supply the variable names as a list/tuple')
+            if len(variables) != 3:
+                raise ValueError('Supply 3 variable names')
+            for i in variables:
+                if not isinstance(i, str):
+                    raise TypeError('Variable names must be strings')
+        else:
+            variables = [name + '_x', name + '_y', name + '_z']
+        self.varlist = (CoordinateSym(variables[0], self, 0),
+                        CoordinateSym(variables[1], self, 1),
+                        CoordinateSym(variables[2], self, 2))
+        ReferenceFrame._count += 1
+        self.index = ReferenceFrame._count
+
+    def __getitem__(self, ind):
+        """
+        Returns basis vector for the provided index, if the index is a string.
+
+        If the index is a number, returns the coordinate variable correspon-
+        -ding to that index.
+        """
+        if not isinstance(ind, str):
+            if ind < 3:
+                return self.varlist[ind]
+            else:
+                raise ValueError("Invalid index provided")
+        if self.indices[0] == ind:
+            return self.x
+        if self.indices[1] == ind:
+            return self.y
+        if self.indices[2] == ind:
+            return self.z
+        else:
+            raise ValueError('Not a defined index')
+
+    def __iter__(self):
+        return iter([self.x, self.y, self.z])
+
+    def __str__(self):
+        """Returns the name of the frame. """
+        return self.name
+
+    __repr__ = __str__
+
+    def _dict_list(self, other, num):
+        """Returns an inclusive list of reference frames that connect this
+        reference frame to the provided reference frame.
+
+        Parameters
+        ==========
+        other : ReferenceFrame
+            The other reference frame to look for a connecting relationship to.
+        num : integer
+            ``0``, ``1``, and ``2`` will look for orientation, angular
+            velocity, and angular acceleration relationships between the two
+            frames, respectively.
+
+        Returns
+        =======
+        list
+            Inclusive list of reference frames that connect this reference
+            frame to the other reference frame.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> A = ReferenceFrame('A')
+        >>> B = ReferenceFrame('B')
+        >>> C = ReferenceFrame('C')
+        >>> D = ReferenceFrame('D')
+        >>> B.orient_axis(A, A.x, 1.0)
+        >>> C.orient_axis(B, B.x, 1.0)
+        >>> D.orient_axis(C, C.x, 1.0)
+        >>> D._dict_list(A, 0)
+        [D, C, B, A]
+
+        Raises
+        ======
+
+        ValueError
+            When no path is found between the two reference frames or ``num``
+            is an incorrect value.
+
+        """
+
+        connect_type = {0: 'orientation',
+                        1: 'angular velocity',
+                        2: 'angular acceleration'}
+
+        if num not in connect_type.keys():
+            raise ValueError('Valid values for num are 0, 1, or 2.')
+
+        possible_connecting_paths = [[self]]
+        oldlist = [[]]
+        while possible_connecting_paths != oldlist:
+            oldlist = possible_connecting_paths.copy()
+            for frame_list in possible_connecting_paths:
+                frames_adjacent_to_last = frame_list[-1]._dlist[num].keys()
+                for adjacent_frame in frames_adjacent_to_last:
+                    if adjacent_frame not in frame_list:
+                        connecting_path = frame_list + [adjacent_frame]
+                        if connecting_path not in possible_connecting_paths:
+                            possible_connecting_paths.append(connecting_path)
+
+        for connecting_path in oldlist:
+            if connecting_path[-1] != other:
+                possible_connecting_paths.remove(connecting_path)
+        possible_connecting_paths.sort(key=len)
+
+        if len(possible_connecting_paths) != 0:
+            return possible_connecting_paths[0]  # selects the shortest path
+
+        msg = 'No connecting {} path found between {} and {}.'
+        raise ValueError(msg.format(connect_type[num], self.name, other.name))
+
+    def _w_diff_dcm(self, otherframe):
+        """Angular velocity from time differentiating the DCM. """
+        from sympy.physics.vector.functions import dynamicsymbols
+        dcm2diff = otherframe.dcm(self)
+        diffed = dcm2diff.diff(dynamicsymbols._t)
+        angvelmat = diffed * dcm2diff.T
+        w1 = trigsimp(expand(angvelmat[7]), recursive=True)
+        w2 = trigsimp(expand(angvelmat[2]), recursive=True)
+        w3 = trigsimp(expand(angvelmat[3]), recursive=True)
+        return Vector([(Matrix([w1, w2, w3]), otherframe)])
+
+    def variable_map(self, otherframe):
+        """
+        Returns a dictionary which expresses the coordinate variables
+        of this frame in terms of the variables of otherframe.
+
+        If Vector.simp is True, returns a simplified version of the mapped
+        values. Else, returns them without simplification.
+
+        Simplification of the expressions may take time.
+
+        Parameters
+        ==========
+
+        otherframe : ReferenceFrame
+            The other frame to map the variables to
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, dynamicsymbols
+        >>> A = ReferenceFrame('A')
+        >>> q = dynamicsymbols('q')
+        >>> B = A.orientnew('B', 'Axis', [q, A.z])
+        >>> A.variable_map(B)
+        {A_x: B_x*cos(q(t)) - B_y*sin(q(t)), A_y: B_x*sin(q(t)) + B_y*cos(q(t)), A_z: B_z}
+
+        """
+
+        _check_frame(otherframe)
+        if (otherframe, Vector.simp) in self._var_dict:
+            return self._var_dict[(otherframe, Vector.simp)]
+        else:
+            vars_matrix = self.dcm(otherframe) * Matrix(otherframe.varlist)
+            mapping = {}
+            for i, x in enumerate(self):
+                if Vector.simp:
+                    mapping[self.varlist[i]] = trigsimp(vars_matrix[i],
+                                                        method='fu')
+                else:
+                    mapping[self.varlist[i]] = vars_matrix[i]
+            self._var_dict[(otherframe, Vector.simp)] = mapping
+            return mapping
+
+    def ang_acc_in(self, otherframe):
+        """Returns the angular acceleration Vector of the ReferenceFrame.
+
+        Effectively returns the Vector:
+
+        ``N_alpha_B``
+
+        which represent the angular acceleration of B in N, where B is self,
+        and N is otherframe.
+
+        Parameters
+        ==========
+
+        otherframe : ReferenceFrame
+            The ReferenceFrame which the angular acceleration is returned in.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> A = ReferenceFrame('A')
+        >>> V = 10 * N.x
+        >>> A.set_ang_acc(N, V)
+        >>> A.ang_acc_in(N)
+        10*N.x
+
+        """
+
+        _check_frame(otherframe)
+        if otherframe in self._ang_acc_dict:
+            return self._ang_acc_dict[otherframe]
+        else:
+            return self.ang_vel_in(otherframe).dt(otherframe)
+
+    def ang_vel_in(self, otherframe):
+        """Returns the angular velocity Vector of the ReferenceFrame.
+
+        Effectively returns the Vector:
+
+        ^N omega ^B
+
+        which represent the angular velocity of B in N, where B is self, and
+        N is otherframe.
+
+        Parameters
+        ==========
+
+        otherframe : ReferenceFrame
+            The ReferenceFrame which the angular velocity is returned in.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> A = ReferenceFrame('A')
+        >>> V = 10 * N.x
+        >>> A.set_ang_vel(N, V)
+        >>> A.ang_vel_in(N)
+        10*N.x
+
+        """
+
+        _check_frame(otherframe)
+        flist = self._dict_list(otherframe, 1)
+        outvec = Vector(0)
+        for i in range(len(flist) - 1):
+            outvec += flist[i]._ang_vel_dict[flist[i + 1]]
+        return outvec
+
+    def dcm(self, otherframe):
+        r"""Returns the direction cosine matrix of this reference frame
+        relative to the provided reference frame.
+
+        The returned matrix can be used to express the orthogonal unit vectors
+        of this frame in terms of the orthogonal unit vectors of
+        ``otherframe``.
+
+        Parameters
+        ==========
+
+        otherframe : ReferenceFrame
+            The reference frame which the direction cosine matrix of this frame
+            is formed relative to.
+
+        Examples
+        ========
+
+        The following example rotates the reference frame A relative to N by a
+        simple rotation and then calculates the direction cosine matrix of N
+        relative to A.
+
+        >>> from sympy import symbols, sin, cos
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> q1 = symbols('q1')
+        >>> N = ReferenceFrame('N')
+        >>> A = ReferenceFrame('A')
+        >>> A.orient_axis(N, q1, N.x)
+        >>> N.dcm(A)
+        Matrix([
+        [1,       0,        0],
+        [0, cos(q1), -sin(q1)],
+        [0, sin(q1),  cos(q1)]])
+
+        The second row of the above direction cosine matrix represents the
+        ``N.y`` unit vector in N expressed in A. Like so:
+
+        >>> Ny = 0*A.x + cos(q1)*A.y - sin(q1)*A.z
+
+        Thus, expressing ``N.y`` in A should return the same result:
+
+        >>> N.y.express(A)
+        cos(q1)*A.y - sin(q1)*A.z
+
+        Notes
+        =====
+
+        It is important to know what form of the direction cosine matrix is
+        returned. If ``B.dcm(A)`` is called, it means the "direction cosine
+        matrix of B rotated relative to A". This is the matrix
+        :math:`{}^B\mathbf{C}^A` shown in the following relationship:
+
+        .. math::
+
+           \begin{bmatrix}
+             \hat{\mathbf{b}}_1 \\
+             \hat{\mathbf{b}}_2 \\
+             \hat{\mathbf{b}}_3
+           \end{bmatrix}
+           =
+           {}^B\mathbf{C}^A
+           \begin{bmatrix}
+             \hat{\mathbf{a}}_1 \\
+             \hat{\mathbf{a}}_2 \\
+             \hat{\mathbf{a}}_3
+           \end{bmatrix}.
+
+        :math:`{}^B\mathbf{C}^A` is the matrix that expresses the B unit
+        vectors in terms of the A unit vectors.
+
+        """
+
+        _check_frame(otherframe)
+        # Check if the dcm wrt that frame has already been calculated
+        if otherframe in self._dcm_cache:
+            return self._dcm_cache[otherframe]
+        flist = self._dict_list(otherframe, 0)
+        outdcm = eye(3)
+        for i in range(len(flist) - 1):
+            outdcm = outdcm * flist[i]._dcm_dict[flist[i + 1]]
+        # After calculation, store the dcm in dcm cache for faster future
+        # retrieval
+        self._dcm_cache[otherframe] = outdcm
+        otherframe._dcm_cache[self] = outdcm.T
+        return outdcm
+
+    def _dcm(self, parent, parent_orient):
+        # If parent.oreint(self) is already defined,then
+        # update the _dcm_dict of parent while over write
+        # all content of self._dcm_dict and self._dcm_cache
+        # with new dcm relation.
+        # Else update _dcm_cache and _dcm_dict of both
+        # self and parent.
+        frames = self._dcm_cache.keys()
+        dcm_dict_del = []
+        dcm_cache_del = []
+        if parent in frames:
+            for frame in frames:
+                if frame in self._dcm_dict:
+                    dcm_dict_del += [frame]
+                dcm_cache_del += [frame]
+            # Reset the _dcm_cache of this frame, and remove it from the
+            # _dcm_caches of the frames it is linked to. Also remove it from
+            # the _dcm_dict of its parent
+            for frame in dcm_dict_del:
+                del frame._dcm_dict[self]
+            for frame in dcm_cache_del:
+                del frame._dcm_cache[self]
+        # Reset the _dcm_dict
+            self._dcm_dict = self._dlist[0] = {}
+        # Reset the _dcm_cache
+            self._dcm_cache = {}
+
+        else:
+            # Check for loops and raise warning accordingly.
+            visited = []
+            queue = list(frames)
+            cont = True  # Flag to control queue loop.
+            while queue and cont:
+                node = queue.pop(0)
+                if node not in visited:
+                    visited.append(node)
+                    neighbors = node._dcm_dict.keys()
+                    for neighbor in neighbors:
+                        if neighbor == parent:
+                            warn('Loops are defined among the orientation of '
+                                 'frames. This is likely not desired and may '
+                                 'cause errors in your calculations.')
+                            cont = False
+                            break
+                        queue.append(neighbor)
+
+        # Add the dcm relationship to _dcm_dict
+        self._dcm_dict.update({parent: parent_orient.T})
+        parent._dcm_dict.update({self: parent_orient})
+        # Update the dcm cache
+        self._dcm_cache.update({parent: parent_orient.T})
+        parent._dcm_cache.update({self: parent_orient})
+
+    def orient_axis(self, parent, axis, angle):
+        """Sets the orientation of this reference frame with respect to a
+        parent reference frame by rotating through an angle about an axis fixed
+        in the parent reference frame.
+
+        Parameters
+        ==========
+
+        parent : ReferenceFrame
+            Reference frame that this reference frame will be rotated relative
+            to.
+        axis : Vector
+            Vector fixed in the parent frame about about which this frame is
+            rotated. It need not be a unit vector and the rotation follows the
+            right hand rule.
+        angle : sympifiable
+            Angle in radians by which it the frame is to be rotated.
+
+        Warns
+        ======
+
+        UserWarning
+            If the orientation creates a kinematic loop.
+
+        Examples
+        ========
+
+        Setup variables for the examples:
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> q1 = symbols('q1')
+        >>> N = ReferenceFrame('N')
+        >>> B = ReferenceFrame('B')
+        >>> B.orient_axis(N, N.x, q1)
+
+        The ``orient_axis()`` method generates a direction cosine matrix and
+        its transpose which defines the orientation of B relative to N and vice
+        versa. Once orient is called, ``dcm()`` outputs the appropriate
+        direction cosine matrix:
+
+        >>> B.dcm(N)
+        Matrix([
+        [1,       0,      0],
+        [0,  cos(q1), sin(q1)],
+        [0, -sin(q1), cos(q1)]])
+        >>> N.dcm(B)
+        Matrix([
+        [1,       0,        0],
+        [0, cos(q1), -sin(q1)],
+        [0, sin(q1),  cos(q1)]])
+
+        The following two lines show that the sense of the rotation can be
+        defined by negating the vector direction or the angle. Both lines
+        produce the same result.
+
+        >>> B.orient_axis(N, -N.x, q1)
+        >>> B.orient_axis(N, N.x, -q1)
+
+        """
+
+        from sympy.physics.vector.functions import dynamicsymbols
+        _check_frame(parent)
+
+        if not isinstance(axis, Vector) and isinstance(angle, Vector):
+            axis, angle = angle, axis
+
+        axis = _check_vector(axis)
+        theta = sympify(angle)
+
+        if not axis.dt(parent) == 0:
+            raise ValueError('Axis cannot be time-varying.')
+        unit_axis = axis.express(parent).normalize()
+        unit_col = unit_axis.args[0][0]
+        parent_orient_axis = (
+            (eye(3) - unit_col * unit_col.T) * cos(theta) +
+            Matrix([[0, -unit_col[2], unit_col[1]],
+                    [unit_col[2], 0, -unit_col[0]],
+                    [-unit_col[1], unit_col[0], 0]]) *
+            sin(theta) + unit_col * unit_col.T)
+
+        self._dcm(parent, parent_orient_axis)
+
+        thetad = (theta).diff(dynamicsymbols._t)
+        wvec = thetad*axis.express(parent).normalize()
+        self._ang_vel_dict.update({parent: wvec})
+        parent._ang_vel_dict.update({self: -wvec})
+        self._var_dict = {}
+
+    def orient_explicit(self, parent, dcm):
+        """Sets the orientation of this reference frame relative to another (parent) reference frame
+        using a direction cosine matrix that describes the rotation from the parent to the child.
+
+        Parameters
+        ==========
+
+        parent : ReferenceFrame
+            Reference frame that this reference frame will be rotated relative
+            to.
+        dcm : Matrix, shape(3, 3)
+            Direction cosine matrix that specifies the relative rotation
+            between the two reference frames.
+
+        Warns
+        ======
+
+        UserWarning
+            If the orientation creates a kinematic loop.
+
+        Examples
+        ========
+
+        Setup variables for the examples:
+
+        >>> from sympy import symbols, Matrix, sin, cos
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> q1 = symbols('q1')
+        >>> A = ReferenceFrame('A')
+        >>> B = ReferenceFrame('B')
+        >>> N = ReferenceFrame('N')
+
+        A simple rotation of ``A`` relative to ``N`` about ``N.x`` is defined
+        by the following direction cosine matrix:
+
+        >>> dcm = Matrix([[1, 0, 0],
+        ...               [0, cos(q1), -sin(q1)],
+        ...               [0, sin(q1), cos(q1)]])
+        >>> A.orient_explicit(N, dcm)
+        >>> A.dcm(N)
+        Matrix([
+        [1,       0,      0],
+        [0,  cos(q1), sin(q1)],
+        [0, -sin(q1), cos(q1)]])
+
+        This is equivalent to using ``orient_axis()``:
+
+        >>> B.orient_axis(N, N.x, q1)
+        >>> B.dcm(N)
+        Matrix([
+        [1,       0,      0],
+        [0,  cos(q1), sin(q1)],
+        [0, -sin(q1), cos(q1)]])
+
+        **Note carefully that** ``N.dcm(B)`` **(the transpose) would be passed
+        into** ``orient_explicit()`` **for** ``A.dcm(N)`` **to match**
+        ``B.dcm(N)``:
+
+        >>> A.orient_explicit(N, N.dcm(B))
+        >>> A.dcm(N)
+        Matrix([
+        [1,       0,      0],
+        [0,  cos(q1), sin(q1)],
+        [0, -sin(q1), cos(q1)]])
+
+        """
+        _check_frame(parent)
+        # amounts must be a Matrix type object
+        # (e.g. sympy.matrices.dense.MutableDenseMatrix).
+        if not isinstance(dcm, MatrixBase):
+            raise TypeError("Amounts must be a SymPy Matrix type object.")
+
+        self.orient_dcm(parent, dcm.T)
+
+    def orient_dcm(self, parent, dcm):
+        """Sets the orientation of this reference frame relative to another (parent) reference frame
+        using a direction cosine matrix that describes the rotation from the child to the parent.
+
+        Parameters
+        ==========
+
+        parent : ReferenceFrame
+            Reference frame that this reference frame will be rotated relative
+            to.
+        dcm : Matrix, shape(3, 3)
+            Direction cosine matrix that specifies the relative rotation
+            between the two reference frames.
+
+        Warns
+        ======
+
+        UserWarning
+            If the orientation creates a kinematic loop.
+
+        Examples
+        ========
+
+        Setup variables for the examples:
+
+        >>> from sympy import symbols, Matrix, sin, cos
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> q1 = symbols('q1')
+        >>> A = ReferenceFrame('A')
+        >>> B = ReferenceFrame('B')
+        >>> N = ReferenceFrame('N')
+
+        A simple rotation of ``A`` relative to ``N`` about ``N.x`` is defined
+        by the following direction cosine matrix:
+
+        >>> dcm = Matrix([[1, 0, 0],
+        ...               [0,  cos(q1), sin(q1)],
+        ...               [0, -sin(q1), cos(q1)]])
+        >>> A.orient_dcm(N, dcm)
+        >>> A.dcm(N)
+        Matrix([
+        [1,       0,      0],
+        [0,  cos(q1), sin(q1)],
+        [0, -sin(q1), cos(q1)]])
+
+        This is equivalent to using ``orient_axis()``:
+
+        >>> B.orient_axis(N, N.x, q1)
+        >>> B.dcm(N)
+        Matrix([
+        [1,       0,      0],
+        [0,  cos(q1), sin(q1)],
+        [0, -sin(q1), cos(q1)]])
+
+        """
+
+        _check_frame(parent)
+        # amounts must be a Matrix type object
+        # (e.g. sympy.matrices.dense.MutableDenseMatrix).
+        if not isinstance(dcm, MatrixBase):
+            raise TypeError("Amounts must be a SymPy Matrix type object.")
+
+        self._dcm(parent, dcm.T)
+
+        wvec = self._w_diff_dcm(parent)
+        self._ang_vel_dict.update({parent: wvec})
+        parent._ang_vel_dict.update({self: -wvec})
+        self._var_dict = {}
+
+    def _rot(self, axis, angle):
+        """DCM for simple axis 1,2,or 3 rotations."""
+        if axis == 1:
+            return Matrix([[1, 0, 0],
+                           [0, cos(angle), -sin(angle)],
+                           [0, sin(angle), cos(angle)]])
+        elif axis == 2:
+            return Matrix([[cos(angle), 0, sin(angle)],
+                           [0, 1, 0],
+                           [-sin(angle), 0, cos(angle)]])
+        elif axis == 3:
+            return Matrix([[cos(angle), -sin(angle), 0],
+                           [sin(angle), cos(angle), 0],
+                           [0, 0, 1]])
+
+    def _parse_consecutive_rotations(self, angles, rotation_order):
+        """Helper for orient_body_fixed and orient_space_fixed.
+
+        Parameters
+        ==========
+        angles : 3-tuple of sympifiable
+            Three angles in radians used for the successive rotations.
+        rotation_order : 3 character string or 3 digit integer
+            Order of the rotations. The order can be specified by the strings
+            ``'XZX'``, ``'131'``, or the integer ``131``. There are 12 unique
+            valid rotation orders.
+
+        Returns
+        =======
+
+        amounts : list
+            List of sympifiables corresponding to the rotation angles.
+        rot_order : list
+            List of integers corresponding to the axis of rotation.
+        rot_matrices : list
+            List of DCM around the given axis with corresponding magnitude.
+
+        """
+        amounts = list(angles)
+        for i, v in enumerate(amounts):
+            if not isinstance(v, Vector):
+                amounts[i] = sympify(v)
+
+        approved_orders = ('123', '231', '312', '132', '213', '321', '121',
+                           '131', '212', '232', '313', '323', '')
+        # make sure XYZ => 123
+        rot_order = translate(str(rotation_order), 'XYZxyz', '123123')
+        if rot_order not in approved_orders:
+            raise TypeError('The rotation order is not a valid order.')
+
+        rot_order = [int(r) for r in rot_order]
+        if not (len(amounts) == 3 & len(rot_order) == 3):
+            raise TypeError('Body orientation takes 3 values & 3 orders')
+        rot_matrices = [self._rot(order, amount)
+                        for (order, amount) in zip(rot_order, amounts)]
+        return amounts, rot_order, rot_matrices
+
+    def orient_body_fixed(self, parent, angles, rotation_order):
+        """Rotates this reference frame relative to the parent reference frame
+        by right hand rotating through three successive body fixed simple axis
+        rotations. Each subsequent axis of rotation is about the "body fixed"
+        unit vectors of a new intermediate reference frame. This type of
+        rotation is also referred to rotating through the `Euler and Tait-Bryan
+        Angles`_.
+
+        .. _Euler and Tait-Bryan Angles: https://en.wikipedia.org/wiki/Euler_angles
+
+        The computed angular velocity in this method is by default expressed in
+        the child's frame, so it is most preferable to use ``u1 * child.x + u2 *
+        child.y + u3 * child.z`` as generalized speeds.
+
+        Parameters
+        ==========
+
+        parent : ReferenceFrame
+            Reference frame that this reference frame will be rotated relative
+            to.
+        angles : 3-tuple of sympifiable
+            Three angles in radians used for the successive rotations.
+        rotation_order : 3 character string or 3 digit integer
+            Order of the rotations about each intermediate reference frames'
+            unit vectors. The Euler rotation about the X, Z', X'' axes can be
+            specified by the strings ``'XZX'``, ``'131'``, or the integer
+            ``131``. There are 12 unique valid rotation orders (6 Euler and 6
+            Tait-Bryan): zxz, xyx, yzy, zyz, xzx, yxy, xyz, yzx, zxy, xzy, zyx,
+            and yxz.
+
+        Warns
+        ======
+
+        UserWarning
+            If the orientation creates a kinematic loop.
+
+        Examples
+        ========
+
+        Setup variables for the examples:
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> q1, q2, q3 = symbols('q1, q2, q3')
+        >>> N = ReferenceFrame('N')
+        >>> B = ReferenceFrame('B')
+        >>> B1 = ReferenceFrame('B1')
+        >>> B2 = ReferenceFrame('B2')
+        >>> B3 = ReferenceFrame('B3')
+
+        For example, a classic Euler Angle rotation can be done by:
+
+        >>> B.orient_body_fixed(N, (q1, q2, q3), 'XYX')
+        >>> B.dcm(N)
+        Matrix([
+        [        cos(q2),                            sin(q1)*sin(q2),                           -sin(q2)*cos(q1)],
+        [sin(q2)*sin(q3), -sin(q1)*sin(q3)*cos(q2) + cos(q1)*cos(q3),  sin(q1)*cos(q3) + sin(q3)*cos(q1)*cos(q2)],
+        [sin(q2)*cos(q3), -sin(q1)*cos(q2)*cos(q3) - sin(q3)*cos(q1), -sin(q1)*sin(q3) + cos(q1)*cos(q2)*cos(q3)]])
+
+        This rotates reference frame B relative to reference frame N through
+        ``q1`` about ``N.x``, then rotates B again through ``q2`` about
+        ``B.y``, and finally through ``q3`` about ``B.x``. It is equivalent to
+        three successive ``orient_axis()`` calls:
+
+        >>> B1.orient_axis(N, N.x, q1)
+        >>> B2.orient_axis(B1, B1.y, q2)
+        >>> B3.orient_axis(B2, B2.x, q3)
+        >>> B3.dcm(N)
+        Matrix([
+        [        cos(q2),                            sin(q1)*sin(q2),                           -sin(q2)*cos(q1)],
+        [sin(q2)*sin(q3), -sin(q1)*sin(q3)*cos(q2) + cos(q1)*cos(q3),  sin(q1)*cos(q3) + sin(q3)*cos(q1)*cos(q2)],
+        [sin(q2)*cos(q3), -sin(q1)*cos(q2)*cos(q3) - sin(q3)*cos(q1), -sin(q1)*sin(q3) + cos(q1)*cos(q2)*cos(q3)]])
+
+        Acceptable rotation orders are of length 3, expressed in as a string
+        ``'XYZ'`` or ``'123'`` or integer ``123``. Rotations about an axis
+        twice in a row are prohibited.
+
+        >>> B.orient_body_fixed(N, (q1, q2, 0), 'ZXZ')
+        >>> B.orient_body_fixed(N, (q1, q2, 0), '121')
+        >>> B.orient_body_fixed(N, (q1, q2, q3), 123)
+
+        """
+        from sympy.physics.vector.functions import dynamicsymbols
+
+        _check_frame(parent)
+
+        amounts, rot_order, rot_matrices = self._parse_consecutive_rotations(
+            angles, rotation_order)
+        self._dcm(parent, rot_matrices[0] * rot_matrices[1] * rot_matrices[2])
+
+        rot_vecs = [zeros(3, 1) for _ in range(3)]
+        for i, order in enumerate(rot_order):
+            rot_vecs[i][order - 1] = amounts[i].diff(dynamicsymbols._t)
+        u1, u2, u3 = rot_vecs[2] + rot_matrices[2].T * (
+            rot_vecs[1] + rot_matrices[1].T * rot_vecs[0])
+        wvec = u1 * self.x + u2 * self.y + u3 * self.z  # There is a double -
+        self._ang_vel_dict.update({parent: wvec})
+        parent._ang_vel_dict.update({self: -wvec})
+        self._var_dict = {}
+
+    def orient_space_fixed(self, parent, angles, rotation_order):
+        """Rotates this reference frame relative to the parent reference frame
+        by right hand rotating through three successive space fixed simple axis
+        rotations. Each subsequent axis of rotation is about the "space fixed"
+        unit vectors of the parent reference frame.
+
+        The computed angular velocity in this method is by default expressed in
+        the child's frame, so it is most preferable to use ``u1 * child.x + u2 *
+        child.y + u3 * child.z`` as generalized speeds.
+
+        Parameters
+        ==========
+        parent : ReferenceFrame
+            Reference frame that this reference frame will be rotated relative
+            to.
+        angles : 3-tuple of sympifiable
+            Three angles in radians used for the successive rotations.
+        rotation_order : 3 character string or 3 digit integer
+            Order of the rotations about the parent reference frame's unit
+            vectors. The order can be specified by the strings ``'XZX'``,
+            ``'131'``, or the integer ``131``. There are 12 unique valid
+            rotation orders.
+
+        Warns
+        ======
+
+        UserWarning
+            If the orientation creates a kinematic loop.
+
+        Examples
+        ========
+
+        Setup variables for the examples:
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> q1, q2, q3 = symbols('q1, q2, q3')
+        >>> N = ReferenceFrame('N')
+        >>> B = ReferenceFrame('B')
+        >>> B1 = ReferenceFrame('B1')
+        >>> B2 = ReferenceFrame('B2')
+        >>> B3 = ReferenceFrame('B3')
+
+        >>> B.orient_space_fixed(N, (q1, q2, q3), '312')
+        >>> B.dcm(N)
+        Matrix([
+        [ sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1)],
+        [-sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1), cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3)],
+        [                           sin(q3)*cos(q2),        -sin(q2),                           cos(q2)*cos(q3)]])
+
+        is equivalent to:
+
+        >>> B1.orient_axis(N, N.z, q1)
+        >>> B2.orient_axis(B1, N.x, q2)
+        >>> B3.orient_axis(B2, N.y, q3)
+        >>> B3.dcm(N).simplify()
+        Matrix([
+        [ sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1)],
+        [-sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1), cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3)],
+        [                           sin(q3)*cos(q2),        -sin(q2),                           cos(q2)*cos(q3)]])
+
+        It is worth noting that space-fixed and body-fixed rotations are
+        related by the order of the rotations, i.e. the reverse order of body
+        fixed will give space fixed and vice versa.
+
+        >>> B.orient_space_fixed(N, (q1, q2, q3), '231')
+        >>> B.dcm(N)
+        Matrix([
+        [cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3), -sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)],
+        [       -sin(q2),                           cos(q2)*cos(q3),                            sin(q3)*cos(q2)],
+        [sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1),  sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3)]])
+
+        >>> B.orient_body_fixed(N, (q3, q2, q1), '132')
+        >>> B.dcm(N)
+        Matrix([
+        [cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3), -sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)],
+        [       -sin(q2),                           cos(q2)*cos(q3),                            sin(q3)*cos(q2)],
+        [sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1),  sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3)]])
+
+        """
+        from sympy.physics.vector.functions import dynamicsymbols
+
+        _check_frame(parent)
+
+        amounts, rot_order, rot_matrices = self._parse_consecutive_rotations(
+            angles, rotation_order)
+        self._dcm(parent, rot_matrices[2] * rot_matrices[1] * rot_matrices[0])
+
+        rot_vecs = [zeros(3, 1) for _ in range(3)]
+        for i, order in enumerate(rot_order):
+            rot_vecs[i][order - 1] = amounts[i].diff(dynamicsymbols._t)
+        u1, u2, u3 = rot_vecs[0] + rot_matrices[0].T * (
+            rot_vecs[1] + rot_matrices[1].T * rot_vecs[2])
+        wvec = u1 * self.x + u2 * self.y + u3 * self.z  # There is a double -
+        self._ang_vel_dict.update({parent: wvec})
+        parent._ang_vel_dict.update({self: -wvec})
+        self._var_dict = {}
+
+    def orient_quaternion(self, parent, numbers):
+        """Sets the orientation of this reference frame relative to a parent
+        reference frame via an orientation quaternion. An orientation
+        quaternion is defined as a finite rotation a unit vector, ``(lambda_x,
+        lambda_y, lambda_z)``, by an angle ``theta``. The orientation
+        quaternion is described by four parameters:
+
+        - ``q0 = cos(theta/2)``
+        - ``q1 = lambda_x*sin(theta/2)``
+        - ``q2 = lambda_y*sin(theta/2)``
+        - ``q3 = lambda_z*sin(theta/2)``
+
+        See `Quaternions and Spatial Rotation
+        <https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation>`_ on
+        Wikipedia for more information.
+
+        Parameters
+        ==========
+        parent : ReferenceFrame
+            Reference frame that this reference frame will be rotated relative
+            to.
+        numbers : 4-tuple of sympifiable
+            The four quaternion scalar numbers as defined above: ``q0``,
+            ``q1``, ``q2``, ``q3``.
+
+        Warns
+        ======
+
+        UserWarning
+            If the orientation creates a kinematic loop.
+
+        Examples
+        ========
+
+        Setup variables for the examples:
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> q0, q1, q2, q3 = symbols('q0 q1 q2 q3')
+        >>> N = ReferenceFrame('N')
+        >>> B = ReferenceFrame('B')
+
+        Set the orientation:
+
+        >>> B.orient_quaternion(N, (q0, q1, q2, q3))
+        >>> B.dcm(N)
+        Matrix([
+        [q0**2 + q1**2 - q2**2 - q3**2,             2*q0*q3 + 2*q1*q2,            -2*q0*q2 + 2*q1*q3],
+        [           -2*q0*q3 + 2*q1*q2, q0**2 - q1**2 + q2**2 - q3**2,             2*q0*q1 + 2*q2*q3],
+        [            2*q0*q2 + 2*q1*q3,            -2*q0*q1 + 2*q2*q3, q0**2 - q1**2 - q2**2 + q3**2]])
+
+        """
+
+        from sympy.physics.vector.functions import dynamicsymbols
+        _check_frame(parent)
+
+        numbers = list(numbers)
+        for i, v in enumerate(numbers):
+            if not isinstance(v, Vector):
+                numbers[i] = sympify(v)
+
+        if not (isinstance(numbers, (list, tuple)) & (len(numbers) == 4)):
+            raise TypeError('Amounts are a list or tuple of length 4')
+        q0, q1, q2, q3 = numbers
+        parent_orient_quaternion = (
+            Matrix([[q0**2 + q1**2 - q2**2 - q3**2,
+                     2 * (q1 * q2 - q0 * q3),
+                     2 * (q0 * q2 + q1 * q3)],
+                    [2 * (q1 * q2 + q0 * q3),
+                     q0**2 - q1**2 + q2**2 - q3**2,
+                     2 * (q2 * q3 - q0 * q1)],
+                    [2 * (q1 * q3 - q0 * q2),
+                     2 * (q0 * q1 + q2 * q3),
+                     q0**2 - q1**2 - q2**2 + q3**2]]))
+
+        self._dcm(parent, parent_orient_quaternion)
+
+        t = dynamicsymbols._t
+        q0, q1, q2, q3 = numbers
+        q0d = diff(q0, t)
+        q1d = diff(q1, t)
+        q2d = diff(q2, t)
+        q3d = diff(q3, t)
+        w1 = 2 * (q1d * q0 + q2d * q3 - q3d * q2 - q0d * q1)
+        w2 = 2 * (q2d * q0 + q3d * q1 - q1d * q3 - q0d * q2)
+        w3 = 2 * (q3d * q0 + q1d * q2 - q2d * q1 - q0d * q3)
+        wvec = Vector([(Matrix([w1, w2, w3]), self)])
+
+        self._ang_vel_dict.update({parent: wvec})
+        parent._ang_vel_dict.update({self: -wvec})
+        self._var_dict = {}
+
+    def orient(self, parent, rot_type, amounts, rot_order=''):
+        """Sets the orientation of this reference frame relative to another
+        (parent) reference frame.
+
+        .. note:: It is now recommended to use the ``.orient_axis,
+           .orient_body_fixed, .orient_space_fixed, .orient_quaternion``
+           methods for the different rotation types.
+
+        Parameters
+        ==========
+
+        parent : ReferenceFrame
+            Reference frame that this reference frame will be rotated relative
+            to.
+        rot_type : str
+            The method used to generate the direction cosine matrix. Supported
+            methods are:
+
+            - ``'Axis'``: simple rotations about a single common axis
+            - ``'DCM'``: for setting the direction cosine matrix directly
+            - ``'Body'``: three successive rotations about new intermediate
+              axes, also called "Euler and Tait-Bryan angles"
+            - ``'Space'``: three successive rotations about the parent
+              frames' unit vectors
+            - ``'Quaternion'``: rotations defined by four parameters which
+              result in a singularity free direction cosine matrix
+
+        amounts :
+            Expressions defining the rotation angles or direction cosine
+            matrix. These must match the ``rot_type``. See examples below for
+            details. The input types are:
+
+            - ``'Axis'``: 2-tuple (expr/sym/func, Vector)
+            - ``'DCM'``: Matrix, shape(3,3)
+            - ``'Body'``: 3-tuple of expressions, symbols, or functions
+            - ``'Space'``: 3-tuple of expressions, symbols, or functions
+            - ``'Quaternion'``: 4-tuple of expressions, symbols, or
+              functions
+
+        rot_order : str or int, optional
+            If applicable, the order of the successive of rotations. The string
+            ``'123'`` and integer ``123`` are equivalent, for example. Required
+            for ``'Body'`` and ``'Space'``.
+
+        Warns
+        ======
+
+        UserWarning
+            If the orientation creates a kinematic loop.
+
+        """
+
+        _check_frame(parent)
+
+        approved_orders = ('123', '231', '312', '132', '213', '321', '121',
+                           '131', '212', '232', '313', '323', '')
+        rot_order = translate(str(rot_order), 'XYZxyz', '123123')
+        rot_type = rot_type.upper()
+
+        if rot_order not in approved_orders:
+            raise TypeError('The supplied order is not an approved type')
+
+        if rot_type == 'AXIS':
+            self.orient_axis(parent, amounts[1], amounts[0])
+
+        elif rot_type == 'DCM':
+            self.orient_explicit(parent, amounts)
+
+        elif rot_type == 'BODY':
+            self.orient_body_fixed(parent, amounts, rot_order)
+
+        elif rot_type == 'SPACE':
+            self.orient_space_fixed(parent, amounts, rot_order)
+
+        elif rot_type == 'QUATERNION':
+            self.orient_quaternion(parent, amounts)
+
+        else:
+            raise NotImplementedError('That is not an implemented rotation')
+
+    def orientnew(self, newname, rot_type, amounts, rot_order='',
+                  variables=None, indices=None, latexs=None):
+        r"""Returns a new reference frame oriented with respect to this
+        reference frame.
+
+        See ``ReferenceFrame.orient()`` for detailed examples of how to orient
+        reference frames.
+
+        Parameters
+        ==========
+
+        newname : str
+            Name for the new reference frame.
+        rot_type : str
+            The method used to generate the direction cosine matrix. Supported
+            methods are:
+
+            - ``'Axis'``: simple rotations about a single common axis
+            - ``'DCM'``: for setting the direction cosine matrix directly
+            - ``'Body'``: three successive rotations about new intermediate
+              axes, also called "Euler and Tait-Bryan angles"
+            - ``'Space'``: three successive rotations about the parent
+              frames' unit vectors
+            - ``'Quaternion'``: rotations defined by four parameters which
+              result in a singularity free direction cosine matrix
+
+        amounts :
+            Expressions defining the rotation angles or direction cosine
+            matrix. These must match the ``rot_type``. See examples below for
+            details. The input types are:
+
+            - ``'Axis'``: 2-tuple (expr/sym/func, Vector)
+            - ``'DCM'``: Matrix, shape(3,3)
+            - ``'Body'``: 3-tuple of expressions, symbols, or functions
+            - ``'Space'``: 3-tuple of expressions, symbols, or functions
+            - ``'Quaternion'``: 4-tuple of expressions, symbols, or
+              functions
+
+        rot_order : str or int, optional
+            If applicable, the order of the successive of rotations. The string
+            ``'123'`` and integer ``123`` are equivalent, for example. Required
+            for ``'Body'`` and ``'Space'``.
+        indices : tuple of str
+            Enables the reference frame's basis unit vectors to be accessed by
+            Python's square bracket indexing notation using the provided three
+            indice strings and alters the printing of the unit vectors to
+            reflect this choice.
+        latexs : tuple of str
+            Alters the LaTeX printing of the reference frame's basis unit
+            vectors to the provided three valid LaTeX strings.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.vector import ReferenceFrame, vlatex
+        >>> q0, q1, q2, q3 = symbols('q0 q1 q2 q3')
+        >>> N = ReferenceFrame('N')
+
+        Create a new reference frame A rotated relative to N through a simple
+        rotation.
+
+        >>> A = N.orientnew('A', 'Axis', (q0, N.x))
+
+        Create a new reference frame B rotated relative to N through body-fixed
+        rotations.
+
+        >>> B = N.orientnew('B', 'Body', (q1, q2, q3), '123')
+
+        Create a new reference frame C rotated relative to N through a simple
+        rotation with unique indices and LaTeX printing.
+
+        >>> C = N.orientnew('C', 'Axis', (q0, N.x), indices=('1', '2', '3'),
+        ... latexs=(r'\hat{\mathbf{c}}_1',r'\hat{\mathbf{c}}_2',
+        ... r'\hat{\mathbf{c}}_3'))
+        >>> C['1']
+        C['1']
+        >>> print(vlatex(C['1']))
+        \hat{\mathbf{c}}_1
+
+        """
+
+        newframe = self.__class__(newname, variables=variables,
+                                  indices=indices, latexs=latexs)
+
+        approved_orders = ('123', '231', '312', '132', '213', '321', '121',
+                           '131', '212', '232', '313', '323', '')
+        rot_order = translate(str(rot_order), 'XYZxyz', '123123')
+        rot_type = rot_type.upper()
+
+        if rot_order not in approved_orders:
+            raise TypeError('The supplied order is not an approved type')
+
+        if rot_type == 'AXIS':
+            newframe.orient_axis(self, amounts[1], amounts[0])
+
+        elif rot_type == 'DCM':
+            newframe.orient_explicit(self, amounts)
+
+        elif rot_type == 'BODY':
+            newframe.orient_body_fixed(self, amounts, rot_order)
+
+        elif rot_type == 'SPACE':
+            newframe.orient_space_fixed(self, amounts, rot_order)
+
+        elif rot_type == 'QUATERNION':
+            newframe.orient_quaternion(self, amounts)
+
+        else:
+            raise NotImplementedError('That is not an implemented rotation')
+        return newframe
+
+    def set_ang_acc(self, otherframe, value):
+        """Define the angular acceleration Vector in a ReferenceFrame.
+
+        Defines the angular acceleration of this ReferenceFrame, in another.
+        Angular acceleration can be defined with respect to multiple different
+        ReferenceFrames. Care must be taken to not create loops which are
+        inconsistent.
+
+        Parameters
+        ==========
+
+        otherframe : ReferenceFrame
+            A ReferenceFrame to define the angular acceleration in
+        value : Vector
+            The Vector representing angular acceleration
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> A = ReferenceFrame('A')
+        >>> V = 10 * N.x
+        >>> A.set_ang_acc(N, V)
+        >>> A.ang_acc_in(N)
+        10*N.x
+
+        """
+
+        if value == 0:
+            value = Vector(0)
+        value = _check_vector(value)
+        _check_frame(otherframe)
+        self._ang_acc_dict.update({otherframe: value})
+        otherframe._ang_acc_dict.update({self: -value})
+
+    def set_ang_vel(self, otherframe, value):
+        """Define the angular velocity vector in a ReferenceFrame.
+
+        Defines the angular velocity of this ReferenceFrame, in another.
+        Angular velocity can be defined with respect to multiple different
+        ReferenceFrames. Care must be taken to not create loops which are
+        inconsistent.
+
+        Parameters
+        ==========
+
+        otherframe : ReferenceFrame
+            A ReferenceFrame to define the angular velocity in
+        value : Vector
+            The Vector representing angular velocity
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> A = ReferenceFrame('A')
+        >>> V = 10 * N.x
+        >>> A.set_ang_vel(N, V)
+        >>> A.ang_vel_in(N)
+        10*N.x
+
+        """
+
+        if value == 0:
+            value = Vector(0)
+        value = _check_vector(value)
+        _check_frame(otherframe)
+        self._ang_vel_dict.update({otherframe: value})
+        otherframe._ang_vel_dict.update({self: -value})
+
+    @property
+    def x(self):
+        """The basis Vector for the ReferenceFrame, in the x direction. """
+        return self._x
+
+    @property
+    def y(self):
+        """The basis Vector for the ReferenceFrame, in the y direction. """
+        return self._y
+
+    @property
+    def z(self):
+        """The basis Vector for the ReferenceFrame, in the z direction. """
+        return self._z
+
+    @property
+    def xx(self):
+        """Unit dyad of basis Vectors x and x for the ReferenceFrame."""
+        return Vector.outer(self.x, self.x)
+
+    @property
+    def xy(self):
+        """Unit dyad of basis Vectors x and y for the ReferenceFrame."""
+        return Vector.outer(self.x, self.y)
+
+    @property
+    def xz(self):
+        """Unit dyad of basis Vectors x and z for the ReferenceFrame."""
+        return Vector.outer(self.x, self.z)
+
+    @property
+    def yx(self):
+        """Unit dyad of basis Vectors y and x for the ReferenceFrame."""
+        return Vector.outer(self.y, self.x)
+
+    @property
+    def yy(self):
+        """Unit dyad of basis Vectors y and y for the ReferenceFrame."""
+        return Vector.outer(self.y, self.y)
+
+    @property
+    def yz(self):
+        """Unit dyad of basis Vectors y and z for the ReferenceFrame."""
+        return Vector.outer(self.y, self.z)
+
+    @property
+    def zx(self):
+        """Unit dyad of basis Vectors z and x for the ReferenceFrame."""
+        return Vector.outer(self.z, self.x)
+
+    @property
+    def zy(self):
+        """Unit dyad of basis Vectors z and y for the ReferenceFrame."""
+        return Vector.outer(self.z, self.y)
+
+    @property
+    def zz(self):
+        """Unit dyad of basis Vectors z and z for the ReferenceFrame."""
+        return Vector.outer(self.z, self.z)
+
+    @property
+    def u(self):
+        """Unit dyadic for the ReferenceFrame."""
+        return self.xx + self.yy + self.zz
+
+    def partial_velocity(self, frame, *gen_speeds):
+        """Returns the partial angular velocities of this frame in the given
+        frame with respect to one or more provided generalized speeds.
+
+        Parameters
+        ==========
+        frame : ReferenceFrame
+            The frame with which the angular velocity is defined in.
+        gen_speeds : functions of time
+            The generalized speeds.
+
+        Returns
+        =======
+        partial_velocities : tuple of Vector
+            The partial angular velocity vectors corresponding to the provided
+            generalized speeds.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, dynamicsymbols
+        >>> N = ReferenceFrame('N')
+        >>> A = ReferenceFrame('A')
+        >>> u1, u2 = dynamicsymbols('u1, u2')
+        >>> A.set_ang_vel(N, u1 * A.x + u2 * N.y)
+        >>> A.partial_velocity(N, u1)
+        A.x
+        >>> A.partial_velocity(N, u1, u2)
+        (A.x, N.y)
+
+        """
+
+        from sympy.physics.vector.functions import partial_velocity
+
+        vel = self.ang_vel_in(frame)
+        partials = partial_velocity([vel], gen_speeds, frame)[0]
+
+        if len(partials) == 1:
+            return partials[0]
+        else:
+            return tuple(partials)
+
+
+def _check_frame(other):
+    from .vector import VectorTypeError
+    if not isinstance(other, ReferenceFrame):
+        raise VectorTypeError(other, ReferenceFrame('A'))

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/vector/functions.py

@@ -0,0 +1,650 @@
+from functools import reduce
+
+from sympy import (sympify, diff, sin, cos, Matrix, symbols,
+                                Function, S, Symbol, linear_eq_to_matrix)
+from sympy.integrals.integrals import integrate
+from sympy.simplify.trigsimp import trigsimp
+from .vector import Vector, _check_vector
+from .frame import CoordinateSym, _check_frame
+from .dyadic import Dyadic
+from .printing import vprint, vsprint, vpprint, vlatex, init_vprinting
+from sympy.utilities.iterables import iterable
+from sympy.utilities.misc import translate
+
+__all__ = ['cross', 'dot', 'express', 'time_derivative', 'outer',
+           'kinematic_equations', 'get_motion_params', 'partial_velocity',
+           'dynamicsymbols', 'vprint', 'vsprint', 'vpprint', 'vlatex',
+           'init_vprinting']
+
+
+def cross(vec1, vec2):
+    """Cross product convenience wrapper for Vector.cross(): \n"""
+    if not isinstance(vec1, (Vector, Dyadic)):
+        raise TypeError('Cross product is between two vectors')
+    return vec1 ^ vec2
+
+
+cross.__doc__ += Vector.cross.__doc__  # type: ignore
+
+
+def dot(vec1, vec2):
+    """Dot product convenience wrapper for Vector.dot(): \n"""
+    if not isinstance(vec1, (Vector, Dyadic)):
+        raise TypeError('Dot product is between two vectors')
+    return vec1 & vec2
+
+
+dot.__doc__ += Vector.dot.__doc__  # type: ignore
+
+
+def express(expr, frame, frame2=None, variables=False):
+    """
+    Global function for 'express' functionality.
+
+    Re-expresses a Vector, scalar(sympyfiable) or Dyadic in given frame.
+
+    Refer to the local methods of Vector and Dyadic for details.
+    If 'variables' is True, then the coordinate variables (CoordinateSym
+    instances) of other frames present in the vector/scalar field or
+    dyadic expression are also substituted in terms of the base scalars of
+    this frame.
+
+    Parameters
+    ==========
+
+    expr : Vector/Dyadic/scalar(sympyfiable)
+        The expression to re-express in ReferenceFrame 'frame'
+
+    frame: ReferenceFrame
+        The reference frame to express expr in
+
+    frame2 : ReferenceFrame
+        The other frame required for re-expression(only for Dyadic expr)
+
+    variables : boolean
+        Specifies whether to substitute the coordinate variables present
+        in expr, in terms of those of frame
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame, outer, dynamicsymbols
+    >>> from sympy.physics.vector import init_vprinting
+    >>> init_vprinting(pretty_print=False)
+    >>> N = ReferenceFrame('N')
+    >>> q = dynamicsymbols('q')
+    >>> B = N.orientnew('B', 'Axis', [q, N.z])
+    >>> d = outer(N.x, N.x)
+    >>> from sympy.physics.vector import express
+    >>> express(d, B, N)
+    cos(q)*(B.x|N.x) - sin(q)*(B.y|N.x)
+    >>> express(B.x, N)
+    cos(q)*N.x + sin(q)*N.y
+    >>> express(N[0], B, variables=True)
+    B_x*cos(q) - B_y*sin(q)
+
+    """
+
+    _check_frame(frame)
+
+    if expr == 0:
+        return expr
+
+    if isinstance(expr, Vector):
+        # Given expr is a Vector
+        if variables:
+            # If variables attribute is True, substitute the coordinate
+            # variables in the Vector
+            frame_list = [x[-1] for x in expr.args]
+            subs_dict = {}
+            for f in frame_list:
+                subs_dict.update(f.variable_map(frame))
+            expr = expr.subs(subs_dict)
+        # Re-express in this frame
+        outvec = Vector([])
+        for v in expr.args:
+            if v[1] != frame:
+                temp = frame.dcm(v[1]) * v[0]
+                if Vector.simp:
+                    temp = temp.applyfunc(lambda x:
+                                          trigsimp(x, method='fu'))
+                outvec += Vector([(temp, frame)])
+            else:
+                outvec += Vector([v])
+        return outvec
+
+    if isinstance(expr, Dyadic):
+        if frame2 is None:
+            frame2 = frame
+        _check_frame(frame2)
+        ol = Dyadic(0)
+        for v in expr.args:
+            ol += express(v[0], frame, variables=variables) * \
+                  (express(v[1], frame, variables=variables) |
+                   express(v[2], frame2, variables=variables))
+        return ol
+
+    else:
+        if variables:
+            # Given expr is a scalar field
+            frame_set = set()
+            expr = sympify(expr)
+            # Substitute all the coordinate variables
+            for x in expr.free_symbols:
+                if isinstance(x, CoordinateSym) and x.frame != frame:
+                    frame_set.add(x.frame)
+            subs_dict = {}
+            for f in frame_set:
+                subs_dict.update(f.variable_map(frame))
+            return expr.subs(subs_dict)
+        return expr
+
+
+def time_derivative(expr, frame, order=1):
+    """
+    Calculate the time derivative of a vector/scalar field function
+    or dyadic expression in given frame.
+
+    References
+    ==========
+
+    https://en.wikipedia.org/wiki/Rotating_reference_frame#Time_derivatives_in_the_two_frames
+
+    Parameters
+    ==========
+
+    expr : Vector/Dyadic/sympifyable
+        The expression whose time derivative is to be calculated
+
+    frame : ReferenceFrame
+        The reference frame to calculate the time derivative in
+
+    order : integer
+        The order of the derivative to be calculated
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame, dynamicsymbols
+    >>> from sympy.physics.vector import init_vprinting
+    >>> init_vprinting(pretty_print=False)
+    >>> from sympy import Symbol
+    >>> q1 = Symbol('q1')
+    >>> u1 = dynamicsymbols('u1')
+    >>> N = ReferenceFrame('N')
+    >>> A = N.orientnew('A', 'Axis', [q1, N.x])
+    >>> v = u1 * N.x
+    >>> A.set_ang_vel(N, 10*A.x)
+    >>> from sympy.physics.vector import time_derivative
+    >>> time_derivative(v, N)
+    u1'*N.x
+    >>> time_derivative(u1*A[0], N)
+    N_x*u1'
+    >>> B = N.orientnew('B', 'Axis', [u1, N.z])
+    >>> from sympy.physics.vector import outer
+    >>> d = outer(N.x, N.x)
+    >>> time_derivative(d, B)
+    - u1'*(N.y|N.x) - u1'*(N.x|N.y)
+
+    """
+
+    t = dynamicsymbols._t
+    _check_frame(frame)
+
+    if order == 0:
+        return expr
+    if order % 1 != 0 or order < 0:
+        raise ValueError("Unsupported value of order entered")
+
+    if isinstance(expr, Vector):
+        outlist = []
+        for v in expr.args:
+            if v[1] == frame:
+                outlist += [(express(v[0], frame, variables=True).diff(t),
+                             frame)]
+            else:
+                outlist += (time_derivative(Vector([v]), v[1]) +
+                            (v[1].ang_vel_in(frame) ^ Vector([v]))).args
+        outvec = Vector(outlist)
+        return time_derivative(outvec, frame, order - 1)
+
+    if isinstance(expr, Dyadic):
+        ol = Dyadic(0)
+        for v in expr.args:
+            ol += (v[0].diff(t) * (v[1] | v[2]))
+            ol += (v[0] * (time_derivative(v[1], frame) | v[2]))
+            ol += (v[0] * (v[1] | time_derivative(v[2], frame)))
+        return time_derivative(ol, frame, order - 1)
+
+    else:
+        return diff(express(expr, frame, variables=True), t, order)
+
+
+def outer(vec1, vec2):
+    """Outer product convenience wrapper for Vector.outer():\n"""
+    if not isinstance(vec1, Vector):
+        raise TypeError('Outer product is between two Vectors')
+    return vec1.outer(vec2)
+
+
+outer.__doc__ += Vector.outer.__doc__  # type: ignore
+
+
+def kinematic_equations(speeds, coords, rot_type, rot_order=''):
+    """Gives equations relating the qdot's to u's for a rotation type.
+
+    Supply rotation type and order as in orient. Speeds are assumed to be
+    body-fixed; if we are defining the orientation of B in A using by rot_type,
+    the angular velocity of B in A is assumed to be in the form: speed[0]*B.x +
+    speed[1]*B.y + speed[2]*B.z
+
+    Parameters
+    ==========
+
+    speeds : list of length 3
+        The body fixed angular velocity measure numbers.
+    coords : list of length 3 or 4
+        The coordinates used to define the orientation of the two frames.
+    rot_type : str
+        The type of rotation used to create the equations. Body, Space, or
+        Quaternion only
+    rot_order : str or int
+        If applicable, the order of a series of rotations.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import dynamicsymbols
+    >>> from sympy.physics.vector import kinematic_equations, vprint
+    >>> u1, u2, u3 = dynamicsymbols('u1 u2 u3')
+    >>> q1, q2, q3 = dynamicsymbols('q1 q2 q3')
+    >>> vprint(kinematic_equations([u1,u2,u3], [q1,q2,q3], 'body', '313'),
+    ...     order=None)
+    [-(u1*sin(q3) + u2*cos(q3))/sin(q2) + q1', -u1*cos(q3) + u2*sin(q3) + q2', (u1*sin(q3) + u2*cos(q3))*cos(q2)/sin(q2) - u3 + q3']
+
+    """
+
+    # Code below is checking and sanitizing input
+    approved_orders = ('123', '231', '312', '132', '213', '321', '121', '131',
+                       '212', '232', '313', '323', '1', '2', '3', '')
+    # make sure XYZ => 123 and rot_type is in lower case
+    rot_order = translate(str(rot_order), 'XYZxyz', '123123')
+    rot_type = rot_type.lower()
+
+    if not isinstance(speeds, (list, tuple)):
+        raise TypeError('Need to supply speeds in a list')
+    if len(speeds) != 3:
+        raise TypeError('Need to supply 3 body-fixed speeds')
+    if not isinstance(coords, (list, tuple)):
+        raise TypeError('Need to supply coordinates in a list')
+    if rot_type in ['body', 'space']:
+        if rot_order not in approved_orders:
+            raise ValueError('Not an acceptable rotation order')
+        if len(coords) != 3:
+            raise ValueError('Need 3 coordinates for body or space')
+        # Actual hard-coded kinematic differential equations
+        w1, w2, w3 = speeds
+        if w1 == w2 == w3 == 0:
+            return [S.Zero]*3
+        q1, q2, q3 = coords
+        q1d, q2d, q3d = [diff(i, dynamicsymbols._t) for i in coords]
+        s1, s2, s3 = [sin(q1), sin(q2), sin(q3)]
+        c1, c2, c3 = [cos(q1), cos(q2), cos(q3)]
+        if rot_type == 'body':
+            if rot_order == '123':
+                return [q1d - (w1 * c3 - w2 * s3) / c2, q2d - w1 * s3 - w2 *
+                        c3, q3d - (-w1 * c3 + w2 * s3) * s2 / c2 - w3]
+            if rot_order == '231':
+                return [q1d - (w2 * c3 - w3 * s3) / c2, q2d - w2 * s3 - w3 *
+                        c3, q3d - w1 - (- w2 * c3 + w3 * s3) * s2 / c2]
+            if rot_order == '312':
+                return [q1d - (-w1 * s3 + w3 * c3) / c2, q2d - w1 * c3 - w3 *
+                        s3, q3d - (w1 * s3 - w3 * c3) * s2 / c2 - w2]
+            if rot_order == '132':
+                return [q1d - (w1 * c3 + w3 * s3) / c2, q2d + w1 * s3 - w3 *
+                        c3, q3d - (w1 * c3 + w3 * s3) * s2 / c2 - w2]
+            if rot_order == '213':
+                return [q1d - (w1 * s3 + w2 * c3) / c2, q2d - w1 * c3 + w2 *
+                        s3, q3d - (w1 * s3 + w2 * c3) * s2 / c2 - w3]
+            if rot_order == '321':
+                return [q1d - (w2 * s3 + w3 * c3) / c2, q2d - w2 * c3 + w3 *
+                        s3, q3d - w1 - (w2 * s3 + w3 * c3) * s2 / c2]
+            if rot_order == '121':
+                return [q1d - (w2 * s3 + w3 * c3) / s2, q2d - w2 * c3 + w3 *
+                        s3, q3d - w1 + (w2 * s3 + w3 * c3) * c2 / s2]
+            if rot_order == '131':
+                return [q1d - (-w2 * c3 + w3 * s3) / s2, q2d - w2 * s3 - w3 *
+                        c3, q3d - w1 - (w2 * c3 - w3 * s3) * c2 / s2]
+            if rot_order == '212':
+                return [q1d - (w1 * s3 - w3 * c3) / s2, q2d - w1 * c3 - w3 *
+                        s3, q3d - (-w1 * s3 + w3 * c3) * c2 / s2 - w2]
+            if rot_order == '232':
+                return [q1d - (w1 * c3 + w3 * s3) / s2, q2d + w1 * s3 - w3 *
+                        c3, q3d + (w1 * c3 + w3 * s3) * c2 / s2 - w2]
+            if rot_order == '313':
+                return [q1d - (w1 * s3 + w2 * c3) / s2, q2d - w1 * c3 + w2 *
+                        s3, q3d + (w1 * s3 + w2 * c3) * c2 / s2 - w3]
+            if rot_order == '323':
+                return [q1d - (-w1 * c3 + w2 * s3) / s2, q2d - w1 * s3 - w2 *
+                        c3, q3d - (w1 * c3 - w2 * s3) * c2 / s2 - w3]
+        if rot_type == 'space':
+            if rot_order == '123':
+                return [q1d - w1 - (w2 * s1 + w3 * c1) * s2 / c2, q2d - w2 *
+                        c1 + w3 * s1, q3d - (w2 * s1 + w3 * c1) / c2]
+            if rot_order == '231':
+                return [q1d - (w1 * c1 + w3 * s1) * s2 / c2 - w2, q2d + w1 *
+                        s1 - w3 * c1, q3d - (w1 * c1 + w3 * s1) / c2]
+            if rot_order == '312':
+                return [q1d - (w1 * s1 + w2 * c1) * s2 / c2 - w3, q2d - w1 *
+                        c1 + w2 * s1, q3d - (w1 * s1 + w2 * c1) / c2]
+            if rot_order == '132':
+                return [q1d - w1 - (-w2 * c1 + w3 * s1) * s2 / c2, q2d - w2 *
+                        s1 - w3 * c1, q3d - (w2 * c1 - w3 * s1) / c2]
+            if rot_order == '213':
+                return [q1d - (w1 * s1 - w3 * c1) * s2 / c2 - w2, q2d - w1 *
+                        c1 - w3 * s1, q3d - (-w1 * s1 + w3 * c1) / c2]
+            if rot_order == '321':
+                return [q1d - (-w1 * c1 + w2 * s1) * s2 / c2 - w3, q2d - w1 *
+                        s1 - w2 * c1, q3d - (w1 * c1 - w2 * s1) / c2]
+            if rot_order == '121':
+                return [q1d - w1 + (w2 * s1 + w3 * c1) * c2 / s2, q2d - w2 *
+                        c1 + w3 * s1, q3d - (w2 * s1 + w3 * c1) / s2]
+            if rot_order == '131':
+                return [q1d - w1 - (w2 * c1 - w3 * s1) * c2 / s2, q2d - w2 *
+                        s1 - w3 * c1, q3d - (-w2 * c1 + w3 * s1) / s2]
+            if rot_order == '212':
+                return [q1d - (-w1 * s1 + w3 * c1) * c2 / s2 - w2, q2d - w1 *
+                        c1 - w3 * s1, q3d - (w1 * s1 - w3 * c1) / s2]
+            if rot_order == '232':
+                return [q1d + (w1 * c1 + w3 * s1) * c2 / s2 - w2, q2d + w1 *
+                        s1 - w3 * c1, q3d - (w1 * c1 + w3 * s1) / s2]
+            if rot_order == '313':
+                return [q1d + (w1 * s1 + w2 * c1) * c2 / s2 - w3, q2d - w1 *
+                        c1 + w2 * s1, q3d - (w1 * s1 + w2 * c1) / s2]
+            if rot_order == '323':
+                return [q1d - (w1 * c1 - w2 * s1) * c2 / s2 - w3, q2d - w1 *
+                        s1 - w2 * c1, q3d - (-w1 * c1 + w2 * s1) / s2]
+    elif rot_type == 'quaternion':
+        if rot_order != '':
+            raise ValueError('Cannot have rotation order for quaternion')
+        if len(coords) != 4:
+            raise ValueError('Need 4 coordinates for quaternion')
+        # Actual hard-coded kinematic differential equations
+        e0, e1, e2, e3 = coords
+        w = Matrix(speeds + [0])
+        E = Matrix([[e0, -e3, e2, e1],
+                    [e3, e0, -e1, e2],
+                    [-e2, e1, e0, e3],
+                    [-e1, -e2, -e3, e0]])
+        edots = Matrix([diff(i, dynamicsymbols._t) for i in [e1, e2, e3, e0]])
+        return list(edots.T - 0.5 * w.T * E.T)
+    else:
+        raise ValueError('Not an approved rotation type for this function')
+
+
+def get_motion_params(frame, **kwargs):
+    """
+    Returns the three motion parameters - (acceleration, velocity, and
+    position) as vectorial functions of time in the given frame.
+
+    If a higher order differential function is provided, the lower order
+    functions are used as boundary conditions. For example, given the
+    acceleration, the velocity and position parameters are taken as
+    boundary conditions.
+
+    The values of time at which the boundary conditions are specified
+    are taken from timevalue1(for position boundary condition) and
+    timevalue2(for velocity boundary condition).
+
+    If any of the boundary conditions are not provided, they are taken
+    to be zero by default (zero vectors, in case of vectorial inputs). If
+    the boundary conditions are also functions of time, they are converted
+    to constants by substituting the time values in the dynamicsymbols._t
+    time Symbol.
+
+    This function can also be used for calculating rotational motion
+    parameters. Have a look at the Parameters and Examples for more clarity.
+
+    Parameters
+    ==========
+
+    frame : ReferenceFrame
+        The frame to express the motion parameters in
+
+    acceleration : Vector
+        Acceleration of the object/frame as a function of time
+
+    velocity : Vector
+        Velocity as function of time or as boundary condition
+        of velocity at time = timevalue1
+
+    position : Vector
+        Velocity as function of time or as boundary condition
+        of velocity at time = timevalue1
+
+    timevalue1 : sympyfiable
+        Value of time for position boundary condition
+
+    timevalue2 : sympyfiable
+        Value of time for velocity boundary condition
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import ReferenceFrame, get_motion_params, dynamicsymbols
+    >>> from sympy.physics.vector import init_vprinting
+    >>> init_vprinting(pretty_print=False)
+    >>> from sympy import symbols
+    >>> R = ReferenceFrame('R')
+    >>> v1, v2, v3 = dynamicsymbols('v1 v2 v3')
+    >>> v = v1*R.x + v2*R.y + v3*R.z
+    >>> get_motion_params(R, position = v)
+    (v1''*R.x + v2''*R.y + v3''*R.z, v1'*R.x + v2'*R.y + v3'*R.z, v1*R.x + v2*R.y + v3*R.z)
+    >>> a, b, c = symbols('a b c')
+    >>> v = a*R.x + b*R.y + c*R.z
+    >>> get_motion_params(R, velocity = v)
+    (0, a*R.x + b*R.y + c*R.z, a*t*R.x + b*t*R.y + c*t*R.z)
+    >>> parameters = get_motion_params(R, acceleration = v)
+    >>> parameters[1]
+    a*t*R.x + b*t*R.y + c*t*R.z
+    >>> parameters[2]
+    a*t**2/2*R.x + b*t**2/2*R.y + c*t**2/2*R.z
+
+    """
+
+    def _process_vector_differential(vectdiff, condition, variable, ordinate,
+                                     frame):
+        """
+        Helper function for get_motion methods. Finds derivative of vectdiff
+        wrt variable, and its integral using the specified boundary condition
+        at value of variable = ordinate.
+        Returns a tuple of - (derivative, function and integral) wrt vectdiff
+
+        """
+
+        # Make sure boundary condition is independent of 'variable'
+        if condition != 0:
+            condition = express(condition, frame, variables=True)
+        # Special case of vectdiff == 0
+        if vectdiff == Vector(0):
+            return (0, 0, condition)
+        # Express vectdiff completely in condition's frame to give vectdiff1
+        vectdiff1 = express(vectdiff, frame)
+        # Find derivative of vectdiff
+        vectdiff2 = time_derivative(vectdiff, frame)
+        # Integrate and use boundary condition
+        vectdiff0 = Vector(0)
+        lims = (variable, ordinate, variable)
+        for dim in frame:
+            function1 = vectdiff1.dot(dim)
+            abscissa = dim.dot(condition).subs({variable: ordinate})
+            # Indefinite integral of 'function1' wrt 'variable', using
+            # the given initial condition (ordinate, abscissa).
+            vectdiff0 += (integrate(function1, lims) + abscissa) * dim
+        # Return tuple
+        return (vectdiff2, vectdiff, vectdiff0)
+
+    _check_frame(frame)
+    # Decide mode of operation based on user's input
+    if 'acceleration' in kwargs:
+        mode = 2
+    elif 'velocity' in kwargs:
+        mode = 1
+    else:
+        mode = 0
+    # All the possible parameters in kwargs
+    # Not all are required for every case
+    # If not specified, set to default values(may or may not be used in
+    # calculations)
+    conditions = ['acceleration', 'velocity', 'position',
+                  'timevalue', 'timevalue1', 'timevalue2']
+    for i, x in enumerate(conditions):
+        if x not in kwargs:
+            if i < 3:
+                kwargs[x] = Vector(0)
+            else:
+                kwargs[x] = S.Zero
+        elif i < 3:
+            _check_vector(kwargs[x])
+        else:
+            kwargs[x] = sympify(kwargs[x])
+    if mode == 2:
+        vel = _process_vector_differential(kwargs['acceleration'],
+                                           kwargs['velocity'],
+                                           dynamicsymbols._t,
+                                           kwargs['timevalue2'], frame)[2]
+        pos = _process_vector_differential(vel, kwargs['position'],
+                                           dynamicsymbols._t,
+                                           kwargs['timevalue1'], frame)[2]
+        return (kwargs['acceleration'], vel, pos)
+    elif mode == 1:
+        return _process_vector_differential(kwargs['velocity'],
+                                            kwargs['position'],
+                                            dynamicsymbols._t,
+                                            kwargs['timevalue1'], frame)
+    else:
+        vel = time_derivative(kwargs['position'], frame)
+        acc = time_derivative(vel, frame)
+        return (acc, vel, kwargs['position'])
+
+
+def partial_velocity(vel_vecs, gen_speeds, frame):
+    """Returns a list of partial velocities with respect to the provided
+    generalized speeds in the given reference frame for each of the supplied
+    velocity vectors.
+
+    The output is a list of lists. The outer list has a number of elements
+    equal to the number of supplied velocity vectors. The inner lists are, for
+    each velocity vector, the partial derivatives of that velocity vector with
+    respect to the generalized speeds supplied.
+
+    Parameters
+    ==========
+
+    vel_vecs : iterable
+        An iterable of velocity vectors (angular or linear).
+    gen_speeds : iterable
+        An iterable of generalized speeds.
+    frame : ReferenceFrame
+        The reference frame that the partial derivatives are going to be taken
+        in.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import Point, ReferenceFrame
+    >>> from sympy.physics.vector import dynamicsymbols
+    >>> from sympy.physics.vector import partial_velocity
+    >>> u = dynamicsymbols('u')
+    >>> N = ReferenceFrame('N')
+    >>> P = Point('P')
+    >>> P.set_vel(N, u * N.x)
+    >>> vel_vecs = [P.vel(N)]
+    >>> gen_speeds = [u]
+    >>> partial_velocity(vel_vecs, gen_speeds, N)
+    [[N.x]]
+
+    """
+
+    if not iterable(vel_vecs):
+        raise TypeError('Velocity vectors must be contained in an iterable.')
+
+    if not iterable(gen_speeds):
+        raise TypeError('Generalized speeds must be contained in an iterable')
+
+    vec_partials = []
+    gen_speeds = list(gen_speeds)
+    for vel in vel_vecs:
+        partials = [Vector(0) for _ in gen_speeds]
+        for components, ref in vel.args:
+            mat, _ = linear_eq_to_matrix(components, gen_speeds)
+            for i in range(len(gen_speeds)):
+                for dim, direction in enumerate(ref):
+                    if mat[dim, i] != 0:
+                        partials[i] += direction * mat[dim, i]
+
+        vec_partials.append(partials)
+
+    return vec_partials
+
+
+def dynamicsymbols(names, level=0, **assumptions):
+    """Uses symbols and Function for functions of time.
+
+    Creates a SymPy UndefinedFunction, which is then initialized as a function
+    of a variable, the default being Symbol('t').
+
+    Parameters
+    ==========
+
+    names : str
+        Names of the dynamic symbols you want to create; works the same way as
+        inputs to symbols
+    level : int
+        Level of differentiation of the returned function; d/dt once of t,
+        twice of t, etc.
+    assumptions :
+        - real(bool) : This is used to set the dynamicsymbol as real,
+                    by default is False.
+        - positive(bool) : This is used to set the dynamicsymbol as positive,
+                    by default is False.
+        - commutative(bool) : This is used to set the commutative property of
+                    a dynamicsymbol, by default is True.
+        - integer(bool) : This is used to set the dynamicsymbol as integer,
+                    by default is False.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import dynamicsymbols
+    >>> from sympy import diff, Symbol
+    >>> q1 = dynamicsymbols('q1')
+    >>> q1
+    q1(t)
+    >>> q2 = dynamicsymbols('q2', real=True)
+    >>> q2.is_real
+    True
+    >>> q3 = dynamicsymbols('q3', positive=True)
+    >>> q3.is_positive
+    True
+    >>> q4, q5 = dynamicsymbols('q4,q5', commutative=False)
+    >>> bool(q4*q5 != q5*q4)
+    True
+    >>> q6 = dynamicsymbols('q6', integer=True)
+    >>> q6.is_integer
+    True
+    >>> diff(q1, Symbol('t'))
+    Derivative(q1(t), t)
+
+    """
+    esses = symbols(names, cls=Function, **assumptions)
+    t = dynamicsymbols._t
+    if iterable(esses):
+        esses = [reduce(diff, [t] * level, e(t)) for e in esses]
+        return esses
+    else:
+        return reduce(diff, [t] * level, esses(t))
+
+
+dynamicsymbols._t = Symbol('t')  # type: ignore
+dynamicsymbols._str = '\''  # type: ignore

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/vector/point.py

@@ -0,0 +1,635 @@
+from .vector import Vector, _check_vector
+from .frame import _check_frame
+from warnings import warn
+from sympy.utilities.misc import filldedent
+
+__all__ = ['Point']
+
+
+class Point:
+    """This object represents a point in a dynamic system.
+
+    It stores the: position, velocity, and acceleration of a point.
+    The position is a vector defined as the vector distance from a parent
+    point to this point.
+
+    Parameters
+    ==========
+
+    name : string
+        The display name of the Point
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import Point, ReferenceFrame, dynamicsymbols
+    >>> from sympy.physics.vector import init_vprinting
+    >>> init_vprinting(pretty_print=False)
+    >>> N = ReferenceFrame('N')
+    >>> O = Point('O')
+    >>> P = Point('P')
+    >>> u1, u2, u3 = dynamicsymbols('u1 u2 u3')
+    >>> O.set_vel(N, u1 * N.x + u2 * N.y + u3 * N.z)
+    >>> O.acc(N)
+    u1'*N.x + u2'*N.y + u3'*N.z
+
+    ``symbols()`` can be used to create multiple Points in a single step, for
+    example:
+
+    >>> from sympy.physics.vector import Point, ReferenceFrame, dynamicsymbols
+    >>> from sympy.physics.vector import init_vprinting
+    >>> init_vprinting(pretty_print=False)
+    >>> from sympy import symbols
+    >>> N = ReferenceFrame('N')
+    >>> u1, u2 = dynamicsymbols('u1 u2')
+    >>> A, B = symbols('A B', cls=Point)
+    >>> type(A)
+    <class 'sympy.physics.vector.point.Point'>
+    >>> A.set_vel(N, u1 * N.x + u2 * N.y)
+    >>> B.set_vel(N, u2 * N.x + u1 * N.y)
+    >>> A.acc(N) - B.acc(N)
+    (u1' - u2')*N.x + (-u1' + u2')*N.y
+
+    """
+
+    def __init__(self, name):
+        """Initialization of a Point object. """
+        self.name = name
+        self._pos_dict = {}
+        self._vel_dict = {}
+        self._acc_dict = {}
+        self._pdlist = [self._pos_dict, self._vel_dict, self._acc_dict]
+
+    def __str__(self):
+        return self.name
+
+    __repr__ = __str__
+
+    def _check_point(self, other):
+        if not isinstance(other, Point):
+            raise TypeError('A Point must be supplied')
+
+    def _pdict_list(self, other, num):
+        """Returns a list of points that gives the shortest path with respect
+        to position, velocity, or acceleration from this point to the provided
+        point.
+
+        Parameters
+        ==========
+        other : Point
+            A point that may be related to this point by position, velocity, or
+            acceleration.
+        num : integer
+            0 for searching the position tree, 1 for searching the velocity
+            tree, and 2 for searching the acceleration tree.
+
+        Returns
+        =======
+        list of Points
+            A sequence of points from self to other.
+
+        Notes
+        =====
+
+        It is not clear if num = 1 or num = 2 actually works because the keys
+        to ``_vel_dict`` and ``_acc_dict`` are :class:`ReferenceFrame` objects
+        which do not have the ``_pdlist`` attribute.
+
+        """
+        outlist = [[self]]
+        oldlist = [[]]
+        while outlist != oldlist:
+            oldlist = outlist.copy()
+            for v in outlist:
+                templist = v[-1]._pdlist[num].keys()
+                for v2 in templist:
+                    if not v.__contains__(v2):
+                        littletemplist = v + [v2]
+                        if not outlist.__contains__(littletemplist):
+                            outlist.append(littletemplist)
+        for v in oldlist:
+            if v[-1] != other:
+                outlist.remove(v)
+        outlist.sort(key=len)
+        if len(outlist) != 0:
+            return outlist[0]
+        raise ValueError('No Connecting Path found between ' + other.name +
+                         ' and ' + self.name)
+
+    def a1pt_theory(self, otherpoint, outframe, interframe):
+        """Sets the acceleration of this point with the 1-point theory.
+
+        The 1-point theory for point acceleration looks like this:
+
+        ^N a^P = ^B a^P + ^N a^O + ^N alpha^B x r^OP + ^N omega^B x (^N omega^B
+        x r^OP) + 2 ^N omega^B x ^B v^P
+
+        where O is a point fixed in B, P is a point moving in B, and B is
+        rotating in frame N.
+
+        Parameters
+        ==========
+
+        otherpoint : Point
+            The first point of the 1-point theory (O)
+        outframe : ReferenceFrame
+            The frame we want this point's acceleration defined in (N)
+        fixedframe : ReferenceFrame
+            The intermediate frame in this calculation (B)
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame
+        >>> from sympy.physics.vector import dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> q = dynamicsymbols('q')
+        >>> q2 = dynamicsymbols('q2')
+        >>> qd = dynamicsymbols('q', 1)
+        >>> q2d = dynamicsymbols('q2', 1)
+        >>> N = ReferenceFrame('N')
+        >>> B = ReferenceFrame('B')
+        >>> B.set_ang_vel(N, 5 * B.y)
+        >>> O = Point('O')
+        >>> P = O.locatenew('P', q * B.x + q2 * B.y)
+        >>> P.set_vel(B, qd * B.x + q2d * B.y)
+        >>> O.set_vel(N, 0)
+        >>> P.a1pt_theory(O, N, B)
+        (-25*q + q'')*B.x + q2''*B.y - 10*q'*B.z
+
+        """
+
+        _check_frame(outframe)
+        _check_frame(interframe)
+        self._check_point(otherpoint)
+        dist = self.pos_from(otherpoint)
+        v = self.vel(interframe)
+        a1 = otherpoint.acc(outframe)
+        a2 = self.acc(interframe)
+        omega = interframe.ang_vel_in(outframe)
+        alpha = interframe.ang_acc_in(outframe)
+        self.set_acc(outframe, a2 + 2 * (omega.cross(v)) + a1 +
+                     (alpha.cross(dist)) + (omega.cross(omega.cross(dist))))
+        return self.acc(outframe)
+
+    def a2pt_theory(self, otherpoint, outframe, fixedframe):
+        """Sets the acceleration of this point with the 2-point theory.
+
+        The 2-point theory for point acceleration looks like this:
+
+        ^N a^P = ^N a^O + ^N alpha^B x r^OP + ^N omega^B x (^N omega^B x r^OP)
+
+        where O and P are both points fixed in frame B, which is rotating in
+        frame N.
+
+        Parameters
+        ==========
+
+        otherpoint : Point
+            The first point of the 2-point theory (O)
+        outframe : ReferenceFrame
+            The frame we want this point's acceleration defined in (N)
+        fixedframe : ReferenceFrame
+            The frame in which both points are fixed (B)
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame, dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> q = dynamicsymbols('q')
+        >>> qd = dynamicsymbols('q', 1)
+        >>> N = ReferenceFrame('N')
+        >>> B = N.orientnew('B', 'Axis', [q, N.z])
+        >>> O = Point('O')
+        >>> P = O.locatenew('P', 10 * B.x)
+        >>> O.set_vel(N, 5 * N.x)
+        >>> P.a2pt_theory(O, N, B)
+        - 10*q'**2*B.x + 10*q''*B.y
+
+        """
+
+        _check_frame(outframe)
+        _check_frame(fixedframe)
+        self._check_point(otherpoint)
+        dist = self.pos_from(otherpoint)
+        a = otherpoint.acc(outframe)
+        omega = fixedframe.ang_vel_in(outframe)
+        alpha = fixedframe.ang_acc_in(outframe)
+        self.set_acc(outframe, a + (alpha.cross(dist)) +
+                     (omega.cross(omega.cross(dist))))
+        return self.acc(outframe)
+
+    def acc(self, frame):
+        """The acceleration Vector of this Point in a ReferenceFrame.
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame
+            The frame in which the returned acceleration vector will be defined
+            in.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> p1 = Point('p1')
+        >>> p1.set_acc(N, 10 * N.x)
+        >>> p1.acc(N)
+        10*N.x
+
+        """
+
+        _check_frame(frame)
+        if not (frame in self._acc_dict):
+            if self.vel(frame) != 0:
+                return (self._vel_dict[frame]).dt(frame)
+            else:
+                return Vector(0)
+        return self._acc_dict[frame]
+
+    def locatenew(self, name, value):
+        """Creates a new point with a position defined from this point.
+
+        Parameters
+        ==========
+
+        name : str
+            The name for the new point
+        value : Vector
+            The position of the new point relative to this point
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, Point
+        >>> N = ReferenceFrame('N')
+        >>> P1 = Point('P1')
+        >>> P2 = P1.locatenew('P2', 10 * N.x)
+
+        """
+
+        if not isinstance(name, str):
+            raise TypeError('Must supply a valid name')
+        if value == 0:
+            value = Vector(0)
+        value = _check_vector(value)
+        p = Point(name)
+        p.set_pos(self, value)
+        self.set_pos(p, -value)
+        return p
+
+    def pos_from(self, otherpoint):
+        """Returns a Vector distance between this Point and the other Point.
+
+        Parameters
+        ==========
+
+        otherpoint : Point
+            The otherpoint we are locating this one relative to
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> p1 = Point('p1')
+        >>> p2 = Point('p2')
+        >>> p1.set_pos(p2, 10 * N.x)
+        >>> p1.pos_from(p2)
+        10*N.x
+
+        """
+
+        outvec = Vector(0)
+        plist = self._pdict_list(otherpoint, 0)
+        for i in range(len(plist) - 1):
+            outvec += plist[i]._pos_dict[plist[i + 1]]
+        return outvec
+
+    def set_acc(self, frame, value):
+        """Used to set the acceleration of this Point in a ReferenceFrame.
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame
+            The frame in which this point's acceleration is defined
+        value : Vector
+            The vector value of this point's acceleration in the frame
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> p1 = Point('p1')
+        >>> p1.set_acc(N, 10 * N.x)
+        >>> p1.acc(N)
+        10*N.x
+
+        """
+
+        if value == 0:
+            value = Vector(0)
+        value = _check_vector(value)
+        _check_frame(frame)
+        self._acc_dict.update({frame: value})
+
+    def set_pos(self, otherpoint, value):
+        """Used to set the position of this point w.r.t. another point.
+
+        Parameters
+        ==========
+
+        otherpoint : Point
+            The other point which this point's location is defined relative to
+        value : Vector
+            The vector which defines the location of this point
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> p1 = Point('p1')
+        >>> p2 = Point('p2')
+        >>> p1.set_pos(p2, 10 * N.x)
+        >>> p1.pos_from(p2)
+        10*N.x
+
+        """
+
+        if value == 0:
+            value = Vector(0)
+        value = _check_vector(value)
+        self._check_point(otherpoint)
+        self._pos_dict.update({otherpoint: value})
+        otherpoint._pos_dict.update({self: -value})
+
+    def set_vel(self, frame, value):
+        """Sets the velocity Vector of this Point in a ReferenceFrame.
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame
+            The frame in which this point's velocity is defined
+        value : Vector
+            The vector value of this point's velocity in the frame
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame
+        >>> N = ReferenceFrame('N')
+        >>> p1 = Point('p1')
+        >>> p1.set_vel(N, 10 * N.x)
+        >>> p1.vel(N)
+        10*N.x
+
+        """
+
+        if value == 0:
+            value = Vector(0)
+        value = _check_vector(value)
+        _check_frame(frame)
+        self._vel_dict.update({frame: value})
+
+    def v1pt_theory(self, otherpoint, outframe, interframe):
+        """Sets the velocity of this point with the 1-point theory.
+
+        The 1-point theory for point velocity looks like this:
+
+        ^N v^P = ^B v^P + ^N v^O + ^N omega^B x r^OP
+
+        where O is a point fixed in B, P is a point moving in B, and B is
+        rotating in frame N.
+
+        Parameters
+        ==========
+
+        otherpoint : Point
+            The first point of the 1-point theory (O)
+        outframe : ReferenceFrame
+            The frame we want this point's velocity defined in (N)
+        interframe : ReferenceFrame
+            The intermediate frame in this calculation (B)
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame
+        >>> from sympy.physics.vector import dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> q = dynamicsymbols('q')
+        >>> q2 = dynamicsymbols('q2')
+        >>> qd = dynamicsymbols('q', 1)
+        >>> q2d = dynamicsymbols('q2', 1)
+        >>> N = ReferenceFrame('N')
+        >>> B = ReferenceFrame('B')
+        >>> B.set_ang_vel(N, 5 * B.y)
+        >>> O = Point('O')
+        >>> P = O.locatenew('P', q * B.x + q2 * B.y)
+        >>> P.set_vel(B, qd * B.x + q2d * B.y)
+        >>> O.set_vel(N, 0)
+        >>> P.v1pt_theory(O, N, B)
+        q'*B.x + q2'*B.y - 5*q*B.z
+
+        """
+
+        _check_frame(outframe)
+        _check_frame(interframe)
+        self._check_point(otherpoint)
+        dist = self.pos_from(otherpoint)
+        v1 = self.vel(interframe)
+        v2 = otherpoint.vel(outframe)
+        omega = interframe.ang_vel_in(outframe)
+        self.set_vel(outframe, v1 + v2 + (omega.cross(dist)))
+        return self.vel(outframe)
+
+    def v2pt_theory(self, otherpoint, outframe, fixedframe):
+        """Sets the velocity of this point with the 2-point theory.
+
+        The 2-point theory for point velocity looks like this:
+
+        ^N v^P = ^N v^O + ^N omega^B x r^OP
+
+        where O and P are both points fixed in frame B, which is rotating in
+        frame N.
+
+        Parameters
+        ==========
+
+        otherpoint : Point
+            The first point of the 2-point theory (O)
+        outframe : ReferenceFrame
+            The frame we want this point's velocity defined in (N)
+        fixedframe : ReferenceFrame
+            The frame in which both points are fixed (B)
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame, dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> q = dynamicsymbols('q')
+        >>> qd = dynamicsymbols('q', 1)
+        >>> N = ReferenceFrame('N')
+        >>> B = N.orientnew('B', 'Axis', [q, N.z])
+        >>> O = Point('O')
+        >>> P = O.locatenew('P', 10 * B.x)
+        >>> O.set_vel(N, 5 * N.x)
+        >>> P.v2pt_theory(O, N, B)
+        5*N.x + 10*q'*B.y
+
+        """
+
+        _check_frame(outframe)
+        _check_frame(fixedframe)
+        self._check_point(otherpoint)
+        dist = self.pos_from(otherpoint)
+        v = otherpoint.vel(outframe)
+        omega = fixedframe.ang_vel_in(outframe)
+        self.set_vel(outframe, v + (omega.cross(dist)))
+        return self.vel(outframe)
+
+    def vel(self, frame):
+        """The velocity Vector of this Point in the ReferenceFrame.
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame
+            The frame in which the returned velocity vector will be defined in
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import Point, ReferenceFrame, dynamicsymbols
+        >>> N = ReferenceFrame('N')
+        >>> p1 = Point('p1')
+        >>> p1.set_vel(N, 10 * N.x)
+        >>> p1.vel(N)
+        10*N.x
+
+        Velocities will be automatically calculated if possible, otherwise a
+        ``ValueError`` will be returned. If it is possible to calculate
+        multiple different velocities from the relative points, the points
+        defined most directly relative to this point will be used. In the case
+        of inconsistent relative positions of points, incorrect velocities may
+        be returned. It is up to the user to define prior relative positions
+        and velocities of points in a self-consistent way.
+
+        >>> p = Point('p')
+        >>> q = dynamicsymbols('q')
+        >>> p.set_vel(N, 10 * N.x)
+        >>> p2 = Point('p2')
+        >>> p2.set_pos(p, q*N.x)
+        >>> p2.vel(N)
+        (Derivative(q(t), t) + 10)*N.x
+
+        """
+
+        _check_frame(frame)
+        if not (frame in self._vel_dict):
+            valid_neighbor_found = False
+            is_cyclic = False
+            visited = []
+            queue = [self]
+            candidate_neighbor = []
+            while queue:  # BFS to find nearest point
+                node = queue.pop(0)
+                if node not in visited:
+                    visited.append(node)
+                    for neighbor, neighbor_pos in node._pos_dict.items():
+                        if neighbor in visited:
+                            continue
+                        try:
+                            # Checks if pos vector is valid
+                            neighbor_pos.express(frame)
+                        except ValueError:
+                            continue
+                        if neighbor in queue:
+                            is_cyclic = True
+                        try:
+                            # Checks if point has its vel defined in req frame
+                            neighbor_velocity = neighbor._vel_dict[frame]
+                        except KeyError:
+                            queue.append(neighbor)
+                            continue
+                        candidate_neighbor.append(neighbor)
+                        if not valid_neighbor_found:
+                            self.set_vel(frame, self.pos_from(neighbor).dt(frame) + neighbor_velocity)
+                            valid_neighbor_found = True
+            if is_cyclic:
+                warn(filldedent("""
+                Kinematic loops are defined among the positions of points. This
+                is likely not desired and may cause errors in your calculations.
+                """))
+            if len(candidate_neighbor) > 1:
+                warn(filldedent(f"""
+                Velocity of {self.name} automatically calculated based on point
+                {candidate_neighbor[0].name} but it is also possible from
+                points(s): {str(candidate_neighbor[1:])}. Velocities from these
+                points are not necessarily the same. This may cause errors in
+                your calculations."""))
+            if valid_neighbor_found:
+                return self._vel_dict[frame]
+            else:
+                raise ValueError(filldedent(f"""
+                Velocity of point {self.name} has not been defined in
+                ReferenceFrame {frame.name}."""))
+
+        return self._vel_dict[frame]
+
+    def partial_velocity(self, frame, *gen_speeds):
+        """Returns the partial velocities of the linear velocity vector of this
+        point in the given frame with respect to one or more provided
+        generalized speeds.
+
+        Parameters
+        ==========
+        frame : ReferenceFrame
+            The frame with which the velocity is defined in.
+        gen_speeds : functions of time
+            The generalized speeds.
+
+        Returns
+        =======
+        partial_velocities : tuple of Vector
+            The partial velocity vectors corresponding to the provided
+            generalized speeds.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, Point
+        >>> from sympy.physics.vector import dynamicsymbols
+        >>> N = ReferenceFrame('N')
+        >>> A = ReferenceFrame('A')
+        >>> p = Point('p')
+        >>> u1, u2 = dynamicsymbols('u1, u2')
+        >>> p.set_vel(N, u1 * N.x + u2 * A.y)
+        >>> p.partial_velocity(N, u1)
+        N.x
+        >>> p.partial_velocity(N, u1, u2)
+        (N.x, A.y)
+
+        """
+
+        from sympy.physics.vector.functions import partial_velocity
+
+        vel = self.vel(frame)
+        partials = partial_velocity([vel], gen_speeds, frame)[0]
+
+        if len(partials) == 1:
+            return partials[0]
+        else:
+            return tuple(partials)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/vector/printing.py

@@ -0,0 +1,371 @@
+from sympy.core.function import Derivative
+from sympy.core.function import UndefinedFunction, AppliedUndef
+from sympy.core.symbol import Symbol
+from sympy.interactive.printing import init_printing
+from sympy.printing.latex import LatexPrinter
+from sympy.printing.pretty.pretty import PrettyPrinter
+from sympy.printing.pretty.pretty_symbology import center_accent
+from sympy.printing.str import StrPrinter
+from sympy.printing.precedence import PRECEDENCE
+
+__all__ = ['vprint', 'vsstrrepr', 'vsprint', 'vpprint', 'vlatex',
+           'init_vprinting']
+
+
+class VectorStrPrinter(StrPrinter):
+    """String Printer for vector expressions. """
+
+    def _print_Derivative(self, e):
+        from sympy.physics.vector.functions import dynamicsymbols
+        t = dynamicsymbols._t
+        if (bool(sum(i == t for i in e.variables)) &
+                isinstance(type(e.args[0]), UndefinedFunction)):
+            ol = str(e.args[0].func)
+            for i, v in enumerate(e.variables):
+                ol += dynamicsymbols._str
+            return ol
+        else:
+            return StrPrinter().doprint(e)
+
+    def _print_Function(self, e):
+        from sympy.physics.vector.functions import dynamicsymbols
+        t = dynamicsymbols._t
+        if isinstance(type(e), UndefinedFunction):
+            return StrPrinter().doprint(e).replace("(%s)" % t, '')
+        return e.func.__name__ + "(%s)" % self.stringify(e.args, ", ")
+
+
+class VectorStrReprPrinter(VectorStrPrinter):
+    """String repr printer for vector expressions."""
+    def _print_str(self, s):
+        return repr(s)
+
+
+class VectorLatexPrinter(LatexPrinter):
+    """Latex Printer for vector expressions. """
+
+    def _print_Function(self, expr, exp=None):
+        from sympy.physics.vector.functions import dynamicsymbols
+        func = expr.func.__name__
+        t = dynamicsymbols._t
+
+        if (hasattr(self, '_print_' + func) and not
+            isinstance(type(expr), UndefinedFunction)):
+            return getattr(self, '_print_' + func)(expr, exp)
+        elif isinstance(type(expr), UndefinedFunction) and (expr.args == (t,)):
+            # treat this function like a symbol
+            expr = Symbol(func)
+            if exp is not None:
+                # copied from LatexPrinter._helper_print_standard_power, which
+                # we can't call because we only have exp as a string.
+                base = self.parenthesize(expr, PRECEDENCE['Pow'])
+                base = self.parenthesize_super(base)
+                return r"%s^{%s}" % (base, exp)
+            else:
+                return super()._print(expr)
+        else:
+            return super()._print_Function(expr, exp)
+
+    def _print_Derivative(self, der_expr):
+        from sympy.physics.vector.functions import dynamicsymbols
+        # make sure it is in the right form
+        der_expr = der_expr.doit()
+        if not isinstance(der_expr, Derivative):
+            return r"\left(%s\right)" % self.doprint(der_expr)
+
+        # check if expr is a dynamicsymbol
+        t = dynamicsymbols._t
+        expr = der_expr.expr
+        red = expr.atoms(AppliedUndef)
+        syms = der_expr.variables
+        test1 = not all(True for i in red if i.free_symbols == {t})
+        test2 = not all(t == i for i in syms)
+        if test1 or test2:
+            return super()._print_Derivative(der_expr)
+
+        # done checking
+        dots = len(syms)
+        base = self._print_Function(expr)
+        base_split = base.split('_', 1)
+        base = base_split[0]
+        if dots == 1:
+            base = r"\dot{%s}" % base
+        elif dots == 2:
+            base = r"\ddot{%s}" % base
+        elif dots == 3:
+            base = r"\dddot{%s}" % base
+        elif dots == 4:
+            base = r"\ddddot{%s}" % base
+        else:  # Fallback to standard printing
+            return super()._print_Derivative(der_expr)
+        if len(base_split) != 1:
+            base += '_' + base_split[1]
+        return base
+
+
+class VectorPrettyPrinter(PrettyPrinter):
+    """Pretty Printer for vectorialexpressions. """
+
+    def _print_Derivative(self, deriv):
+        from sympy.physics.vector.functions import dynamicsymbols
+        # XXX use U('PARTIAL DIFFERENTIAL') here ?
+        t = dynamicsymbols._t
+        dot_i = 0
+        syms = list(reversed(deriv.variables))
+
+        while len(syms) > 0:
+            if syms[-1] == t:
+                syms.pop()
+                dot_i += 1
+            else:
+                return super()._print_Derivative(deriv)
+
+        if not (isinstance(type(deriv.expr), UndefinedFunction) and
+                (deriv.expr.args == (t,))):
+            return super()._print_Derivative(deriv)
+        else:
+            pform = self._print_Function(deriv.expr)
+
+        # the following condition would happen with some sort of non-standard
+        # dynamic symbol I guess, so we'll just print the SymPy way
+        if len(pform.picture) > 1:
+            return super()._print_Derivative(deriv)
+
+        # There are only special symbols up to fourth-order derivatives
+        if dot_i >= 5:
+            return super()._print_Derivative(deriv)
+
+        # Deal with special symbols
+        dots = {0: "",
+                1: "\N{COMBINING DOT ABOVE}",
+                2: "\N{COMBINING DIAERESIS}",
+                3: "\N{COMBINING THREE DOTS ABOVE}",
+                4: "\N{COMBINING FOUR DOTS ABOVE}"}
+
+        d = pform.__dict__
+        # if unicode is false then calculate number of apostrophes needed and
+        # add to output
+        if not self._use_unicode:
+            apostrophes = ""
+            for i in range(0, dot_i):
+                apostrophes += "'"
+            d['picture'][0] += apostrophes + "(t)"
+        else:
+            d['picture'] = [center_accent(d['picture'][0], dots[dot_i])]
+        return pform
+
+    def _print_Function(self, e):
+        from sympy.physics.vector.functions import dynamicsymbols
+        t = dynamicsymbols._t
+        # XXX works only for applied functions
+        func = e.func
+        args = e.args
+        func_name = func.__name__
+        pform = self._print_Symbol(Symbol(func_name))
+        # If this function is an Undefined function of t, it is probably a
+        # dynamic symbol, so we'll skip the (t). The rest of the code is
+        # identical to the normal PrettyPrinter code
+        if not (isinstance(func, UndefinedFunction) and (args == (t,))):
+            return super()._print_Function(e)
+        return pform
+
+
+def vprint(expr, **settings):
+    r"""Function for printing of expressions generated in the
+    sympy.physics vector package.
+
+    Extends SymPy's StrPrinter, takes the same setting accepted by SymPy's
+    :func:`~.sstr`, and is equivalent to ``print(sstr(foo))``.
+
+    Parameters
+    ==========
+
+    expr : valid SymPy object
+        SymPy expression to print.
+    settings : args
+        Same as the settings accepted by SymPy's sstr().
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import vprint, dynamicsymbols
+    >>> u1 = dynamicsymbols('u1')
+    >>> print(u1)
+    u1(t)
+    >>> vprint(u1)
+    u1
+
+    """
+
+    outstr = vsprint(expr, **settings)
+
+    import builtins
+    if (outstr != 'None'):
+        builtins._ = outstr
+        print(outstr)
+
+
+def vsstrrepr(expr, **settings):
+    """Function for displaying expression representation's with vector
+    printing enabled.
+
+    Parameters
+    ==========
+
+    expr : valid SymPy object
+        SymPy expression to print.
+    settings : args
+        Same as the settings accepted by SymPy's sstrrepr().
+
+    """
+    p = VectorStrReprPrinter(settings)
+    return p.doprint(expr)
+
+
+def vsprint(expr, **settings):
+    r"""Function for displaying expressions generated in the
+    sympy.physics vector package.
+
+    Returns the output of vprint() as a string.
+
+    Parameters
+    ==========
+
+    expr : valid SymPy object
+        SymPy expression to print
+    settings : args
+        Same as the settings accepted by SymPy's sstr().
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import vsprint, dynamicsymbols
+    >>> u1, u2 = dynamicsymbols('u1 u2')
+    >>> u2d = dynamicsymbols('u2', level=1)
+    >>> print("%s = %s" % (u1, u2 + u2d))
+    u1(t) = u2(t) + Derivative(u2(t), t)
+    >>> print("%s = %s" % (vsprint(u1), vsprint(u2 + u2d)))
+    u1 = u2 + u2'
+
+    """
+
+    string_printer = VectorStrPrinter(settings)
+    return string_printer.doprint(expr)
+
+
+def vpprint(expr, **settings):
+    r"""Function for pretty printing of expressions generated in the
+    sympy.physics vector package.
+
+    Mainly used for expressions not inside a vector; the output of running
+    scripts and generating equations of motion. Takes the same options as
+    SymPy's :func:`~.pretty_print`; see that function for more information.
+
+    Parameters
+    ==========
+
+    expr : valid SymPy object
+        SymPy expression to pretty print
+    settings : args
+        Same as those accepted by SymPy's pretty_print.
+
+
+    """
+
+    pp = VectorPrettyPrinter(settings)
+
+    # Note that this is copied from sympy.printing.pretty.pretty_print:
+
+    # XXX: this is an ugly hack, but at least it works
+    use_unicode = pp._settings['use_unicode']
+    from sympy.printing.pretty.pretty_symbology import pretty_use_unicode
+    uflag = pretty_use_unicode(use_unicode)
+
+    try:
+        return pp.doprint(expr)
+    finally:
+        pretty_use_unicode(uflag)
+
+
+def vlatex(expr, **settings):
+    r"""Function for printing latex representation of sympy.physics.vector
+    objects.
+
+    For latex representation of Vectors, Dyadics, and dynamicsymbols. Takes the
+    same options as SymPy's :func:`~.latex`; see that function for more
+    information;
+
+    Parameters
+    ==========
+
+    expr : valid SymPy object
+        SymPy expression to represent in LaTeX form
+    settings : args
+        Same as latex()
+
+    Examples
+    ========
+
+    >>> from sympy.physics.vector import vlatex, ReferenceFrame, dynamicsymbols
+    >>> N = ReferenceFrame('N')
+    >>> q1, q2 = dynamicsymbols('q1 q2')
+    >>> q1d, q2d = dynamicsymbols('q1 q2', 1)
+    >>> q1dd, q2dd = dynamicsymbols('q1 q2', 2)
+    >>> vlatex(N.x + N.y)
+    '\\mathbf{\\hat{n}_x} + \\mathbf{\\hat{n}_y}'
+    >>> vlatex(q1 + q2)
+    'q_{1} + q_{2}'
+    >>> vlatex(q1d)
+    '\\dot{q}_{1}'
+    >>> vlatex(q1 * q2d)
+    'q_{1} \\dot{q}_{2}'
+    >>> vlatex(q1dd * q1 / q1d)
+    '\\frac{q_{1} \\ddot{q}_{1}}{\\dot{q}_{1}}'
+
+    """
+    latex_printer = VectorLatexPrinter(settings)
+
+    return latex_printer.doprint(expr)
+
+
+def init_vprinting(**kwargs):
+    """Initializes time derivative printing for all SymPy objects, i.e. any
+    functions of time will be displayed in a more compact notation. The main
+    benefit of this is for printing of time derivatives; instead of
+    displaying as ``Derivative(f(t),t)``, it will display ``f'``. This is
+    only actually needed for when derivatives are present and are not in a
+    physics.vector.Vector or physics.vector.Dyadic object. This function is a
+    light wrapper to :func:`~.init_printing`. Any keyword
+    arguments for it are valid here.
+
+    {0}
+
+    Examples
+    ========
+
+    >>> from sympy import Function, symbols
+    >>> t, x = symbols('t, x')
+    >>> omega = Function('omega')
+    >>> omega(x).diff()
+    Derivative(omega(x), x)
+    >>> omega(t).diff()
+    Derivative(omega(t), t)
+
+    Now use the string printer:
+
+    >>> from sympy.physics.vector import init_vprinting
+    >>> init_vprinting(pretty_print=False)
+    >>> omega(x).diff()
+    Derivative(omega(x), x)
+    >>> omega(t).diff()
+    omega'
+
+    """
+    kwargs['str_printer'] = vsstrrepr
+    kwargs['pretty_printer'] = vpprint
+    kwargs['latex_printer'] = vlatex
+    init_printing(**kwargs)
+
+
+params = init_printing.__doc__.split('Examples\n    ========')[0]  # type: ignore
+init_vprinting.__doc__ = init_vprinting.__doc__.format(params)  # type: ignore

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/vector/tests/test_dyadic.py

@@ -0,0 +1,123 @@
+from sympy.core.numbers import (Float, pi)
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.matrices.immutable import ImmutableDenseMatrix as Matrix
+from sympy.physics.vector import ReferenceFrame, dynamicsymbols, outer
+from sympy.physics.vector.dyadic import _check_dyadic
+from sympy.testing.pytest import raises
+
+A = ReferenceFrame('A')
+
+
+def test_dyadic():
+    d1 = A.x | A.x
+    d2 = A.y | A.y
+    d3 = A.x | A.y
+    assert d1 * 0 == 0
+    assert d1 != 0
+    assert d1 * 2 == 2 * A.x | A.x
+    assert d1 / 2. == 0.5 * d1
+    assert d1 & (0 * d1) == 0
+    assert d1 & d2 == 0
+    assert d1 & A.x == A.x
+    assert d1 ^ A.x == 0
+    assert d1 ^ A.y == A.x | A.z
+    assert d1 ^ A.z == - A.x | A.y
+    assert d2 ^ A.x == - A.y | A.z
+    assert A.x ^ d1 == 0
+    assert A.y ^ d1 == - A.z | A.x
+    assert A.z ^ d1 == A.y | A.x
+    assert A.x & d1 == A.x
+    assert A.y & d1 == 0
+    assert A.y & d2 == A.y
+    assert d1 & d3 == A.x | A.y
+    assert d3 & d1 == 0
+    assert d1.dt(A) == 0
+    q = dynamicsymbols('q')
+    qd = dynamicsymbols('q', 1)
+    B = A.orientnew('B', 'Axis', [q, A.z])
+    assert d1.express(B) == d1.express(B, B)
+    assert d1.express(B) == ((cos(q)**2) * (B.x | B.x) + (-sin(q) * cos(q)) *
+            (B.x | B.y) + (-sin(q) * cos(q)) * (B.y | B.x) + (sin(q)**2) *
+            (B.y | B.y))
+    assert d1.express(B, A) == (cos(q)) * (B.x | A.x) + (-sin(q)) * (B.y | A.x)
+    assert d1.express(A, B) == (cos(q)) * (A.x | B.x) + (-sin(q)) * (A.x | B.y)
+    assert d1.dt(B) == (-qd) * (A.y | A.x) + (-qd) * (A.x | A.y)
+
+    assert d1.to_matrix(A) == Matrix([[1, 0, 0], [0, 0, 0], [0, 0, 0]])
+    assert d1.to_matrix(A, B) == Matrix([[cos(q), -sin(q), 0],
+                                         [0, 0, 0],
+                                         [0, 0, 0]])
+    assert d3.to_matrix(A) == Matrix([[0, 1, 0], [0, 0, 0], [0, 0, 0]])
+    a, b, c, d, e, f = symbols('a, b, c, d, e, f')
+    v1 = a * A.x + b * A.y + c * A.z
+    v2 = d * A.x + e * A.y + f * A.z
+    d4 = v1.outer(v2)
+    assert d4.to_matrix(A) == Matrix([[a * d, a * e, a * f],
+                                      [b * d, b * e, b * f],
+                                      [c * d, c * e, c * f]])
+    d5 = v1.outer(v1)
+    C = A.orientnew('C', 'Axis', [q, A.x])
+    for expected, actual in zip(C.dcm(A) * d5.to_matrix(A) * C.dcm(A).T,
+                                d5.to_matrix(C)):
+        assert (expected - actual).simplify() == 0
+
+    raises(TypeError, lambda: d1.applyfunc(0))
+
+
+def test_dyadic_simplify():
+    x, y, z, k, n, m, w, f, s, A = symbols('x, y, z, k, n, m, w, f, s, A')
+    N = ReferenceFrame('N')
+
+    dy = N.x | N.x
+    test1 = (1 / x + 1 / y) * dy
+    assert (N.x & test1 & N.x) != (x + y) / (x * y)
+    test1 = test1.simplify()
+    assert (N.x & test1 & N.x) == (x + y) / (x * y)
+
+    test2 = (A**2 * s**4 / (4 * pi * k * m**3)) * dy
+    test2 = test2.simplify()
+    assert (N.x & test2 & N.x) == (A**2 * s**4 / (4 * pi * k * m**3))
+
+    test3 = ((4 + 4 * x - 2 * (2 + 2 * x)) / (2 + 2 * x)) * dy
+    test3 = test3.simplify()
+    assert (N.x & test3 & N.x) == 0
+
+    test4 = ((-4 * x * y**2 - 2 * y**3 - 2 * x**2 * y) / (x + y)**2) * dy
+    test4 = test4.simplify()
+    assert (N.x & test4 & N.x) == -2 * y
+
+
+def test_dyadic_subs():
+    N = ReferenceFrame('N')
+    s = symbols('s')
+    a = s*(N.x | N.x)
+    assert a.subs({s: 2}) == 2*(N.x | N.x)
+
+
+def test_check_dyadic():
+    raises(TypeError, lambda: _check_dyadic(0))
+
+
+def test_dyadic_evalf():
+    N = ReferenceFrame('N')
+    a = pi * (N.x | N.x)
+    assert a.evalf(3) == Float('3.1416', 3) * (N.x | N.x)
+    s = symbols('s')
+    a = 5 * s * pi* (N.x | N.x)
+    assert a.evalf(2) == Float('5', 2) * Float('3.1416', 2) * s * (N.x | N.x)
+    assert a.evalf(9, subs={s: 5.124}) == Float('80.48760378', 9) * (N.x | N.x)
+
+
+def test_dyadic_xreplace():
+    x, y, z = symbols('x y z')
+    N = ReferenceFrame('N')
+    D = outer(N.x, N.x)
+    v = x*y * D
+    assert v.xreplace({x : cos(x)}) == cos(x)*y * D
+    assert v.xreplace({x*y : pi}) == pi * D
+    v = (x*y)**z * D
+    assert v.xreplace({(x*y)**z : 1}) == D
+    assert v.xreplace({x:1, z:0}) == D
+    raises(TypeError, lambda: v.xreplace())
+    raises(TypeError, lambda: v.xreplace([x, y]))

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/vector/tests/test_fieldfunctions.py

@@ -0,0 +1,133 @@
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.physics.vector import ReferenceFrame, Vector, Point, \
+     dynamicsymbols
+from sympy.physics.vector.fieldfunctions import divergence, \
+     gradient, curl, is_conservative, is_solenoidal, \
+     scalar_potential, scalar_potential_difference
+from sympy.testing.pytest import raises
+
+R = ReferenceFrame('R')
+q = dynamicsymbols('q')
+P = R.orientnew('P', 'Axis', [q, R.z])
+
+
+def test_curl():
+    assert curl(Vector(0), R) == Vector(0)
+    assert curl(R.x, R) == Vector(0)
+    assert curl(2*R[1]**2*R.y, R) == Vector(0)
+    assert curl(R[0]*R[1]*R.z, R) == R[0]*R.x - R[1]*R.y
+    assert curl(R[0]*R[1]*R[2] * (R.x+R.y+R.z), R) == \
+           (-R[0]*R[1] + R[0]*R[2])*R.x + (R[0]*R[1] - R[1]*R[2])*R.y + \
+           (-R[0]*R[2] + R[1]*R[2])*R.z
+    assert curl(2*R[0]**2*R.y, R) == 4*R[0]*R.z
+    assert curl(P[0]**2*R.x + P.y, R) == \
+           - 2*(R[0]*cos(q) + R[1]*sin(q))*sin(q)*R.z
+    assert curl(P[0]*R.y, P) == cos(q)*P.z
+
+
+def test_divergence():
+    assert divergence(Vector(0), R) is S.Zero
+    assert divergence(R.x, R) is S.Zero
+    assert divergence(R[0]**2*R.x, R) == 2*R[0]
+    assert divergence(R[0]*R[1]*R[2] * (R.x+R.y+R.z), R) == \
+           R[0]*R[1] + R[0]*R[2] + R[1]*R[2]
+    assert divergence((1/(R[0]*R[1]*R[2])) * (R.x+R.y+R.z), R) == \
+           -1/(R[0]*R[1]*R[2]**2) - 1/(R[0]*R[1]**2*R[2]) - \
+           1/(R[0]**2*R[1]*R[2])
+    v = P[0]*P.x + P[1]*P.y + P[2]*P.z
+    assert divergence(v, P) == 3
+    assert divergence(v, R).simplify() == 3
+    assert divergence(P[0]*R.x + R[0]*P.x, R) == 2*cos(q)
+
+
+def test_gradient():
+    a = Symbol('a')
+    assert gradient(0, R) == Vector(0)
+    assert gradient(R[0], R) == R.x
+    assert gradient(R[0]*R[1]*R[2], R) == \
+           R[1]*R[2]*R.x + R[0]*R[2]*R.y + R[0]*R[1]*R.z
+    assert gradient(2*R[0]**2, R) == 4*R[0]*R.x
+    assert gradient(a*sin(R[1])/R[0], R) == \
+           - a*sin(R[1])/R[0]**2*R.x + a*cos(R[1])/R[0]*R.y
+    assert gradient(P[0]*P[1], R) == \
+           ((-R[0]*sin(q) + R[1]*cos(q))*cos(q) - (R[0]*cos(q) + R[1]*sin(q))*sin(q))*R.x + \
+           ((-R[0]*sin(q) + R[1]*cos(q))*sin(q) + (R[0]*cos(q) + R[1]*sin(q))*cos(q))*R.y
+    assert gradient(P[0]*R[2], P) == P[2]*P.x + P[0]*P.z
+
+
+scalar_field = 2*R[0]**2*R[1]*R[2]
+grad_field = gradient(scalar_field, R)
+vector_field = R[1]**2*R.x + 3*R[0]*R.y + 5*R[1]*R[2]*R.z
+curl_field = curl(vector_field, R)
+
+
+def test_conservative():
+    assert is_conservative(0) is True
+    assert is_conservative(R.x) is True
+    assert is_conservative(2 * R.x + 3 * R.y + 4 * R.z) is True
+    assert is_conservative(R[1]*R[2]*R.x + R[0]*R[2]*R.y + R[0]*R[1]*R.z) is \
+           True
+    assert is_conservative(R[0] * R.y) is False
+    assert is_conservative(grad_field) is True
+    assert is_conservative(curl_field) is False
+    assert is_conservative(4*R[0]*R[1]*R[2]*R.x + 2*R[0]**2*R[2]*R.y) is \
+                           False
+    assert is_conservative(R[2]*P.x + P[0]*R.z) is True
+
+
+def test_solenoidal():
+    assert is_solenoidal(0) is True
+    assert is_solenoidal(R.x) is True
+    assert is_solenoidal(2 * R.x + 3 * R.y + 4 * R.z) is True
+    assert is_solenoidal(R[1]*R[2]*R.x + R[0]*R[2]*R.y + R[0]*R[1]*R.z) is \
+           True
+    assert is_solenoidal(R[1] * R.y) is False
+    assert is_solenoidal(grad_field) is False
+    assert is_solenoidal(curl_field) is True
+    assert is_solenoidal((-2*R[1] + 3)*R.z) is True
+    assert is_solenoidal(cos(q)*R.x + sin(q)*R.y + cos(q)*P.z) is True
+    assert is_solenoidal(R[2]*P.x + P[0]*R.z) is True
+
+
+def test_scalar_potential():
+    assert scalar_potential(0, R) == 0
+    assert scalar_potential(R.x, R) == R[0]
+    assert scalar_potential(R.y, R) == R[1]
+    assert scalar_potential(R.z, R) == R[2]
+    assert scalar_potential(R[1]*R[2]*R.x + R[0]*R[2]*R.y + \
+                            R[0]*R[1]*R.z, R) == R[0]*R[1]*R[2]
+    assert scalar_potential(grad_field, R) == scalar_field
+    assert scalar_potential(R[2]*P.x + P[0]*R.z, R) == \
+           R[0]*R[2]*cos(q) + R[1]*R[2]*sin(q)
+    assert scalar_potential(R[2]*P.x + P[0]*R.z, P) == P[0]*P[2]
+    raises(ValueError, lambda: scalar_potential(R[0] * R.y, R))
+
+
+def test_scalar_potential_difference():
+    origin = Point('O')
+    point1 = origin.locatenew('P1', 1*R.x + 2*R.y + 3*R.z)
+    point2 = origin.locatenew('P2', 4*R.x + 5*R.y + 6*R.z)
+    genericpointR = origin.locatenew('RP', R[0]*R.x + R[1]*R.y + R[2]*R.z)
+    genericpointP = origin.locatenew('PP', P[0]*P.x + P[1]*P.y + P[2]*P.z)
+    assert scalar_potential_difference(S.Zero, R, point1, point2, \
+                                       origin) == 0
+    assert scalar_potential_difference(scalar_field, R, origin, \
+                                       genericpointR, origin) == \
+                                       scalar_field
+    assert scalar_potential_difference(grad_field, R, origin, \
+                                       genericpointR, origin) == \
+                                       scalar_field
+    assert scalar_potential_difference(grad_field, R, point1, point2,
+                                       origin) == 948
+    assert scalar_potential_difference(R[1]*R[2]*R.x + R[0]*R[2]*R.y + \
+                                       R[0]*R[1]*R.z, R, point1,
+                                       genericpointR, origin) == \
+                                       R[0]*R[1]*R[2] - 6
+    potential_diff_P = 2*P[2]*(P[0]*sin(q) + P[1]*cos(q))*\
+                       (P[0]*cos(q) - P[1]*sin(q))**2
+    assert scalar_potential_difference(grad_field, P, origin, \
+                                       genericpointP, \
+                                       origin).simplify() == \
+                                       potential_diff_P

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/vector/tests/test_frame.py

@@ -0,0 +1,761 @@
+from sympy.core.numbers import pi
+from sympy.core.symbol import symbols
+from sympy.simplify import trigsimp
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.matrices.dense import (eye, zeros)
+from sympy.matrices.immutable import ImmutableDenseMatrix as Matrix
+from sympy.simplify.simplify import simplify
+from sympy.physics.vector import (ReferenceFrame, Vector, CoordinateSym,
+                                  dynamicsymbols, time_derivative, express,
+                                  dot)
+from sympy.physics.vector.frame import _check_frame
+from sympy.physics.vector.vector import VectorTypeError
+from sympy.testing.pytest import raises
+import warnings
+import pickle
+
+
+def test_dict_list():
+
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    C = ReferenceFrame('C')
+    D = ReferenceFrame('D')
+    E = ReferenceFrame('E')
+    F = ReferenceFrame('F')
+
+    B.orient_axis(A, A.x, 1.0)
+    C.orient_axis(B, B.x, 1.0)
+    D.orient_axis(C, C.x, 1.0)
+
+    assert D._dict_list(A, 0) == [D, C, B, A]
+
+    E.orient_axis(D, D.x, 1.0)
+
+    assert C._dict_list(A, 0) == [C, B, A]
+    assert C._dict_list(E, 0) == [C, D, E]
+
+    # only 0, 1, 2 permitted for second argument
+    raises(ValueError, lambda: C._dict_list(E, 5))
+    # no connecting path
+    raises(ValueError, lambda: F._dict_list(A, 0))
+
+
+def test_coordinate_vars():
+    """Tests the coordinate variables functionality"""
+    A = ReferenceFrame('A')
+    assert CoordinateSym('Ax', A, 0) == A[0]
+    assert CoordinateSym('Ax', A, 1) == A[1]
+    assert CoordinateSym('Ax', A, 2) == A[2]
+    raises(ValueError, lambda: CoordinateSym('Ax', A, 3))
+    q = dynamicsymbols('q')
+    qd = dynamicsymbols('q', 1)
+    assert isinstance(A[0], CoordinateSym) and \
+           isinstance(A[0], CoordinateSym) and \
+           isinstance(A[0], CoordinateSym)
+    assert A.variable_map(A) == {A[0]:A[0], A[1]:A[1], A[2]:A[2]}
+    assert A[0].frame == A
+    B = A.orientnew('B', 'Axis', [q, A.z])
+    assert B.variable_map(A) == {B[2]: A[2], B[1]: -A[0]*sin(q) + A[1]*cos(q),
+                                 B[0]: A[0]*cos(q) + A[1]*sin(q)}
+    assert A.variable_map(B) == {A[0]: B[0]*cos(q) - B[1]*sin(q),
+                                 A[1]: B[0]*sin(q) + B[1]*cos(q), A[2]: B[2]}
+    assert time_derivative(B[0], A) == -A[0]*sin(q)*qd + A[1]*cos(q)*qd
+    assert time_derivative(B[1], A) == -A[0]*cos(q)*qd - A[1]*sin(q)*qd
+    assert time_derivative(B[2], A) == 0
+    assert express(B[0], A, variables=True) == A[0]*cos(q) + A[1]*sin(q)
+    assert express(B[1], A, variables=True) == -A[0]*sin(q) + A[1]*cos(q)
+    assert express(B[2], A, variables=True) == A[2]
+    assert time_derivative(A[0]*A.x + A[1]*A.y + A[2]*A.z, B) == A[1]*qd*A.x - A[0]*qd*A.y
+    assert time_derivative(B[0]*B.x + B[1]*B.y + B[2]*B.z, A) == - B[1]*qd*B.x + B[0]*qd*B.y
+    assert express(B[0]*B[1]*B[2], A, variables=True) == \
+           A[2]*(-A[0]*sin(q) + A[1]*cos(q))*(A[0]*cos(q) + A[1]*sin(q))
+    assert (time_derivative(B[0]*B[1]*B[2], A) -
+            (A[2]*(-A[0]**2*cos(2*q) -
+             2*A[0]*A[1]*sin(2*q) +
+             A[1]**2*cos(2*q))*qd)).trigsimp() == 0
+    assert express(B[0]*B.x + B[1]*B.y + B[2]*B.z, A) == \
+           (B[0]*cos(q) - B[1]*sin(q))*A.x + (B[0]*sin(q) + \
+           B[1]*cos(q))*A.y + B[2]*A.z
+    assert express(B[0]*B.x + B[1]*B.y + B[2]*B.z, A,
+                   variables=True).simplify() == A[0]*A.x + A[1]*A.y + A[2]*A.z
+    assert express(A[0]*A.x + A[1]*A.y + A[2]*A.z, B) == \
+           (A[0]*cos(q) + A[1]*sin(q))*B.x + \
+           (-A[0]*sin(q) + A[1]*cos(q))*B.y + A[2]*B.z
+    assert express(A[0]*A.x + A[1]*A.y + A[2]*A.z, B,
+                   variables=True).simplify() == B[0]*B.x + B[1]*B.y + B[2]*B.z
+    N = B.orientnew('N', 'Axis', [-q, B.z])
+    assert ({k: v.simplify() for k, v in N.variable_map(A).items()} ==
+            {N[0]: A[0], N[2]: A[2], N[1]: A[1]})
+    C = A.orientnew('C', 'Axis', [q, A.x + A.y + A.z])
+    mapping = A.variable_map(C)
+    assert trigsimp(mapping[A[0]]) == (2*C[0]*cos(q)/3 + C[0]/3 -
+                                       2*C[1]*sin(q + pi/6)/3 +
+                                       C[1]/3 - 2*C[2]*cos(q + pi/3)/3 +
+                                       C[2]/3)
+    assert trigsimp(mapping[A[1]]) == -2*C[0]*cos(q + pi/3)/3 + \
+           C[0]/3 + 2*C[1]*cos(q)/3 + C[1]/3 - 2*C[2]*sin(q + pi/6)/3 + C[2]/3
+    assert trigsimp(mapping[A[2]]) == -2*C[0]*sin(q + pi/6)/3 + C[0]/3 - \
+           2*C[1]*cos(q + pi/3)/3 + C[1]/3 + 2*C[2]*cos(q)/3 + C[2]/3
+
+
+def test_ang_vel():
+    q1, q2, q3, q4 = dynamicsymbols('q1 q2 q3 q4')
+    q1d, q2d, q3d, q4d = dynamicsymbols('q1 q2 q3 q4', 1)
+    N = ReferenceFrame('N')
+    A = N.orientnew('A', 'Axis', [q1, N.z])
+    B = A.orientnew('B', 'Axis', [q2, A.x])
+    C = B.orientnew('C', 'Axis', [q3, B.y])
+    D = N.orientnew('D', 'Axis', [q4, N.y])
+    u1, u2, u3 = dynamicsymbols('u1 u2 u3')
+    assert A.ang_vel_in(N) == (q1d)*A.z
+    assert B.ang_vel_in(N) == (q2d)*B.x + (q1d)*A.z
+    assert C.ang_vel_in(N) == (q3d)*C.y + (q2d)*B.x + (q1d)*A.z
+
+    A2 = N.orientnew('A2', 'Axis', [q4, N.y])
+    assert N.ang_vel_in(N) == 0
+    assert N.ang_vel_in(A) == -q1d*N.z
+    assert N.ang_vel_in(B) == -q1d*A.z - q2d*B.x
+    assert N.ang_vel_in(C) == -q1d*A.z - q2d*B.x - q3d*B.y
+    assert N.ang_vel_in(A2) == -q4d*N.y
+
+    assert A.ang_vel_in(N) == q1d*N.z
+    assert A.ang_vel_in(A) == 0
+    assert A.ang_vel_in(B) == - q2d*B.x
+    assert A.ang_vel_in(C) == - q2d*B.x - q3d*B.y
+    assert A.ang_vel_in(A2) == q1d*N.z - q4d*N.y
+
+    assert B.ang_vel_in(N) == q1d*A.z + q2d*A.x
+    assert B.ang_vel_in(A) == q2d*A.x
+    assert B.ang_vel_in(B) == 0
+    assert B.ang_vel_in(C) == -q3d*B.y
+    assert B.ang_vel_in(A2) == q1d*A.z + q2d*A.x - q4d*N.y
+
+    assert C.ang_vel_in(N) == q1d*A.z + q2d*A.x + q3d*B.y
+    assert C.ang_vel_in(A) == q2d*A.x + q3d*C.y
+    assert C.ang_vel_in(B) == q3d*B.y
+    assert C.ang_vel_in(C) == 0
+    assert C.ang_vel_in(A2) == q1d*A.z + q2d*A.x + q3d*B.y - q4d*N.y
+
+    assert A2.ang_vel_in(N) == q4d*A2.y
+    assert A2.ang_vel_in(A) == q4d*A2.y - q1d*N.z
+    assert A2.ang_vel_in(B) == q4d*N.y - q1d*A.z - q2d*A.x
+    assert A2.ang_vel_in(C) == q4d*N.y - q1d*A.z - q2d*A.x - q3d*B.y
+    assert A2.ang_vel_in(A2) == 0
+
+    C.set_ang_vel(N, u1*C.x + u2*C.y + u3*C.z)
+    assert C.ang_vel_in(N) == (u1)*C.x + (u2)*C.y + (u3)*C.z
+    assert N.ang_vel_in(C) == (-u1)*C.x + (-u2)*C.y + (-u3)*C.z
+    assert C.ang_vel_in(D) == (u1)*C.x + (u2)*C.y + (u3)*C.z + (-q4d)*D.y
+    assert D.ang_vel_in(C) == (-u1)*C.x + (-u2)*C.y + (-u3)*C.z + (q4d)*D.y
+
+    q0 = dynamicsymbols('q0')
+    q0d = dynamicsymbols('q0', 1)
+    E = N.orientnew('E', 'Quaternion', (q0, q1, q2, q3))
+    assert E.ang_vel_in(N) == (
+        2 * (q1d * q0 + q2d * q3 - q3d * q2 - q0d * q1) * E.x +
+        2 * (q2d * q0 + q3d * q1 - q1d * q3 - q0d * q2) * E.y +
+        2 * (q3d * q0 + q1d * q2 - q2d * q1 - q0d * q3) * E.z)
+
+    F = N.orientnew('F', 'Body', (q1, q2, q3), 313)
+    assert F.ang_vel_in(N) == ((sin(q2)*sin(q3)*q1d + cos(q3)*q2d)*F.x +
+        (sin(q2)*cos(q3)*q1d - sin(q3)*q2d)*F.y + (cos(q2)*q1d + q3d)*F.z)
+    G = N.orientnew('G', 'Axis', (q1, N.x + N.y))
+    assert G.ang_vel_in(N) == q1d * (N.x + N.y).normalize()
+    assert N.ang_vel_in(G) == -q1d * (N.x + N.y).normalize()
+
+
+def test_dcm():
+    q1, q2, q3, q4 = dynamicsymbols('q1 q2 q3 q4')
+    N = ReferenceFrame('N')
+    A = N.orientnew('A', 'Axis', [q1, N.z])
+    B = A.orientnew('B', 'Axis', [q2, A.x])
+    C = B.orientnew('C', 'Axis', [q3, B.y])
+    D = N.orientnew('D', 'Axis', [q4, N.y])
+    E = N.orientnew('E', 'Space', [q1, q2, q3], '123')
+    assert N.dcm(C) == Matrix([
+        [- sin(q1) * sin(q2) * sin(q3) + cos(q1) * cos(q3), - sin(q1) *
+        cos(q2), sin(q1) * sin(q2) * cos(q3) + sin(q3) * cos(q1)], [sin(q1) *
+        cos(q3) + sin(q2) * sin(q3) * cos(q1), cos(q1) * cos(q2), sin(q1) *
+            sin(q3) - sin(q2) * cos(q1) * cos(q3)], [- sin(q3) * cos(q2), sin(q2),
+        cos(q2) * cos(q3)]])
+    # This is a little touchy.  Is it ok to use simplify in assert?
+    test_mat = D.dcm(C) - Matrix(
+        [[cos(q1) * cos(q3) * cos(q4) - sin(q3) * (- sin(q4) * cos(q2) +
+        sin(q1) * sin(q2) * cos(q4)), - sin(q2) * sin(q4) - sin(q1) *
+            cos(q2) * cos(q4), sin(q3) * cos(q1) * cos(q4) + cos(q3) * (- sin(q4) *
+        cos(q2) + sin(q1) * sin(q2) * cos(q4))], [sin(q1) * cos(q3) +
+        sin(q2) * sin(q3) * cos(q1), cos(q1) * cos(q2), sin(q1) * sin(q3) -
+            sin(q2) * cos(q1) * cos(q3)], [sin(q4) * cos(q1) * cos(q3) -
+        sin(q3) * (cos(q2) * cos(q4) + sin(q1) * sin(q2) * sin(q4)), sin(q2) *
+                cos(q4) - sin(q1) * sin(q4) * cos(q2), sin(q3) * sin(q4) * cos(q1) +
+                cos(q3) * (cos(q2) * cos(q4) + sin(q1) * sin(q2) * sin(q4))]])
+    assert test_mat.expand() == zeros(3, 3)
+    assert E.dcm(N) == Matrix(
+        [[cos(q2)*cos(q3), sin(q3)*cos(q2), -sin(q2)],
+        [sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1), sin(q1)*sin(q2)*sin(q3) +
+        cos(q1)*cos(q3), sin(q1)*cos(q2)], [sin(q1)*sin(q3) +
+        sin(q2)*cos(q1)*cos(q3), - sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1),
+         cos(q1)*cos(q2)]])
+
+def test_w_diff_dcm1():
+    # Ref:
+    # Dynamics Theory and Applications, Kane 1985
+    # Sec. 2.1 ANGULAR VELOCITY
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+
+    c11, c12, c13 = dynamicsymbols('C11 C12 C13')
+    c21, c22, c23 = dynamicsymbols('C21 C22 C23')
+    c31, c32, c33 = dynamicsymbols('C31 C32 C33')
+
+    c11d, c12d, c13d = dynamicsymbols('C11 C12 C13', level=1)
+    c21d, c22d, c23d = dynamicsymbols('C21 C22 C23', level=1)
+    c31d, c32d, c33d = dynamicsymbols('C31 C32 C33', level=1)
+
+    DCM = Matrix([
+        [c11, c12, c13],
+        [c21, c22, c23],
+        [c31, c32, c33]
+    ])
+
+    B.orient(A, 'DCM', DCM)
+    b1a = (B.x).express(A)
+    b2a = (B.y).express(A)
+    b3a = (B.z).express(A)
+
+    # Equation (2.1.1)
+    B.set_ang_vel(A, B.x*(dot((b3a).dt(A), B.y))
+                   + B.y*(dot((b1a).dt(A), B.z))
+                   + B.z*(dot((b2a).dt(A), B.x)))
+
+    # Equation (2.1.21)
+    expr = (  (c12*c13d + c22*c23d + c32*c33d)*B.x
+            + (c13*c11d + c23*c21d + c33*c31d)*B.y
+            + (c11*c12d + c21*c22d + c31*c32d)*B.z)
+    assert B.ang_vel_in(A) - expr == 0
+
+def test_w_diff_dcm2():
+    q1, q2, q3 = dynamicsymbols('q1:4')
+    N = ReferenceFrame('N')
+    A = N.orientnew('A', 'axis', [q1, N.x])
+    B = A.orientnew('B', 'axis', [q2, A.y])
+    C = B.orientnew('C', 'axis', [q3, B.z])
+
+    DCM = C.dcm(N).T
+    D = N.orientnew('D', 'DCM', DCM)
+
+    # Frames D and C are the same ReferenceFrame,
+    # since they have equal DCM respect to frame N.
+    # Therefore, D and C should have same angle velocity in N.
+    assert D.dcm(N) == C.dcm(N) == Matrix([
+        [cos(q2)*cos(q3), sin(q1)*sin(q2)*cos(q3) +
+        sin(q3)*cos(q1), sin(q1)*sin(q3) -
+        sin(q2)*cos(q1)*cos(q3)], [-sin(q3)*cos(q2),
+        -sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3),
+        sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)],
+        [sin(q2), -sin(q1)*cos(q2), cos(q1)*cos(q2)]])
+    assert (D.ang_vel_in(N) - C.ang_vel_in(N)).express(N).simplify() == 0
+
+def test_orientnew_respects_parent_class():
+    class MyReferenceFrame(ReferenceFrame):
+        pass
+    B = MyReferenceFrame('B')
+    C = B.orientnew('C', 'Axis', [0, B.x])
+    assert isinstance(C, MyReferenceFrame)
+
+
+def test_orientnew_respects_input_indices():
+    N = ReferenceFrame('N')
+    q1 = dynamicsymbols('q1')
+    A = N.orientnew('a', 'Axis', [q1, N.z])
+    #modify default indices:
+    minds = [x+'1' for x in N.indices]
+    B = N.orientnew('b', 'Axis', [q1, N.z], indices=minds)
+
+    assert N.indices == A.indices
+    assert B.indices == minds
+
+def test_orientnew_respects_input_latexs():
+    N = ReferenceFrame('N')
+    q1 = dynamicsymbols('q1')
+    A = N.orientnew('a', 'Axis', [q1, N.z])
+
+    #build default and alternate latex_vecs:
+    def_latex_vecs = [(r"\mathbf{\hat{%s}_%s}" % (A.name.lower(),
+                      A.indices[0])), (r"\mathbf{\hat{%s}_%s}" %
+                      (A.name.lower(), A.indices[1])),
+                      (r"\mathbf{\hat{%s}_%s}" % (A.name.lower(),
+                      A.indices[2]))]
+
+    name = 'b'
+    indices = [x+'1' for x in N.indices]
+    new_latex_vecs = [(r"\mathbf{\hat{%s}_{%s}}" % (name.lower(),
+                      indices[0])), (r"\mathbf{\hat{%s}_{%s}}" %
+                      (name.lower(), indices[1])),
+                      (r"\mathbf{\hat{%s}_{%s}}" % (name.lower(),
+                      indices[2]))]
+
+    B = N.orientnew(name, 'Axis', [q1, N.z], latexs=new_latex_vecs)
+
+    assert A.latex_vecs == def_latex_vecs
+    assert B.latex_vecs == new_latex_vecs
+    assert B.indices != indices
+
+def test_orientnew_respects_input_variables():
+    N = ReferenceFrame('N')
+    q1 = dynamicsymbols('q1')
+    A = N.orientnew('a', 'Axis', [q1, N.z])
+
+    #build non-standard variable names
+    name = 'b'
+    new_variables = ['notb_'+x+'1' for x in N.indices]
+    B = N.orientnew(name, 'Axis', [q1, N.z], variables=new_variables)
+
+    for j,var in enumerate(A.varlist):
+        assert var.name == A.name + '_' + A.indices[j]
+
+    for j,var in enumerate(B.varlist):
+        assert var.name == new_variables[j]
+
+def test_issue_10348():
+    u = dynamicsymbols('u:3')
+    I = ReferenceFrame('I')
+    I.orientnew('A', 'space', u, 'XYZ')
+
+
+def test_issue_11503():
+    A = ReferenceFrame("A")
+    A.orientnew("B", "Axis", [35, A.y])
+    C = ReferenceFrame("C")
+    A.orient(C, "Axis", [70, C.z])
+
+
+def test_partial_velocity():
+
+    N = ReferenceFrame('N')
+    A = ReferenceFrame('A')
+
+    u1, u2 = dynamicsymbols('u1, u2')
+
+    A.set_ang_vel(N, u1 * A.x + u2 * N.y)
+
+    assert N.partial_velocity(A, u1) == -A.x
+    assert N.partial_velocity(A, u1, u2) == (-A.x, -N.y)
+
+    assert A.partial_velocity(N, u1) == A.x
+    assert A.partial_velocity(N, u1, u2) == (A.x, N.y)
+
+    assert N.partial_velocity(N, u1) == 0
+    assert A.partial_velocity(A, u1) == 0
+
+
+def test_issue_11498():
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+
+    # Identity transformation
+    A.orient(B, 'DCM', eye(3))
+    assert A.dcm(B) == Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+    assert B.dcm(A) == Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+
+    # x -> y
+    # y -> -z
+    # z -> -x
+    A.orient(B, 'DCM', Matrix([[0, 1, 0], [0, 0, -1], [-1, 0, 0]]))
+    assert B.dcm(A) == Matrix([[0, 1, 0], [0, 0, -1], [-1, 0, 0]])
+    assert A.dcm(B) == Matrix([[0, 0, -1], [1, 0, 0], [0, -1, 0]])
+    assert B.dcm(A).T == A.dcm(B)
+
+
+def test_reference_frame():
+    raises(TypeError, lambda: ReferenceFrame(0))
+    raises(TypeError, lambda: ReferenceFrame('N', 0))
+    raises(ValueError, lambda: ReferenceFrame('N', [0, 1]))
+    raises(TypeError, lambda: ReferenceFrame('N', [0, 1, 2]))
+    raises(TypeError, lambda: ReferenceFrame('N', ['a', 'b', 'c'], 0))
+    raises(ValueError, lambda: ReferenceFrame('N', ['a', 'b', 'c'], [0, 1]))
+    raises(TypeError, lambda: ReferenceFrame('N', ['a', 'b', 'c'], [0, 1, 2]))
+    raises(TypeError, lambda: ReferenceFrame('N', ['a', 'b', 'c'],
+                                                 ['a', 'b', 'c'], 0))
+    raises(ValueError, lambda: ReferenceFrame('N', ['a', 'b', 'c'],
+                                              ['a', 'b', 'c'], [0, 1]))
+    raises(TypeError, lambda: ReferenceFrame('N', ['a', 'b', 'c'],
+                                             ['a', 'b', 'c'], [0, 1, 2]))
+    N = ReferenceFrame('N')
+    assert N[0] == CoordinateSym('N_x', N, 0)
+    assert N[1] == CoordinateSym('N_y', N, 1)
+    assert N[2] == CoordinateSym('N_z', N, 2)
+    raises(ValueError, lambda: N[3])
+    N = ReferenceFrame('N', ['a', 'b', 'c'])
+    assert N['a'] == N.x
+    assert N['b'] == N.y
+    assert N['c'] == N.z
+    raises(ValueError, lambda: N['d'])
+    assert str(N) == 'N'
+
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    q0, q1, q2, q3 = symbols('q0 q1 q2 q3')
+    raises(TypeError, lambda: A.orient(B, 'DCM', 0))
+    raises(TypeError, lambda: B.orient(N, 'Space', [q1, q2, q3], '222'))
+    raises(TypeError, lambda: B.orient(N, 'Axis', [q1, N.x + 2 * N.y], '222'))
+    raises(TypeError, lambda: B.orient(N, 'Axis', q1))
+    raises(IndexError, lambda: B.orient(N, 'Axis', [q1]))
+    raises(TypeError, lambda: B.orient(N, 'Quaternion', [q0, q1, q2, q3], '222'))
+    raises(TypeError, lambda: B.orient(N, 'Quaternion', q0))
+    raises(TypeError, lambda: B.orient(N, 'Quaternion', [q0, q1, q2]))
+    raises(NotImplementedError, lambda: B.orient(N, 'Foo', [q0, q1, q2]))
+    raises(TypeError, lambda: B.orient(N, 'Body', [q1, q2], '232'))
+    raises(TypeError, lambda: B.orient(N, 'Space', [q1, q2], '232'))
+
+    N.set_ang_acc(B, 0)
+    assert N.ang_acc_in(B) == Vector(0)
+    N.set_ang_vel(B, 0)
+    assert N.ang_vel_in(B) == Vector(0)
+
+
+def test_check_frame():
+    raises(VectorTypeError, lambda: _check_frame(0))
+
+
+def test_dcm_diff_16824():
+    # NOTE : This is a regression test for the bug introduced in PR 14758,
+    # identified in 16824, and solved by PR 16828.
+
+    # This is the solution to Problem 2.2 on page 264 in Kane & Lenvinson's
+    # 1985 book.
+
+    q1, q2, q3 = dynamicsymbols('q1:4')
+
+    s1 = sin(q1)
+    c1 = cos(q1)
+    s2 = sin(q2)
+    c2 = cos(q2)
+    s3 = sin(q3)
+    c3 = cos(q3)
+
+    dcm = Matrix([[c2*c3, s1*s2*c3 - s3*c1, c1*s2*c3 + s3*s1],
+                  [c2*s3, s1*s2*s3 + c3*c1, c1*s2*s3 - c3*s1],
+                  [-s2,   s1*c2,            c1*c2]])
+
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    B.orient(A, 'DCM', dcm)
+
+    AwB = B.ang_vel_in(A)
+
+    alpha2 = s3*c2*q1.diff() + c3*q2.diff()
+    beta2 = s1*c2*q3.diff() + c1*q2.diff()
+
+    assert simplify(AwB.dot(A.y) - alpha2) == 0
+    assert simplify(AwB.dot(B.y) - beta2) == 0
+
+def test_orient_explicit():
+    cxx, cyy, czz = dynamicsymbols('c_{xx}, c_{yy}, c_{zz}')
+    cxy, cxz, cyx = dynamicsymbols('c_{xy}, c_{xz}, c_{yx}')
+    cyz, czx, czy = dynamicsymbols('c_{yz}, c_{zx}, c_{zy}')
+    dcxx, dcyy, dczz = dynamicsymbols('c_{xx}, c_{yy}, c_{zz}', 1)
+    dcxy, dcxz, dcyx = dynamicsymbols('c_{xy}, c_{xz}, c_{yx}', 1)
+    dcyz, dczx, dczy = dynamicsymbols('c_{yz}, c_{zx}, c_{zy}', 1)
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    B_C_A = Matrix([[cxx, cxy, cxz],
+                    [cyx, cyy, cyz],
+                    [czx, czy, czz]])
+    B_w_A = ((cyx*dczx + cyy*dczy + cyz*dczz)*B.x +
+            (czx*dcxx + czy*dcxy + czz*dcxz)*B.y +
+            (cxx*dcyx + cxy*dcyy + cxz*dcyz)*B.z)
+    A.orient_explicit(B, B_C_A)
+    assert B.dcm(A) == B_C_A
+    assert A.ang_vel_in(B) == B_w_A
+    assert B.ang_vel_in(A) == -B_w_A
+
+def test_orient_dcm():
+    cxx, cyy, czz = dynamicsymbols('c_{xx}, c_{yy}, c_{zz}')
+    cxy, cxz, cyx = dynamicsymbols('c_{xy}, c_{xz}, c_{yx}')
+    cyz, czx, czy = dynamicsymbols('c_{yz}, c_{zx}, c_{zy}')
+    B_C_A = Matrix([[cxx, cxy, cxz],
+                    [cyx, cyy, cyz],
+                    [czx, czy, czz]])
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    B.orient_dcm(A, B_C_A)
+    assert B.dcm(A) == Matrix([[cxx, cxy, cxz],
+                               [cyx, cyy, cyz],
+                               [czx, czy, czz]])
+
+def test_orient_axis():
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    A.orient_axis(B,-B.x, 1)
+    A1 = A.dcm(B)
+    A.orient_axis(B, B.x, -1)
+    A2 = A.dcm(B)
+    A.orient_axis(B, 1, -B.x)
+    A3 = A.dcm(B)
+    assert A1 == A2
+    assert A2 == A3
+    raises(TypeError, lambda: A.orient_axis(B, 1, 1))
+
+def test_orient_body():
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    B.orient_body_fixed(A, (1,1,0), 'XYX')
+    assert B.dcm(A) == Matrix([[cos(1), sin(1)**2, -sin(1)*cos(1)], [0, cos(1), sin(1)], [sin(1), -sin(1)*cos(1), cos(1)**2]])
+
+
+def test_orient_body_advanced():
+    q1, q2, q3 = dynamicsymbols('q1:4')
+    c1, c2, c3 = symbols('c1:4')
+    u1, u2, u3 = dynamicsymbols('q1:4', 1)
+
+    # Test with everything as dynamicsymbols
+    A, B = ReferenceFrame('A'), ReferenceFrame('B')
+    B.orient_body_fixed(A, (q1, q2, q3), 'zxy')
+    assert A.dcm(B) == Matrix([
+        [-sin(q1) * sin(q2) * sin(q3) + cos(q1) * cos(q3), -sin(q1) * cos(q2),
+         sin(q1) * sin(q2) * cos(q3) + sin(q3) * cos(q1)],
+        [sin(q1) * cos(q3) + sin(q2) * sin(q3) * cos(q1), cos(q1) * cos(q2),
+         sin(q1) * sin(q3) - sin(q2) * cos(q1) * cos(q3)],
+        [-sin(q3) * cos(q2), sin(q2), cos(q2) * cos(q3)]])
+    assert B.ang_vel_in(A).to_matrix(B) == Matrix([
+        [-sin(q3) * cos(q2) * u1 + cos(q3) * u2],
+        [sin(q2) * u1 + u3],
+        [sin(q3) * u2 + cos(q2) * cos(q3) * u1]])
+
+    # Test with constant symbol
+    A, B = ReferenceFrame('A'), ReferenceFrame('B')
+    B.orient_body_fixed(A, (q1, c2, q3), 131)
+    assert A.dcm(B) == Matrix([
+        [cos(c2), -sin(c2) * cos(q3), sin(c2) * sin(q3)],
+        [sin(c2) * cos(q1), -sin(q1) * sin(q3) + cos(c2) * cos(q1) * cos(q3),
+         -sin(q1) * cos(q3) - sin(q3) * cos(c2) * cos(q1)],
+        [sin(c2) * sin(q1), sin(q1) * cos(c2) * cos(q3) + sin(q3) * cos(q1),
+         -sin(q1) * sin(q3) * cos(c2) + cos(q1) * cos(q3)]])
+    assert B.ang_vel_in(A).to_matrix(B) == Matrix([
+        [cos(c2) * u1 + u3],
+        [-sin(c2) * cos(q3) * u1],
+        [sin(c2) * sin(q3) * u1]])
+
+    # Test all symbols not time dependent
+    A, B = ReferenceFrame('A'), ReferenceFrame('B')
+    B.orient_body_fixed(A, (c1, c2, c3), 123)
+    assert B.ang_vel_in(A) == Vector(0)
+
+
+def test_orient_space_advanced():
+    # space fixed is in the end like body fixed only in opposite order
+    q1, q2, q3 = dynamicsymbols('q1:4')
+    c1, c2, c3 = symbols('c1:4')
+    u1, u2, u3 = dynamicsymbols('q1:4', 1)
+
+    # Test with everything as dynamicsymbols
+    A, B = ReferenceFrame('A'), ReferenceFrame('B')
+    B.orient_space_fixed(A, (q3, q2, q1), 'yxz')
+    assert A.dcm(B) == Matrix([
+        [-sin(q1) * sin(q2) * sin(q3) + cos(q1) * cos(q3), -sin(q1) * cos(q2),
+         sin(q1) * sin(q2) * cos(q3) + sin(q3) * cos(q1)],
+        [sin(q1) * cos(q3) + sin(q2) * sin(q3) * cos(q1), cos(q1) * cos(q2),
+         sin(q1) * sin(q3) - sin(q2) * cos(q1) * cos(q3)],
+        [-sin(q3) * cos(q2), sin(q2), cos(q2) * cos(q3)]])
+    assert B.ang_vel_in(A).to_matrix(B) == Matrix([
+        [-sin(q3) * cos(q2) * u1 + cos(q3) * u2],
+        [sin(q2) * u1 + u3],
+        [sin(q3) * u2 + cos(q2) * cos(q3) * u1]])
+
+    # Test with constant symbol
+    A, B = ReferenceFrame('A'), ReferenceFrame('B')
+    B.orient_space_fixed(A, (q3, c2, q1), 131)
+    assert A.dcm(B) == Matrix([
+        [cos(c2), -sin(c2) * cos(q3), sin(c2) * sin(q3)],
+        [sin(c2) * cos(q1), -sin(q1) * sin(q3) + cos(c2) * cos(q1) * cos(q3),
+         -sin(q1) * cos(q3) - sin(q3) * cos(c2) * cos(q1)],
+        [sin(c2) * sin(q1), sin(q1) * cos(c2) * cos(q3) + sin(q3) * cos(q1),
+         -sin(q1) * sin(q3) * cos(c2) + cos(q1) * cos(q3)]])
+    assert B.ang_vel_in(A).to_matrix(B) == Matrix([
+        [cos(c2) * u1 + u3],
+        [-sin(c2) * cos(q3) * u1],
+        [sin(c2) * sin(q3) * u1]])
+
+    # Test all symbols not time dependent
+    A, B = ReferenceFrame('A'), ReferenceFrame('B')
+    B.orient_space_fixed(A, (c1, c2, c3), 123)
+    assert B.ang_vel_in(A) == Vector(0)
+
+
+def test_orient_body_simple_ang_vel():
+    """This test ensures that the simplest form of that linear system solution
+    is returned, thus the == for the expression comparison."""
+
+    psi, theta, phi = dynamicsymbols('psi, theta, varphi')
+    t = dynamicsymbols._t
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    B.orient_body_fixed(A, (psi, theta, phi), 'ZXZ')
+    A_w_B = B.ang_vel_in(A)
+    assert A_w_B.args[0][1] == B
+    assert A_w_B.args[0][0][0] == (sin(theta)*sin(phi)*psi.diff(t) +
+                                   cos(phi)*theta.diff(t))
+    assert A_w_B.args[0][0][1] == (sin(theta)*cos(phi)*psi.diff(t) -
+                                   sin(phi)*theta.diff(t))
+    assert A_w_B.args[0][0][2] == cos(theta)*psi.diff(t) + phi.diff(t)
+
+
+def test_orient_space():
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    B.orient_space_fixed(A, (0,0,0), '123')
+    assert B.dcm(A) == Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+
+def test_orient_quaternion():
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    B.orient_quaternion(A, (0,0,0,0))
+    assert B.dcm(A) == Matrix([[0, 0, 0], [0, 0, 0], [0, 0, 0]])
+
+def test_looped_frame_warning():
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    C = ReferenceFrame('C')
+
+    a, b, c = symbols('a b c')
+    B.orient_axis(A, A.x, a)
+    C.orient_axis(B, B.x, b)
+
+    with warnings.catch_warnings(record = True) as w:
+        warnings.simplefilter("always")
+        A.orient_axis(C, C.x, c)
+        assert issubclass(w[-1].category, UserWarning)
+        assert 'Loops are defined among the orientation of frames. ' + \
+            'This is likely not desired and may cause errors in your calculations.' in str(w[-1].message)
+
+def test_frame_dict():
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    C = ReferenceFrame('C')
+
+    a, b, c = symbols('a b c')
+
+    B.orient_axis(A, A.x, a)
+    assert A._dcm_dict == {B: Matrix([[1, 0, 0],[0, cos(a), -sin(a)],[0, sin(a),  cos(a)]])}
+    assert B._dcm_dict == {A: Matrix([[1, 0, 0],[0,  cos(a), sin(a)],[0, -sin(a), cos(a)]])}
+    assert C._dcm_dict == {}
+
+    B.orient_axis(C, C.x, b)
+    # Previous relation is not wiped
+    assert A._dcm_dict == {B: Matrix([[1, 0, 0],[0, cos(a), -sin(a)],[0, sin(a),  cos(a)]])}
+    assert B._dcm_dict == {A: Matrix([[1, 0, 0],[0,  cos(a), sin(a)],[0, -sin(a), cos(a)]]), \
+        C: Matrix([[1, 0, 0],[0,  cos(b), sin(b)],[0, -sin(b), cos(b)]])}
+    assert C._dcm_dict == {B: Matrix([[1, 0, 0],[0, cos(b), -sin(b)],[0, sin(b),  cos(b)]])}
+
+    A.orient_axis(B, B.x, c)
+    # Previous relation is updated
+    assert B._dcm_dict == {C: Matrix([[1, 0, 0],[0,  cos(b), sin(b)],[0, -sin(b), cos(b)]]),\
+        A: Matrix([[1, 0, 0],[0, cos(c), -sin(c)],[0, sin(c),  cos(c)]])}
+    assert A._dcm_dict == {B: Matrix([[1, 0, 0],[0,  cos(c), sin(c)],[0, -sin(c), cos(c)]])}
+    assert C._dcm_dict == {B: Matrix([[1, 0, 0],[0, cos(b), -sin(b)],[0, sin(b),  cos(b)]])}
+
+def test_dcm_cache_dict():
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    C = ReferenceFrame('C')
+    D = ReferenceFrame('D')
+
+    a, b, c = symbols('a b c')
+
+    B.orient_axis(A, A.x, a)
+    C.orient_axis(B, B.x, b)
+    D.orient_axis(C, C.x, c)
+
+    assert D._dcm_dict == {C: Matrix([[1, 0, 0],[0,  cos(c), sin(c)],[0, -sin(c), cos(c)]])}
+    assert C._dcm_dict == {B: Matrix([[1, 0, 0],[0,  cos(b), sin(b)],[0, -sin(b), cos(b)]]), \
+        D: Matrix([[1, 0, 0],[0, cos(c), -sin(c)],[0, sin(c),  cos(c)]])}
+    assert B._dcm_dict == {A: Matrix([[1, 0, 0],[0,  cos(a), sin(a)],[0, -sin(a), cos(a)]]), \
+        C: Matrix([[1, 0, 0],[0, cos(b), -sin(b)],[0, sin(b),  cos(b)]])}
+    assert A._dcm_dict == {B: Matrix([[1, 0, 0],[0, cos(a), -sin(a)],[0, sin(a),  cos(a)]])}
+
+    assert D._dcm_dict == D._dcm_cache
+
+    D.dcm(A) # Check calculated dcm relation is stored in _dcm_cache and not in _dcm_dict
+    assert list(A._dcm_cache.keys()) == [A, B, D]
+    assert list(D._dcm_cache.keys()) == [C, A]
+    assert list(A._dcm_dict.keys()) == [B]
+    assert list(D._dcm_dict.keys()) == [C]
+    assert A._dcm_dict != A._dcm_cache
+
+    A.orient_axis(B, B.x, b) # _dcm_cache of A is wiped out and new relation is stored.
+    assert A._dcm_dict == {B: Matrix([[1, 0, 0],[0,  cos(b), sin(b)],[0, -sin(b), cos(b)]])}
+    assert A._dcm_dict == A._dcm_cache
+    assert B._dcm_dict == {C: Matrix([[1, 0, 0],[0, cos(b), -sin(b)],[0, sin(b),  cos(b)]]), \
+        A: Matrix([[1, 0, 0],[0, cos(b), -sin(b)],[0, sin(b),  cos(b)]])}
+
+def test_xx_dyad():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.xx == Vector.outer(N.x, N.x)
+    assert F.xx == Vector.outer(F.x, F.x)
+
+def test_xy_dyad():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.xy == Vector.outer(N.x, N.y)
+    assert F.xy == Vector.outer(F.x, F.y)
+
+def test_xz_dyad():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.xz == Vector.outer(N.x, N.z)
+    assert F.xz == Vector.outer(F.x, F.z)
+
+def test_yx_dyad():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.yx == Vector.outer(N.y, N.x)
+    assert F.yx == Vector.outer(F.y, F.x)
+
+def test_yy_dyad():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.yy == Vector.outer(N.y, N.y)
+    assert F.yy == Vector.outer(F.y, F.y)
+
+def test_yz_dyad():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.yz == Vector.outer(N.y, N.z)
+    assert F.yz == Vector.outer(F.y, F.z)
+
+def test_zx_dyad():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.zx == Vector.outer(N.z, N.x)
+    assert F.zx == Vector.outer(F.z, F.x)
+
+def test_zy_dyad():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.zy == Vector.outer(N.z, N.y)
+    assert F.zy == Vector.outer(F.z, F.y)
+
+def test_zz_dyad():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.zz == Vector.outer(N.z, N.z)
+    assert F.zz == Vector.outer(F.z, F.z)
+
+def test_unit_dyadic():
+    N = ReferenceFrame('N')
+    F = ReferenceFrame('F', indices=['1', '2', '3'])
+    assert N.u == N.xx + N.yy + N.zz
+    assert F.u == F.xx + F.yy + F.zz
+
+
+def test_pickle_frame():
+    N = ReferenceFrame('N')
+    A = ReferenceFrame('A')
+    A.orient_axis(N, N.x, 1)
+    A_C_N = A.dcm(N)
+    N1 = pickle.loads(pickle.dumps(N))
+    A1 = tuple(N1._dcm_dict.keys())[0]
+    assert A1.dcm(N1) == A_C_N

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/vector/tests/test_functions.py

@@ -0,0 +1,509 @@
+from sympy.core.numbers import pi
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.integrals.integrals import Integral
+from sympy.physics.vector import Dyadic, Point, ReferenceFrame, Vector
+from sympy.physics.vector.functions import (cross, dot, express,
+                                            time_derivative,
+                                            kinematic_equations, outer,
+                                            partial_velocity,
+                                            get_motion_params, dynamicsymbols)
+from sympy.simplify import trigsimp
+from sympy.testing.pytest import raises
+
+q1, q2, q3, q4, q5 = symbols('q1 q2 q3 q4 q5')
+N = ReferenceFrame('N')
+A = N.orientnew('A', 'Axis', [q1, N.z])
+B = A.orientnew('B', 'Axis', [q2, A.x])
+C = B.orientnew('C', 'Axis', [q3, B.y])
+
+
+def test_dot():
+    assert dot(A.x, A.x) == 1
+    assert dot(A.x, A.y) == 0
+    assert dot(A.x, A.z) == 0
+
+    assert dot(A.y, A.x) == 0
+    assert dot(A.y, A.y) == 1
+    assert dot(A.y, A.z) == 0
+
+    assert dot(A.z, A.x) == 0
+    assert dot(A.z, A.y) == 0
+    assert dot(A.z, A.z) == 1
+
+
+def test_dot_different_frames():
+    assert dot(N.x, A.x) == cos(q1)
+    assert dot(N.x, A.y) == -sin(q1)
+    assert dot(N.x, A.z) == 0
+    assert dot(N.y, A.x) == sin(q1)
+    assert dot(N.y, A.y) == cos(q1)
+    assert dot(N.y, A.z) == 0
+    assert dot(N.z, A.x) == 0
+    assert dot(N.z, A.y) == 0
+    assert dot(N.z, A.z) == 1
+
+    assert trigsimp(dot(N.x, A.x + A.y)) == sqrt(2)*cos(q1 + pi/4)
+    assert trigsimp(dot(N.x, A.x + A.y)) == trigsimp(dot(A.x + A.y, N.x))
+
+    assert dot(A.x, C.x) == cos(q3)
+    assert dot(A.x, C.y) == 0
+    assert dot(A.x, C.z) == sin(q3)
+    assert dot(A.y, C.x) == sin(q2)*sin(q3)
+    assert dot(A.y, C.y) == cos(q2)
+    assert dot(A.y, C.z) == -sin(q2)*cos(q3)
+    assert dot(A.z, C.x) == -cos(q2)*sin(q3)
+    assert dot(A.z, C.y) == sin(q2)
+    assert dot(A.z, C.z) == cos(q2)*cos(q3)
+
+
+def test_cross():
+    assert cross(A.x, A.x) == 0
+    assert cross(A.x, A.y) == A.z
+    assert cross(A.x, A.z) == -A.y
+
+    assert cross(A.y, A.x) == -A.z
+    assert cross(A.y, A.y) == 0
+    assert cross(A.y, A.z) == A.x
+
+    assert cross(A.z, A.x) == A.y
+    assert cross(A.z, A.y) == -A.x
+    assert cross(A.z, A.z) == 0
+
+
+def test_cross_different_frames():
+    assert cross(N.x, A.x) == sin(q1)*A.z
+    assert cross(N.x, A.y) == cos(q1)*A.z
+    assert cross(N.x, A.z) == -sin(q1)*A.x - cos(q1)*A.y
+    assert cross(N.y, A.x) == -cos(q1)*A.z
+    assert cross(N.y, A.y) == sin(q1)*A.z
+    assert cross(N.y, A.z) == cos(q1)*A.x - sin(q1)*A.y
+    assert cross(N.z, A.x) == A.y
+    assert cross(N.z, A.y) == -A.x
+    assert cross(N.z, A.z) == 0
+
+    assert cross(N.x, A.x) == sin(q1)*A.z
+    assert cross(N.x, A.y) == cos(q1)*A.z
+    assert cross(N.x, A.x + A.y) == sin(q1)*A.z + cos(q1)*A.z
+    assert cross(A.x + A.y, N.x) == -sin(q1)*A.z - cos(q1)*A.z
+
+    assert cross(A.x, C.x) == sin(q3)*C.y
+    assert cross(A.x, C.y) == -sin(q3)*C.x + cos(q3)*C.z
+    assert cross(A.x, C.z) == -cos(q3)*C.y
+    assert cross(C.x, A.x) == -sin(q3)*C.y
+    assert cross(C.y, A.x).express(C).simplify() == sin(q3)*C.x - cos(q3)*C.z
+    assert cross(C.z, A.x) == cos(q3)*C.y
+
+def test_operator_match():
+    """Test that the output of dot, cross, outer functions match
+    operator behavior.
+    """
+    A = ReferenceFrame('A')
+    v = A.x + A.y
+    d = v | v
+    zerov = Vector(0)
+    zerod = Dyadic(0)
+
+    # dot products
+    assert d & d == dot(d, d)
+    assert d & zerod == dot(d, zerod)
+    assert zerod & d == dot(zerod, d)
+    assert d & v == dot(d, v)
+    assert v & d == dot(v, d)
+    assert d & zerov == dot(d, zerov)
+    assert zerov & d == dot(zerov, d)
+    raises(TypeError, lambda: dot(d, S.Zero))
+    raises(TypeError, lambda: dot(S.Zero, d))
+    raises(TypeError, lambda: dot(d, 0))
+    raises(TypeError, lambda: dot(0, d))
+    assert v & v == dot(v, v)
+    assert v & zerov == dot(v, zerov)
+    assert zerov & v == dot(zerov, v)
+    raises(TypeError, lambda: dot(v, S.Zero))
+    raises(TypeError, lambda: dot(S.Zero, v))
+    raises(TypeError, lambda: dot(v, 0))
+    raises(TypeError, lambda: dot(0, v))
+
+    # cross products
+    raises(TypeError, lambda: cross(d, d))
+    raises(TypeError, lambda: cross(d, zerod))
+    raises(TypeError, lambda: cross(zerod, d))
+    assert d ^ v == cross(d, v)
+    assert v ^ d == cross(v, d)
+    assert d ^ zerov == cross(d, zerov)
+    assert zerov ^ d == cross(zerov, d)
+    assert zerov ^ d == cross(zerov, d)
+    raises(TypeError, lambda: cross(d, S.Zero))
+    raises(TypeError, lambda: cross(S.Zero, d))
+    raises(TypeError, lambda: cross(d, 0))
+    raises(TypeError, lambda: cross(0, d))
+    assert v ^ v == cross(v, v)
+    assert v ^ zerov == cross(v, zerov)
+    assert zerov ^ v == cross(zerov, v)
+    raises(TypeError, lambda: cross(v, S.Zero))
+    raises(TypeError, lambda: cross(S.Zero, v))
+    raises(TypeError, lambda: cross(v, 0))
+    raises(TypeError, lambda: cross(0, v))
+
+    # outer products
+    raises(TypeError, lambda: outer(d, d))
+    raises(TypeError, lambda: outer(d, zerod))
+    raises(TypeError, lambda: outer(zerod, d))
+    raises(TypeError, lambda: outer(d, v))
+    raises(TypeError, lambda: outer(v, d))
+    raises(TypeError, lambda: outer(d, zerov))
+    raises(TypeError, lambda: outer(zerov, d))
+    raises(TypeError, lambda: outer(zerov, d))
+    raises(TypeError, lambda: outer(d, S.Zero))
+    raises(TypeError, lambda: outer(S.Zero, d))
+    raises(TypeError, lambda: outer(d, 0))
+    raises(TypeError, lambda: outer(0, d))
+    assert v | v == outer(v, v)
+    assert v | zerov == outer(v, zerov)
+    assert zerov | v == outer(zerov, v)
+    raises(TypeError, lambda: outer(v, S.Zero))
+    raises(TypeError, lambda: outer(S.Zero, v))
+    raises(TypeError, lambda: outer(v, 0))
+    raises(TypeError, lambda: outer(0, v))
+
+
+def test_express():
+    assert express(Vector(0), N) == Vector(0)
+    assert express(S.Zero, N) is S.Zero
+    assert express(A.x, C) == cos(q3)*C.x + sin(q3)*C.z
+    assert express(A.y, C) == sin(q2)*sin(q3)*C.x + cos(q2)*C.y - \
+        sin(q2)*cos(q3)*C.z
+    assert express(A.z, C) == -sin(q3)*cos(q2)*C.x + sin(q2)*C.y + \
+        cos(q2)*cos(q3)*C.z
+    assert express(A.x, N) == cos(q1)*N.x + sin(q1)*N.y
+    assert express(A.y, N) == -sin(q1)*N.x + cos(q1)*N.y
+    assert express(A.z, N) == N.z
+    assert express(A.x, A) == A.x
+    assert express(A.y, A) == A.y
+    assert express(A.z, A) == A.z
+    assert express(A.x, B) == B.x
+    assert express(A.y, B) == cos(q2)*B.y - sin(q2)*B.z
+    assert express(A.z, B) == sin(q2)*B.y + cos(q2)*B.z
+    assert express(A.x, C) == cos(q3)*C.x + sin(q3)*C.z
+    assert express(A.y, C) == sin(q2)*sin(q3)*C.x + cos(q2)*C.y - \
+        sin(q2)*cos(q3)*C.z
+    assert express(A.z, C) == -sin(q3)*cos(q2)*C.x + sin(q2)*C.y + \
+        cos(q2)*cos(q3)*C.z
+    # Check to make sure UnitVectors get converted properly
+    assert express(N.x, N) == N.x
+    assert express(N.y, N) == N.y
+    assert express(N.z, N) == N.z
+    assert express(N.x, A) == (cos(q1)*A.x - sin(q1)*A.y)
+    assert express(N.y, A) == (sin(q1)*A.x + cos(q1)*A.y)
+    assert express(N.z, A) == A.z
+    assert express(N.x, B) == (cos(q1)*B.x - sin(q1)*cos(q2)*B.y +
+            sin(q1)*sin(q2)*B.z)
+    assert express(N.y, B) == (sin(q1)*B.x + cos(q1)*cos(q2)*B.y -
+            sin(q2)*cos(q1)*B.z)
+    assert express(N.z, B) == (sin(q2)*B.y + cos(q2)*B.z)
+    assert express(N.x, C) == (
+        (cos(q1)*cos(q3) - sin(q1)*sin(q2)*sin(q3))*C.x -
+        sin(q1)*cos(q2)*C.y +
+        (sin(q3)*cos(q1) + sin(q1)*sin(q2)*cos(q3))*C.z)
+    assert express(N.y, C) == (
+        (sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1))*C.x +
+        cos(q1)*cos(q2)*C.y +
+        (sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3))*C.z)
+    assert express(N.z, C) == (-sin(q3)*cos(q2)*C.x + sin(q2)*C.y +
+            cos(q2)*cos(q3)*C.z)
+
+    assert express(A.x, N) == (cos(q1)*N.x + sin(q1)*N.y)
+    assert express(A.y, N) == (-sin(q1)*N.x + cos(q1)*N.y)
+    assert express(A.z, N) == N.z
+    assert express(A.x, A) == A.x
+    assert express(A.y, A) == A.y
+    assert express(A.z, A) == A.z
+    assert express(A.x, B) == B.x
+    assert express(A.y, B) == (cos(q2)*B.y - sin(q2)*B.z)
+    assert express(A.z, B) == (sin(q2)*B.y + cos(q2)*B.z)
+    assert express(A.x, C) == (cos(q3)*C.x + sin(q3)*C.z)
+    assert express(A.y, C) == (sin(q2)*sin(q3)*C.x + cos(q2)*C.y -
+            sin(q2)*cos(q3)*C.z)
+    assert express(A.z, C) == (-sin(q3)*cos(q2)*C.x + sin(q2)*C.y +
+            cos(q2)*cos(q3)*C.z)
+
+    assert express(B.x, N) == (cos(q1)*N.x + sin(q1)*N.y)
+    assert express(B.y, N) == (-sin(q1)*cos(q2)*N.x +
+            cos(q1)*cos(q2)*N.y + sin(q2)*N.z)
+    assert express(B.z, N) == (sin(q1)*sin(q2)*N.x -
+            sin(q2)*cos(q1)*N.y + cos(q2)*N.z)
+    assert express(B.x, A) == A.x
+    assert express(B.y, A) == (cos(q2)*A.y + sin(q2)*A.z)
+    assert express(B.z, A) == (-sin(q2)*A.y + cos(q2)*A.z)
+    assert express(B.x, B) == B.x
+    assert express(B.y, B) == B.y
+    assert express(B.z, B) == B.z
+    assert express(B.x, C) == (cos(q3)*C.x + sin(q3)*C.z)
+    assert express(B.y, C) == C.y
+    assert express(B.z, C) == (-sin(q3)*C.x + cos(q3)*C.z)
+
+    assert express(C.x, N) == (
+        (cos(q1)*cos(q3) - sin(q1)*sin(q2)*sin(q3))*N.x +
+        (sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1))*N.y -
+        sin(q3)*cos(q2)*N.z)
+    assert express(C.y, N) == (
+        -sin(q1)*cos(q2)*N.x + cos(q1)*cos(q2)*N.y + sin(q2)*N.z)
+    assert express(C.z, N) == (
+        (sin(q3)*cos(q1) + sin(q1)*sin(q2)*cos(q3))*N.x +
+        (sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3))*N.y +
+        cos(q2)*cos(q3)*N.z)
+    assert express(C.x, A) == (cos(q3)*A.x + sin(q2)*sin(q3)*A.y -
+            sin(q3)*cos(q2)*A.z)
+    assert express(C.y, A) == (cos(q2)*A.y + sin(q2)*A.z)
+    assert express(C.z, A) == (sin(q3)*A.x - sin(q2)*cos(q3)*A.y +
+            cos(q2)*cos(q3)*A.z)
+    assert express(C.x, B) == (cos(q3)*B.x - sin(q3)*B.z)
+    assert express(C.y, B) == B.y
+    assert express(C.z, B) == (sin(q3)*B.x + cos(q3)*B.z)
+    assert express(C.x, C) == C.x
+    assert express(C.y, C) == C.y
+    assert express(C.z, C) == C.z == (C.z)
+
+    #  Check to make sure Vectors get converted back to UnitVectors
+    assert N.x == express((cos(q1)*A.x - sin(q1)*A.y), N).simplify()
+    assert N.y == express((sin(q1)*A.x + cos(q1)*A.y), N).simplify()
+    assert N.x == express((cos(q1)*B.x - sin(q1)*cos(q2)*B.y +
+            sin(q1)*sin(q2)*B.z), N).simplify()
+    assert N.y == express((sin(q1)*B.x + cos(q1)*cos(q2)*B.y -
+        sin(q2)*cos(q1)*B.z), N).simplify()
+    assert N.z == express((sin(q2)*B.y + cos(q2)*B.z), N).simplify()
+
+    """
+    These don't really test our code, they instead test the auto simplification
+    (or lack thereof) of SymPy.
+    assert N.x == express((
+            (cos(q1)*cos(q3)-sin(q1)*sin(q2)*sin(q3))*C.x -
+            sin(q1)*cos(q2)*C.y +
+            (sin(q3)*cos(q1)+sin(q1)*sin(q2)*cos(q3))*C.z), N)
+    assert N.y == express((
+            (sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1))*C.x +
+            cos(q1)*cos(q2)*C.y +
+            (sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3))*C.z), N)
+    assert N.z == express((-sin(q3)*cos(q2)*C.x + sin(q2)*C.y +
+            cos(q2)*cos(q3)*C.z), N)
+    """
+
+    assert A.x == express((cos(q1)*N.x + sin(q1)*N.y), A).simplify()
+    assert A.y == express((-sin(q1)*N.x + cos(q1)*N.y), A).simplify()
+
+    assert A.y == express((cos(q2)*B.y - sin(q2)*B.z), A).simplify()
+    assert A.z == express((sin(q2)*B.y + cos(q2)*B.z), A).simplify()
+
+    assert A.x == express((cos(q3)*C.x + sin(q3)*C.z), A).simplify()
+
+    # Tripsimp messes up here too.
+    #print express((sin(q2)*sin(q3)*C.x + cos(q2)*C.y -
+    #        sin(q2)*cos(q3)*C.z), A)
+    assert A.y == express((sin(q2)*sin(q3)*C.x + cos(q2)*C.y -
+            sin(q2)*cos(q3)*C.z), A).simplify()
+
+    assert A.z == express((-sin(q3)*cos(q2)*C.x + sin(q2)*C.y +
+            cos(q2)*cos(q3)*C.z), A).simplify()
+    assert B.x == express((cos(q1)*N.x + sin(q1)*N.y), B).simplify()
+    assert B.y == express((-sin(q1)*cos(q2)*N.x +
+            cos(q1)*cos(q2)*N.y + sin(q2)*N.z), B).simplify()
+
+    assert B.z == express((sin(q1)*sin(q2)*N.x -
+            sin(q2)*cos(q1)*N.y + cos(q2)*N.z), B).simplify()
+
+    assert B.y == express((cos(q2)*A.y + sin(q2)*A.z), B).simplify()
+    assert B.z == express((-sin(q2)*A.y + cos(q2)*A.z), B).simplify()
+    assert B.x == express((cos(q3)*C.x + sin(q3)*C.z), B).simplify()
+    assert B.z == express((-sin(q3)*C.x + cos(q3)*C.z), B).simplify()
+
+    """
+    assert C.x == express((
+            (cos(q1)*cos(q3)-sin(q1)*sin(q2)*sin(q3))*N.x +
+            (sin(q1)*cos(q3)+sin(q2)*sin(q3)*cos(q1))*N.y -
+                sin(q3)*cos(q2)*N.z), C)
+    assert C.y == express((
+            -sin(q1)*cos(q2)*N.x + cos(q1)*cos(q2)*N.y + sin(q2)*N.z), C)
+    assert C.z == express((
+            (sin(q3)*cos(q1)+sin(q1)*sin(q2)*cos(q3))*N.x +
+            (sin(q1)*sin(q3)-sin(q2)*cos(q1)*cos(q3))*N.y +
+            cos(q2)*cos(q3)*N.z), C)
+    """
+    assert C.x == express((cos(q3)*A.x + sin(q2)*sin(q3)*A.y -
+            sin(q3)*cos(q2)*A.z), C).simplify()
+    assert C.y == express((cos(q2)*A.y + sin(q2)*A.z), C).simplify()
+    assert C.z == express((sin(q3)*A.x - sin(q2)*cos(q3)*A.y +
+            cos(q2)*cos(q3)*A.z), C).simplify()
+    assert C.x == express((cos(q3)*B.x - sin(q3)*B.z), C).simplify()
+    assert C.z == express((sin(q3)*B.x + cos(q3)*B.z), C).simplify()
+
+
+def test_time_derivative():
+    #The use of time_derivative for calculations pertaining to scalar
+    #fields has been tested in test_coordinate_vars in test_essential.py
+    A = ReferenceFrame('A')
+    q = dynamicsymbols('q')
+    qd = dynamicsymbols('q', 1)
+    B = A.orientnew('B', 'Axis', [q, A.z])
+    d = A.x | A.x
+    assert time_derivative(d, B) == (-qd) * (A.y | A.x) + \
+           (-qd) * (A.x | A.y)
+    d1 = A.x | B.y
+    assert time_derivative(d1, A) == - qd*(A.x|B.x)
+    assert time_derivative(d1, B) == - qd*(A.y|B.y)
+    d2 = A.x | B.x
+    assert time_derivative(d2, A) == qd*(A.x|B.y)
+    assert time_derivative(d2, B) == - qd*(A.y|B.x)
+    d3 = A.x | B.z
+    assert time_derivative(d3, A) == 0
+    assert time_derivative(d3, B) == - qd*(A.y|B.z)
+    q1, q2, q3, q4 = dynamicsymbols('q1 q2 q3 q4')
+    q1d, q2d, q3d, q4d = dynamicsymbols('q1 q2 q3 q4', 1)
+    q1dd, q2dd, q3dd, q4dd = dynamicsymbols('q1 q2 q3 q4', 2)
+    C = B.orientnew('C', 'Axis', [q4, B.x])
+    v1 = q1 * A.z
+    v2 = q2*A.x + q3*B.y
+    v3 = q1*A.x + q2*A.y + q3*A.z
+    assert time_derivative(B.x, C) == 0
+    assert time_derivative(B.y, C) == - q4d*B.z
+    assert time_derivative(B.z, C) == q4d*B.y
+    assert time_derivative(v1, B) == q1d*A.z
+    assert time_derivative(v1, C) == - q1*sin(q)*q4d*A.x + \
+           q1*cos(q)*q4d*A.y + q1d*A.z
+    assert time_derivative(v2, A) == q2d*A.x - q3*qd*B.x + q3d*B.y
+    assert time_derivative(v2, C) == q2d*A.x - q2*qd*A.y + \
+           q2*sin(q)*q4d*A.z + q3d*B.y - q3*q4d*B.z
+    assert time_derivative(v3, B) == (q2*qd + q1d)*A.x + \
+           (-q1*qd + q2d)*A.y + q3d*A.z
+    assert time_derivative(d, C) == - qd*(A.y|A.x) + \
+           sin(q)*q4d*(A.z|A.x) - qd*(A.x|A.y) + sin(q)*q4d*(A.x|A.z)
+    raises(ValueError, lambda: time_derivative(B.x, C, order=0.5))
+    raises(ValueError, lambda: time_derivative(B.x, C, order=-1))
+
+
+def test_get_motion_methods():
+    #Initialization
+    t = dynamicsymbols._t
+    s1, s2, s3 = symbols('s1 s2 s3')
+    S1, S2, S3 = symbols('S1 S2 S3')
+    S4, S5, S6 = symbols('S4 S5 S6')
+    t1, t2 = symbols('t1 t2')
+    a, b, c = dynamicsymbols('a b c')
+    ad, bd, cd = dynamicsymbols('a b c', 1)
+    a2d, b2d, c2d = dynamicsymbols('a b c', 2)
+    v0 = S1*N.x + S2*N.y + S3*N.z
+    v01 = S4*N.x + S5*N.y + S6*N.z
+    v1 = s1*N.x + s2*N.y + s3*N.z
+    v2 = a*N.x + b*N.y + c*N.z
+    v2d = ad*N.x + bd*N.y + cd*N.z
+    v2dd = a2d*N.x + b2d*N.y + c2d*N.z
+    #Test position parameter
+    assert get_motion_params(frame = N) == (0, 0, 0)
+    assert get_motion_params(N, position=v1) == (0, 0, v1)
+    assert get_motion_params(N, position=v2) == (v2dd, v2d, v2)
+    #Test velocity parameter
+    assert get_motion_params(N, velocity=v1) == (0, v1, v1 * t)
+    assert get_motion_params(N, velocity=v1, position=v0, timevalue1=t1) == \
+           (0, v1, v0 + v1*(t - t1))
+    answer = get_motion_params(N, velocity=v1, position=v2, timevalue1=t1)
+    answer_expected = (0, v1, v1*t - v1*t1 + v2.subs(t, t1))
+    assert answer == answer_expected
+
+    answer = get_motion_params(N, velocity=v2, position=v0, timevalue1=t1)
+    integral_vector = Integral(a, (t, t1, t))*N.x + Integral(b, (t, t1, t))*N.y \
+            + Integral(c, (t, t1, t))*N.z
+    answer_expected = (v2d, v2, v0 + integral_vector)
+    assert answer == answer_expected
+
+    #Test acceleration parameter
+    assert get_motion_params(N, acceleration=v1) == \
+           (v1, v1 * t, v1 * t**2/2)
+    assert get_motion_params(N, acceleration=v1, velocity=v0,
+                          position=v2, timevalue1=t1, timevalue2=t2) == \
+           (v1, (v0 + v1*t - v1*t2),
+            -v0*t1 + v1*t**2/2 + v1*t2*t1 - \
+            v1*t1**2/2 + t*(v0 - v1*t2) + \
+            v2.subs(t, t1))
+    assert get_motion_params(N, acceleration=v1, velocity=v0,
+                             position=v01, timevalue1=t1, timevalue2=t2) == \
+           (v1, v0 + v1*t - v1*t2,
+            -v0*t1 + v01 + v1*t**2/2 + \
+            v1*t2*t1 - v1*t1**2/2 + \
+            t*(v0 - v1*t2))
+    answer = get_motion_params(N, acceleration=a*N.x, velocity=S1*N.x,
+                          position=S2*N.x, timevalue1=t1, timevalue2=t2)
+    i1 = Integral(a, (t, t2, t))
+    answer_expected = (a*N.x, (S1 + i1)*N.x, \
+        (S2 + Integral(S1 + i1, (t, t1, t)))*N.x)
+    assert answer == answer_expected
+
+
+def test_kin_eqs():
+    q0, q1, q2, q3 = dynamicsymbols('q0 q1 q2 q3')
+    q0d, q1d, q2d, q3d = dynamicsymbols('q0 q1 q2 q3', 1)
+    u1, u2, u3 = dynamicsymbols('u1 u2 u3')
+    ke = kinematic_equations([u1,u2,u3], [q1,q2,q3], 'body', 313)
+    assert ke == kinematic_equations([u1,u2,u3], [q1,q2,q3], 'body', '313')
+    kds = kinematic_equations([u1, u2, u3], [q0, q1, q2, q3], 'quaternion')
+    assert kds == [-0.5 * q0 * u1 - 0.5 * q2 * u3 + 0.5 * q3 * u2 + q1d,
+            -0.5 * q0 * u2 + 0.5 * q1 * u3 - 0.5 * q3 * u1 + q2d,
+            -0.5 * q0 * u3 - 0.5 * q1 * u2 + 0.5 * q2 * u1 + q3d,
+            0.5 * q1 * u1 + 0.5 * q2 * u2 + 0.5 * q3 * u3 + q0d]
+    raises(ValueError, lambda: kinematic_equations([u1, u2, u3], [q0, q1, q2], 'quaternion'))
+    raises(ValueError, lambda: kinematic_equations([u1, u2, u3], [q0, q1, q2, q3], 'quaternion', '123'))
+    raises(ValueError, lambda: kinematic_equations([u1, u2, u3], [q0, q1, q2, q3], 'foo'))
+    raises(TypeError, lambda: kinematic_equations(u1, [q0, q1, q2, q3], 'quaternion'))
+    raises(TypeError, lambda: kinematic_equations([u1], [q0, q1, q2, q3], 'quaternion'))
+    raises(TypeError, lambda: kinematic_equations([u1, u2, u3], q0, 'quaternion'))
+    raises(ValueError, lambda: kinematic_equations([u1, u2, u3], [q0, q1, q2, q3], 'body'))
+    raises(ValueError, lambda: kinematic_equations([u1, u2, u3], [q0, q1, q2, q3], 'space'))
+    raises(ValueError, lambda: kinematic_equations([u1, u2, u3], [q0, q1, q2], 'body', '222'))
+    assert kinematic_equations([0, 0, 0], [q0, q1, q2], 'space') == [S.Zero, S.Zero, S.Zero]
+
+
+def test_partial_velocity():
+    q1, q2, q3, u1, u2, u3 = dynamicsymbols('q1 q2 q3 u1 u2 u3')
+    u4, u5 = dynamicsymbols('u4, u5')
+    r = symbols('r')
+
+    N = ReferenceFrame('N')
+    Y = N.orientnew('Y', 'Axis', [q1, N.z])
+    L = Y.orientnew('L', 'Axis', [q2, Y.x])
+    R = L.orientnew('R', 'Axis', [q3, L.y])
+    R.set_ang_vel(N, u1 * L.x + u2 * L.y + u3 * L.z)
+
+    C = Point('C')
+    C.set_vel(N, u4 * L.x + u5 * (Y.z ^ L.x))
+    Dmc = C.locatenew('Dmc', r * L.z)
+    Dmc.v2pt_theory(C, N, R)
+
+    vel_list = [Dmc.vel(N), C.vel(N), R.ang_vel_in(N)]
+    u_list = [u1, u2, u3, u4, u5]
+    assert (partial_velocity(vel_list, u_list, N) ==
+            [[- r*L.y, r*L.x, 0, L.x, cos(q2)*L.y - sin(q2)*L.z],
+            [0, 0, 0, L.x, cos(q2)*L.y - sin(q2)*L.z],
+            [L.x, L.y, L.z, 0, 0]])
+
+    # Make sure that partial velocities can be computed regardless if the
+    # orientation between frames is defined or not.
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    v = u4 * A.x + u5 * B.y
+    assert partial_velocity((v, ), (u4, u5), A) == [[A.x, B.y]]
+
+    raises(TypeError, lambda: partial_velocity(Dmc.vel(N), u_list, N))
+    raises(TypeError, lambda: partial_velocity(vel_list, u1, N))
+
+def test_dynamicsymbols():
+    #Tests to check the assumptions applied to dynamicsymbols
+    f1 = dynamicsymbols('f1')
+    f2 = dynamicsymbols('f2', real=True)
+    f3 = dynamicsymbols('f3', positive=True)
+    f4, f5 = dynamicsymbols('f4,f5', commutative=False)
+    f6 = dynamicsymbols('f6', integer=True)
+    assert f1.is_real is None
+    assert f2.is_real
+    assert f3.is_positive
+    assert f4*f5 != f5*f4
+    assert f6.is_integer

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/vector/tests/test_output.py

@@ -0,0 +1,75 @@
+from sympy.core.singleton import S
+from sympy.physics.vector import Vector, ReferenceFrame, Dyadic
+from sympy.testing.pytest import raises
+
+A = ReferenceFrame('A')
+
+
+def test_output_type():
+    A = ReferenceFrame('A')
+    v = A.x + A.y
+    d = v | v
+    zerov = Vector(0)
+    zerod = Dyadic(0)
+
+    # dot products
+    assert isinstance(d & d, Dyadic)
+    assert isinstance(d & zerod, Dyadic)
+    assert isinstance(zerod & d, Dyadic)
+    assert isinstance(d & v, Vector)
+    assert isinstance(v & d, Vector)
+    assert isinstance(d & zerov, Vector)
+    assert isinstance(zerov & d, Vector)
+    raises(TypeError, lambda: d & S.Zero)
+    raises(TypeError, lambda: S.Zero & d)
+    raises(TypeError, lambda: d & 0)
+    raises(TypeError, lambda: 0 & d)
+    assert not isinstance(v & v, (Vector, Dyadic))
+    assert not isinstance(v & zerov, (Vector, Dyadic))
+    assert not isinstance(zerov & v, (Vector, Dyadic))
+    raises(TypeError, lambda: v & S.Zero)
+    raises(TypeError, lambda: S.Zero & v)
+    raises(TypeError, lambda: v & 0)
+    raises(TypeError, lambda: 0 & v)
+
+    # cross products
+    raises(TypeError, lambda: d ^ d)
+    raises(TypeError, lambda: d ^ zerod)
+    raises(TypeError, lambda: zerod ^ d)
+    assert isinstance(d ^ v, Dyadic)
+    assert isinstance(v ^ d, Dyadic)
+    assert isinstance(d ^ zerov, Dyadic)
+    assert isinstance(zerov ^ d, Dyadic)
+    assert isinstance(zerov ^ d, Dyadic)
+    raises(TypeError, lambda: d ^ S.Zero)
+    raises(TypeError, lambda: S.Zero ^ d)
+    raises(TypeError, lambda: d ^ 0)
+    raises(TypeError, lambda: 0 ^ d)
+    assert isinstance(v ^ v, Vector)
+    assert isinstance(v ^ zerov, Vector)
+    assert isinstance(zerov ^ v, Vector)
+    raises(TypeError, lambda: v ^ S.Zero)
+    raises(TypeError, lambda: S.Zero ^ v)
+    raises(TypeError, lambda: v ^ 0)
+    raises(TypeError, lambda: 0 ^ v)
+
+    # outer products
+    raises(TypeError, lambda: d | d)
+    raises(TypeError, lambda: d | zerod)
+    raises(TypeError, lambda: zerod | d)
+    raises(TypeError, lambda: d | v)
+    raises(TypeError, lambda: v | d)
+    raises(TypeError, lambda: d | zerov)
+    raises(TypeError, lambda: zerov | d)
+    raises(TypeError, lambda: zerov | d)
+    raises(TypeError, lambda: d | S.Zero)
+    raises(TypeError, lambda: S.Zero | d)
+    raises(TypeError, lambda: d | 0)
+    raises(TypeError, lambda: 0 | d)
+    assert isinstance(v | v, Dyadic)
+    assert isinstance(v | zerov, Dyadic)
+    assert isinstance(zerov | v, Dyadic)
+    raises(TypeError, lambda: v | S.Zero)
+    raises(TypeError, lambda: S.Zero | v)
+    raises(TypeError, lambda: v | 0)
+    raises(TypeError, lambda: 0 | v)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/vector/tests/test_point.py

@@ -0,0 +1,382 @@
+from sympy.physics.vector import dynamicsymbols, Point, ReferenceFrame
+from sympy.testing.pytest import raises, ignore_warnings
+import warnings
+
+def test_point_v1pt_theorys():
+    q, q2 = dynamicsymbols('q q2')
+    qd, q2d = dynamicsymbols('q q2', 1)
+    qdd, q2dd = dynamicsymbols('q q2', 2)
+    N = ReferenceFrame('N')
+    B = ReferenceFrame('B')
+    B.set_ang_vel(N, qd * B.z)
+    O = Point('O')
+    P = O.locatenew('P', B.x)
+    P.set_vel(B, 0)
+    O.set_vel(N, 0)
+    assert P.v1pt_theory(O, N, B) == qd * B.y
+    O.set_vel(N, N.x)
+    assert P.v1pt_theory(O, N, B) == N.x + qd * B.y
+    P.set_vel(B, B.z)
+    assert P.v1pt_theory(O, N, B) == B.z + N.x + qd * B.y
+
+
+def test_point_a1pt_theorys():
+    q, q2 = dynamicsymbols('q q2')
+    qd, q2d = dynamicsymbols('q q2', 1)
+    qdd, q2dd = dynamicsymbols('q q2', 2)
+    N = ReferenceFrame('N')
+    B = ReferenceFrame('B')
+    B.set_ang_vel(N, qd * B.z)
+    O = Point('O')
+    P = O.locatenew('P', B.x)
+    P.set_vel(B, 0)
+    O.set_vel(N, 0)
+    assert P.a1pt_theory(O, N, B) == -(qd**2) * B.x + qdd * B.y
+    P.set_vel(B, q2d * B.z)
+    assert P.a1pt_theory(O, N, B) == -(qd**2) * B.x + qdd * B.y + q2dd * B.z
+    O.set_vel(N, q2d * B.x)
+    assert P.a1pt_theory(O, N, B) == ((q2dd - qd**2) * B.x + (q2d * qd + qdd) * B.y +
+                               q2dd * B.z)
+
+
+def test_point_v2pt_theorys():
+    q = dynamicsymbols('q')
+    qd = dynamicsymbols('q', 1)
+    N = ReferenceFrame('N')
+    B = N.orientnew('B', 'Axis', [q, N.z])
+    O = Point('O')
+    P = O.locatenew('P', 0)
+    O.set_vel(N, 0)
+    assert P.v2pt_theory(O, N, B) == 0
+    P = O.locatenew('P', B.x)
+    assert P.v2pt_theory(O, N, B) == (qd * B.z ^ B.x)
+    O.set_vel(N, N.x)
+    assert P.v2pt_theory(O, N, B) == N.x + qd * B.y
+
+
+def test_point_a2pt_theorys():
+    q = dynamicsymbols('q')
+    qd = dynamicsymbols('q', 1)
+    qdd = dynamicsymbols('q', 2)
+    N = ReferenceFrame('N')
+    B = N.orientnew('B', 'Axis', [q, N.z])
+    O = Point('O')
+    P = O.locatenew('P', 0)
+    O.set_vel(N, 0)
+    assert P.a2pt_theory(O, N, B) == 0
+    P.set_pos(O, B.x)
+    assert P.a2pt_theory(O, N, B) == (-qd**2) * B.x + (qdd) * B.y
+
+
+def test_point_funcs():
+    q, q2 = dynamicsymbols('q q2')
+    qd, q2d = dynamicsymbols('q q2', 1)
+    qdd, q2dd = dynamicsymbols('q q2', 2)
+    N = ReferenceFrame('N')
+    B = ReferenceFrame('B')
+    B.set_ang_vel(N, 5 * B.y)
+    O = Point('O')
+    P = O.locatenew('P', q * B.x + q2 * B.y)
+    assert P.pos_from(O) == q * B.x + q2 * B.y
+    P.set_vel(B, qd * B.x + q2d * B.y)
+    assert P.vel(B) == qd * B.x + q2d * B.y
+    O.set_vel(N, 0)
+    assert O.vel(N) == 0
+    assert P.a1pt_theory(O, N, B) == ((-25 * q + qdd) * B.x + (q2dd) * B.y +
+                               (-10 * qd) * B.z)
+
+    B = N.orientnew('B', 'Axis', [q, N.z])
+    O = Point('O')
+    P = O.locatenew('P', 10 * B.x)
+    O.set_vel(N, 5 * N.x)
+    assert O.vel(N) == 5 * N.x
+    assert P.a2pt_theory(O, N, B) == (-10 * qd**2) * B.x + (10 * qdd) * B.y
+
+    B.set_ang_vel(N, 5 * B.y)
+    O = Point('O')
+    P = O.locatenew('P', q * B.x + q2 * B.y)
+    P.set_vel(B, qd * B.x + q2d * B.y)
+    O.set_vel(N, 0)
+    assert P.v1pt_theory(O, N, B) == qd * B.x + q2d * B.y - 5 * q * B.z
+
+
+def test_point_pos():
+    q = dynamicsymbols('q')
+    N = ReferenceFrame('N')
+    B = N.orientnew('B', 'Axis', [q, N.z])
+    O = Point('O')
+    P = O.locatenew('P', 10 * N.x + 5 * B.x)
+    assert P.pos_from(O) == 10 * N.x + 5 * B.x
+    Q = P.locatenew('Q', 10 * N.y + 5 * B.y)
+    assert Q.pos_from(P) == 10 * N.y + 5 * B.y
+    assert Q.pos_from(O) == 10 * N.x + 10 * N.y + 5 * B.x + 5 * B.y
+    assert O.pos_from(Q) == -10 * N.x - 10 * N.y - 5 * B.x - 5 * B.y
+
+def test_point_partial_velocity():
+
+    N = ReferenceFrame('N')
+    A = ReferenceFrame('A')
+
+    p = Point('p')
+
+    u1, u2 = dynamicsymbols('u1, u2')
+
+    p.set_vel(N, u1 * A.x + u2 * N.y)
+
+    assert p.partial_velocity(N, u1) == A.x
+    assert p.partial_velocity(N, u1, u2) == (A.x, N.y)
+    raises(ValueError, lambda: p.partial_velocity(A, u1))
+
+def test_point_vel(): #Basic functionality
+    q1, q2 = dynamicsymbols('q1 q2')
+    N = ReferenceFrame('N')
+    B = ReferenceFrame('B')
+    Q = Point('Q')
+    O = Point('O')
+    Q.set_pos(O, q1 * N.x)
+    raises(ValueError , lambda: Q.vel(N)) # Velocity of O in N is not defined
+    O.set_vel(N, q2 * N.y)
+    assert O.vel(N) == q2 * N.y
+    raises(ValueError , lambda : O.vel(B)) #Velocity of O is not defined in B
+
+def test_auto_point_vel():
+    t = dynamicsymbols._t
+    q1, q2 = dynamicsymbols('q1 q2')
+    N = ReferenceFrame('N')
+    B = ReferenceFrame('B')
+    O = Point('O')
+    Q = Point('Q')
+    Q.set_pos(O, q1 * N.x)
+    O.set_vel(N, q2 * N.y)
+    assert Q.vel(N) == q1.diff(t) * N.x + q2 * N.y  # Velocity of Q using O
+    P1 = Point('P1')
+    P1.set_pos(O, q1 * B.x)
+    P2 = Point('P2')
+    P2.set_pos(P1, q2 * B.z)
+    raises(ValueError, lambda : P2.vel(B)) # O's velocity is defined in different frame, and no
+    #point in between has its velocity defined
+    raises(ValueError, lambda: P2.vel(N)) # Velocity of O not defined in N
+
+def test_auto_point_vel_multiple_point_path():
+    t = dynamicsymbols._t
+    q1, q2 = dynamicsymbols('q1 q2')
+    B = ReferenceFrame('B')
+    P = Point('P')
+    P.set_vel(B, q1 * B.x)
+    P1 = Point('P1')
+    P1.set_pos(P, q2 * B.y)
+    P1.set_vel(B, q1 * B.z)
+    P2 = Point('P2')
+    P2.set_pos(P1, q1 * B.z)
+    P3 = Point('P3')
+    P3.set_pos(P2, 10 * q1 * B.y)
+    assert P3.vel(B) == 10 * q1.diff(t) * B.y + (q1 + q1.diff(t)) * B.z
+
+def test_auto_vel_dont_overwrite():
+    t = dynamicsymbols._t
+    q1, q2, u1 = dynamicsymbols('q1, q2, u1')
+    N = ReferenceFrame('N')
+    P = Point('P1')
+    P.set_vel(N, u1 * N.x)
+    P1 = Point('P1')
+    P1.set_pos(P, q2 * N.y)
+    assert P1.vel(N) == q2.diff(t) * N.y + u1 * N.x
+    assert P.vel(N) == u1 * N.x
+    P1.set_vel(N, u1 * N.z)
+    assert P1.vel(N) == u1 * N.z
+
+def test_auto_point_vel_if_tree_has_vel_but_inappropriate_pos_vector():
+    q1, q2 = dynamicsymbols('q1 q2')
+    B = ReferenceFrame('B')
+    S = ReferenceFrame('S')
+    P = Point('P')
+    P.set_vel(B, q1 * B.x)
+    P1 = Point('P1')
+    P1.set_pos(P, S.y)
+    raises(ValueError, lambda : P1.vel(B)) # P1.pos_from(P) can't be expressed in B
+    raises(ValueError, lambda : P1.vel(S)) # P.vel(S) not defined
+
+def test_auto_point_vel_shortest_path():
+    t = dynamicsymbols._t
+    q1, q2, u1, u2 = dynamicsymbols('q1 q2 u1 u2')
+    B = ReferenceFrame('B')
+    P = Point('P')
+    P.set_vel(B, u1 * B.x)
+    P1 = Point('P1')
+    P1.set_pos(P, q2 * B.y)
+    P1.set_vel(B, q1 * B.z)
+    P2 = Point('P2')
+    P2.set_pos(P1, q1 * B.z)
+    P3 = Point('P3')
+    P3.set_pos(P2, 10 * q1 * B.y)
+    P4 = Point('P4')
+    P4.set_pos(P3, q1 * B.x)
+    O = Point('O')
+    O.set_vel(B, u2 * B.y)
+    O1 = Point('O1')
+    O1.set_pos(O, q2 * B.z)
+    P4.set_pos(O1, q1 * B.x + q2 * B.z)
+    with warnings.catch_warnings(): #There are two possible paths in this point tree, thus a warning is raised
+        warnings.simplefilter('error')
+        with ignore_warnings(UserWarning):
+            assert P4.vel(B) == q1.diff(t) * B.x + u2 * B.y + 2 * q2.diff(t) * B.z
+
+def test_auto_point_vel_connected_frames():
+    t = dynamicsymbols._t
+    q, q1, q2, u = dynamicsymbols('q q1 q2 u')
+    N = ReferenceFrame('N')
+    B = ReferenceFrame('B')
+    O = Point('O')
+    O.set_vel(N, u * N.x)
+    P = Point('P')
+    P.set_pos(O, q1 * N.x + q2 * B.y)
+    raises(ValueError, lambda: P.vel(N))
+    N.orient(B, 'Axis', (q, B.x))
+    assert P.vel(N) == (u + q1.diff(t)) * N.x + q2.diff(t) * B.y - q2 * q.diff(t) * B.z
+
+def test_auto_point_vel_multiple_paths_warning_arises():
+    q, u = dynamicsymbols('q u')
+    N = ReferenceFrame('N')
+    O = Point('O')
+    P = Point('P')
+    Q = Point('Q')
+    R = Point('R')
+    P.set_vel(N, u * N.x)
+    Q.set_vel(N, u *N.y)
+    R.set_vel(N, u * N.z)
+    O.set_pos(P, q * N.z)
+    O.set_pos(Q, q * N.y)
+    O.set_pos(R, q * N.x)
+    with warnings.catch_warnings(): #There are two possible paths in this point tree, thus a warning is raised
+        warnings.simplefilter("error")
+        raises(UserWarning ,lambda: O.vel(N))
+
+def test_auto_vel_cyclic_warning_arises():
+    P = Point('P')
+    P1 = Point('P1')
+    P2 = Point('P2')
+    P3 = Point('P3')
+    N = ReferenceFrame('N')
+    P.set_vel(N, N.x)
+    P1.set_pos(P, N.x)
+    P2.set_pos(P1, N.y)
+    P3.set_pos(P2, N.z)
+    P1.set_pos(P3, N.x + N.y)
+    with warnings.catch_warnings(): #The path is cyclic at P1, thus a warning is raised
+        warnings.simplefilter("error")
+        raises(UserWarning ,lambda: P2.vel(N))
+
+def test_auto_vel_cyclic_warning_msg():
+    P = Point('P')
+    P1 = Point('P1')
+    P2 = Point('P2')
+    P3 = Point('P3')
+    N = ReferenceFrame('N')
+    P.set_vel(N, N.x)
+    P1.set_pos(P, N.x)
+    P2.set_pos(P1, N.y)
+    P3.set_pos(P2, N.z)
+    P1.set_pos(P3, N.x + N.y)
+    with warnings.catch_warnings(record = True) as w: #The path is cyclic at P1, thus a warning is raised
+        warnings.simplefilter("always")
+        P2.vel(N)
+        msg = str(w[-1].message).replace("\n", " ")
+        assert issubclass(w[-1].category, UserWarning)
+        assert 'Kinematic loops are defined among the positions of points. This is likely not desired and may cause errors in your calculations.' in msg
+
+def test_auto_vel_multiple_path_warning_msg():
+    N = ReferenceFrame('N')
+    O = Point('O')
+    P = Point('P')
+    Q = Point('Q')
+    P.set_vel(N, N.x)
+    Q.set_vel(N, N.y)
+    O.set_pos(P, N.z)
+    O.set_pos(Q, N.y)
+    with warnings.catch_warnings(record = True) as w: #There are two possible paths in this point tree, thus a warning is raised
+        warnings.simplefilter("always")
+        O.vel(N)
+        msg = str(w[-1].message).replace("\n", " ")
+        assert issubclass(w[-1].category, UserWarning)
+        assert 'Velocity' in msg
+        assert 'automatically calculated based on point' in msg
+        assert 'Velocities from these points are not necessarily the same. This may cause errors in your calculations.' in msg
+
+def test_auto_vel_derivative():
+    q1, q2 = dynamicsymbols('q1:3')
+    u1, u2 = dynamicsymbols('u1:3', 1)
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    C = ReferenceFrame('C')
+    B.orient_axis(A, A.z, q1)
+    B.set_ang_vel(A, u1 * A.z)
+    C.orient_axis(B, B.z, q2)
+    C.set_ang_vel(B, u2 * B.z)
+
+    Am = Point('Am')
+    Am.set_vel(A, 0)
+    Bm = Point('Bm')
+    Bm.set_pos(Am, B.x)
+    Bm.set_vel(B, 0)
+    Bm.set_vel(C, 0)
+    Cm = Point('Cm')
+    Cm.set_pos(Bm, C.x)
+    Cm.set_vel(C, 0)
+    temp = Cm._vel_dict.copy()
+    assert Cm.vel(A) == (u1 * B.y + (u1 + u2) * C.y)
+    Cm._vel_dict = temp
+    Cm.v2pt_theory(Bm, B, C)
+    assert Cm.vel(A) == (u1 * B.y + (u1 + u2) * C.y)
+
+def test_auto_point_acc_zero_vel():
+    N = ReferenceFrame('N')
+    O = Point('O')
+    O.set_vel(N, 0)
+    assert O.acc(N) == 0 * N.x
+
+def test_auto_point_acc_compute_vel():
+    t = dynamicsymbols._t
+    q1 = dynamicsymbols('q1')
+    N = ReferenceFrame('N')
+    A = ReferenceFrame('A')
+    A.orient_axis(N, N.z, q1)
+
+    O = Point('O')
+    O.set_vel(N, 0)
+    P = Point('P')
+    P.set_pos(O, A.x)
+    assert P.acc(N) == -q1.diff(t) ** 2 * A.x + q1.diff(t, 2) * A.y
+
+def test_auto_acc_derivative():
+    # Tests whether the Point.acc method gives the correct acceleration of the
+    # end point of two linkages in series, while getting minimal information.
+    q1, q2 = dynamicsymbols('q1:3')
+    u1, u2 = dynamicsymbols('q1:3', 1)
+    v1, v2 = dynamicsymbols('q1:3', 2)
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    C = ReferenceFrame('C')
+    B.orient_axis(A, A.z, q1)
+    C.orient_axis(B, B.z, q2)
+
+    Am = Point('Am')
+    Am.set_vel(A, 0)
+    Bm = Point('Bm')
+    Bm.set_pos(Am, B.x)
+    Bm.set_vel(B, 0)
+    Bm.set_vel(C, 0)
+    Cm = Point('Cm')
+    Cm.set_pos(Bm, C.x)
+    Cm.set_vel(C, 0)
+
+    # Copy dictionaries to later check the calculation using the 2pt_theories
+    Bm_vel_dict, Cm_vel_dict = Bm._vel_dict.copy(), Cm._vel_dict.copy()
+    Bm_acc_dict, Cm_acc_dict = Bm._acc_dict.copy(), Cm._acc_dict.copy()
+    check = -u1 ** 2 * B.x + v1 * B.y - (u1 + u2) ** 2 * C.x + (v1 + v2) * C.y
+    assert Cm.acc(A) == check
+    Bm._vel_dict, Cm._vel_dict = Bm_vel_dict, Cm_vel_dict
+    Bm._acc_dict, Cm._acc_dict = Bm_acc_dict, Cm_acc_dict
+    Bm.v2pt_theory(Am, A, B)
+    Cm.v2pt_theory(Bm, A, C)
+    Bm.a2pt_theory(Am, A, B)
+    assert Cm.a2pt_theory(Bm, A, C) == check

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/vector/tests/test_printing.py

@@ -0,0 +1,353 @@
+# -*- coding: utf-8 -*-
+
+from sympy.core.function import Function
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (asin, cos, sin)
+from sympy.physics.vector import ReferenceFrame, dynamicsymbols, Dyadic
+from sympy.physics.vector.printing import (VectorLatexPrinter, vpprint,
+                                           vsprint, vsstrrepr, vlatex)
+
+
+a, b, c = symbols('a, b, c')
+alpha, omega, beta = dynamicsymbols('alpha, omega, beta')
+
+A = ReferenceFrame('A')
+N = ReferenceFrame('N')
+
+v = a ** 2 * N.x + b * N.y + c * sin(alpha) * N.z
+w = alpha * N.x + sin(omega) * N.y + alpha * beta * N.z
+ww = alpha * N.x + asin(omega) * N.y - alpha.diff() * beta * N.z
+o = a/b * N.x + (c+b)/a * N.y + c**2/b * N.z
+
+y = a ** 2 * (N.x | N.y) + b * (N.y | N.y) + c * sin(alpha) * (N.z | N.y)
+x = alpha * (N.x | N.x) + sin(omega) * (N.y | N.z) + alpha * beta * (N.z | N.x)
+xx = N.x | (-N.y - N.z)
+xx2 = N.x | (N.y + N.z)
+
+def ascii_vpretty(expr):
+    return vpprint(expr, use_unicode=False, wrap_line=False)
+
+
+def unicode_vpretty(expr):
+    return vpprint(expr, use_unicode=True, wrap_line=False)
+
+
+def test_latex_printer():
+    r = Function('r')('t')
+    assert VectorLatexPrinter().doprint(r ** 2) == "r^{2}"
+    r2 = Function('r^2')('t')
+    assert VectorLatexPrinter().doprint(r2.diff()) == r'\dot{r^{2}}'
+    ra = Function('r__a')('t')
+    assert VectorLatexPrinter().doprint(ra.diff().diff()) == r'\ddot{r^{a}}'
+
+
+def test_vector_pretty_print():
+
+    # TODO : The unit vectors should print with subscripts but they just
+    # print as `n_x` instead of making `x` a subscript with unicode.
+
+    # TODO : The pretty print division does not print correctly here:
+    # w = alpha * N.x + sin(omega) * N.y + alpha / beta * N.z
+
+    expected = """\
+ 2                               \n\
+a  n_x + b n_y + c*sin(alpha) n_z\
+"""
+    uexpected = """\
+ 2                           \n\
+a  n_x + b n_y + c⋅sin(α) n_z\
+"""
+
+    assert ascii_vpretty(v) == expected
+    assert unicode_vpretty(v) == uexpected
+
+    expected = 'alpha n_x + sin(omega) n_y + alpha*beta n_z'
+    uexpected = 'α n_x + sin(ω) n_y + α⋅β n_z'
+
+    assert ascii_vpretty(w) == expected
+    assert unicode_vpretty(w) == uexpected
+
+    expected = """\
+                     2    \n\
+a       b + c       c     \n\
+- n_x + ----- n_y + -- n_z\n\
+b         a         b     \
+"""
+    uexpected = """\
+                     2    \n\
+a       b + c       c     \n\
+─ n_x + ───── n_y + ── n_z\n\
+b         a         b     \
+"""
+
+    assert ascii_vpretty(o) == expected
+    assert unicode_vpretty(o) == uexpected
+
+    # https://github.com/sympy/sympy/issues/26731
+    assert ascii_vpretty(-A.x) == '-a_x'
+    assert unicode_vpretty(-A.x) == '-a_x'
+
+    # https://github.com/sympy/sympy/issues/26799
+    assert ascii_vpretty(0*A.x) == '0'
+    assert unicode_vpretty(0*A.x) == '0'
+
+
+def test_vector_latex():
+
+    a, b, c, d, omega = symbols('a, b, c, d, omega')
+
+    v = (a ** 2 + b / c) * A.x + sqrt(d) * A.y + cos(omega) * A.z
+
+    assert vlatex(v) == (r'(a^{2} + \frac{b}{c})\mathbf{\hat{a}_x} + '
+                         r'\sqrt{d}\mathbf{\hat{a}_y} + '
+                         r'\cos{\left(\omega \right)}'
+                         r'\mathbf{\hat{a}_z}')
+
+    theta, omega, alpha, q = dynamicsymbols('theta, omega, alpha, q')
+
+    v = theta * A.x + omega * omega * A.y + (q * alpha) * A.z
+
+    assert vlatex(v) == (r'\theta\mathbf{\hat{a}_x} + '
+                         r'\omega^{2}\mathbf{\hat{a}_y} + '
+                         r'\alpha q\mathbf{\hat{a}_z}')
+
+    phi1, phi2, phi3 = dynamicsymbols('phi1, phi2, phi3')
+    theta1, theta2, theta3 = symbols('theta1, theta2, theta3')
+
+    v = (sin(theta1) * A.x +
+         cos(phi1) * cos(phi2) * A.y +
+         cos(theta1 + phi3) * A.z)
+
+    assert vlatex(v) == (r'\sin{\left(\theta_{1} \right)}'
+                         r'\mathbf{\hat{a}_x} + \cos{'
+                         r'\left(\phi_{1} \right)} \cos{'
+                         r'\left(\phi_{2} \right)}\mathbf{\hat{a}_y} + '
+                         r'\cos{\left(\theta_{1} + '
+                         r'\phi_{3} \right)}\mathbf{\hat{a}_z}')
+
+    N = ReferenceFrame('N')
+
+    a, b, c, d, omega = symbols('a, b, c, d, omega')
+
+    v = (a ** 2 + b / c) * N.x + sqrt(d) * N.y + cos(omega) * N.z
+
+    expected = (r'(a^{2} + \frac{b}{c})\mathbf{\hat{n}_x} + '
+                r'\sqrt{d}\mathbf{\hat{n}_y} + '
+                r'\cos{\left(\omega \right)}'
+                r'\mathbf{\hat{n}_z}')
+
+    assert vlatex(v) == expected
+
+    # Try custom unit vectors.
+
+    N = ReferenceFrame('N', latexs=(r'\hat{i}', r'\hat{j}', r'\hat{k}'))
+
+    v = (a ** 2 + b / c) * N.x + sqrt(d) * N.y + cos(omega) * N.z
+
+    expected = (r'(a^{2} + \frac{b}{c})\hat{i} + '
+                r'\sqrt{d}\hat{j} + '
+                r'\cos{\left(\omega \right)}\hat{k}')
+    assert vlatex(v) == expected
+
+    expected = r'\alpha\mathbf{\hat{n}_x} + \operatorname{asin}{\left(\omega ' \
+        r'\right)}\mathbf{\hat{n}_y} -  \beta \dot{\alpha}\mathbf{\hat{n}_z}'
+    assert vlatex(ww) == expected
+
+    expected = r'- \mathbf{\hat{n}_x}\otimes \mathbf{\hat{n}_y} - ' \
+        r'\mathbf{\hat{n}_x}\otimes \mathbf{\hat{n}_z}'
+    assert vlatex(xx) == expected
+
+    expected = r'\mathbf{\hat{n}_x}\otimes \mathbf{\hat{n}_y} + ' \
+        r'\mathbf{\hat{n}_x}\otimes \mathbf{\hat{n}_z}'
+    assert vlatex(xx2) == expected
+
+
+def test_vector_latex_arguments():
+    assert vlatex(N.x * 3.0, full_prec=False) == r'3.0\mathbf{\hat{n}_x}'
+    assert vlatex(N.x * 3.0, full_prec=True) == r'3.00000000000000\mathbf{\hat{n}_x}'
+
+
+def test_vector_latex_with_functions():
+
+    N = ReferenceFrame('N')
+
+    omega, alpha = dynamicsymbols('omega, alpha')
+
+    v = omega.diff() * N.x
+
+    assert vlatex(v) == r'\dot{\omega}\mathbf{\hat{n}_x}'
+
+    v = omega.diff() ** alpha * N.x
+
+    assert vlatex(v) == (r'\dot{\omega}^{\alpha}'
+                          r'\mathbf{\hat{n}_x}')
+
+
+def test_dyadic_pretty_print():
+
+    expected = """\
+ 2
+a  n_x|n_y + b n_y|n_y + c*sin(alpha) n_z|n_y\
+"""
+
+    uexpected = """\
+ 2
+a  n_x⊗n_y + b n_y⊗n_y + c⋅sin(α) n_z⊗n_y\
+"""
+    assert ascii_vpretty(y) == expected
+    assert unicode_vpretty(y) == uexpected
+
+    expected = 'alpha n_x|n_x + sin(omega) n_y|n_z + alpha*beta n_z|n_x'
+    uexpected = 'α n_x⊗n_x + sin(ω) n_y⊗n_z + α⋅β n_z⊗n_x'
+    assert ascii_vpretty(x) == expected
+    assert unicode_vpretty(x) == uexpected
+
+    assert ascii_vpretty(Dyadic([])) == '0'
+    assert unicode_vpretty(Dyadic([])) == '0'
+
+    assert ascii_vpretty(xx) == '- n_x|n_y - n_x|n_z'
+    assert unicode_vpretty(xx) == '- n_x⊗n_y - n_x⊗n_z'
+
+    assert ascii_vpretty(xx2) == 'n_x|n_y + n_x|n_z'
+    assert unicode_vpretty(xx2) == 'n_x⊗n_y + n_x⊗n_z'
+
+
+def test_dyadic_latex():
+
+    expected = (r'a^{2}\mathbf{\hat{n}_x}\otimes \mathbf{\hat{n}_y} + '
+                r'b\mathbf{\hat{n}_y}\otimes \mathbf{\hat{n}_y} + '
+                r'c \sin{\left(\alpha \right)}'
+                r'\mathbf{\hat{n}_z}\otimes \mathbf{\hat{n}_y}')
+
+    assert vlatex(y) == expected
+
+    expected = (r'\alpha\mathbf{\hat{n}_x}\otimes \mathbf{\hat{n}_x} + '
+                r'\sin{\left(\omega \right)}\mathbf{\hat{n}_y}'
+                r'\otimes \mathbf{\hat{n}_z} + '
+                r'\alpha \beta\mathbf{\hat{n}_z}\otimes \mathbf{\hat{n}_x}')
+
+    assert vlatex(x) == expected
+
+    assert vlatex(Dyadic([])) == '0'
+
+
+def test_dyadic_str():
+    assert vsprint(Dyadic([])) == '0'
+    assert vsprint(y) == 'a**2*(N.x|N.y) + b*(N.y|N.y) + c*sin(alpha)*(N.z|N.y)'
+    assert vsprint(x) == 'alpha*(N.x|N.x) + sin(omega)*(N.y|N.z) + alpha*beta*(N.z|N.x)'
+    assert vsprint(ww) == "alpha*N.x + asin(omega)*N.y - beta*alpha'*N.z"
+    assert vsprint(xx) == '- (N.x|N.y) - (N.x|N.z)'
+    assert vsprint(xx2) == '(N.x|N.y) + (N.x|N.z)'
+
+
+def test_vlatex(): # vlatex is broken #12078
+    from sympy.physics.vector import vlatex
+
+    x = symbols('x')
+    J = symbols('J')
+
+    f = Function('f')
+    g = Function('g')
+    h = Function('h')
+
+    expected = r'J \left(\frac{d}{d x} g{\left(x \right)} - \frac{d}{d x} h{\left(x \right)}\right)'
+
+    expr = J*f(x).diff(x).subs(f(x), g(x)-h(x))
+
+    assert vlatex(expr) == expected
+
+
+def test_issue_13354():
+    """
+    Test for proper pretty printing of physics vectors with ADD
+    instances in arguments.
+
+    Test is exactly the one suggested in the original bug report by
+    @moorepants.
+    """
+
+    a, b, c = symbols('a, b, c')
+    A = ReferenceFrame('A')
+    v = a * A.x + b * A.y + c * A.z
+    w = b * A.x + c * A.y + a * A.z
+    z = w + v
+
+    expected = """(a + b) a_x + (b + c) a_y + (a + c) a_z"""
+
+    assert ascii_vpretty(z) == expected
+
+
+def test_vector_derivative_printing():
+    # First order
+    v = omega.diff() * N.x
+    assert unicode_vpretty(v) == 'ω̇ n_x'
+    assert ascii_vpretty(v) == "omega'(t) n_x"
+
+    # Second order
+    v = omega.diff().diff() * N.x
+
+    assert vlatex(v) == r'\ddot{\omega}\mathbf{\hat{n}_x}'
+    assert unicode_vpretty(v) == 'ω̈ n_x'
+    assert ascii_vpretty(v) == "omega''(t) n_x"
+
+    # Third order
+    v = omega.diff().diff().diff() * N.x
+
+    assert vlatex(v) == r'\dddot{\omega}\mathbf{\hat{n}_x}'
+    assert unicode_vpretty(v) == 'ω⃛ n_x'
+    assert ascii_vpretty(v) == "omega'''(t) n_x"
+
+    # Fourth order
+    v = omega.diff().diff().diff().diff() * N.x
+
+    assert vlatex(v) == r'\ddddot{\omega}\mathbf{\hat{n}_x}'
+    assert unicode_vpretty(v) == 'ω⃜ n_x'
+    assert ascii_vpretty(v) == "omega''''(t) n_x"
+
+    # Fifth order
+    v = omega.diff().diff().diff().diff().diff() * N.x
+
+    assert vlatex(v) == r'\frac{d^{5}}{d t^{5}} \omega\mathbf{\hat{n}_x}'
+    expected = '''\
+ 5            \n\
+d             \n\
+---(omega) n_x\n\
+  5           \n\
+dt            \
+'''
+    uexpected = '''\
+ 5        \n\
+d         \n\
+───(ω) n_x\n\
+  5       \n\
+dt        \
+'''
+    assert unicode_vpretty(v) == uexpected
+    assert ascii_vpretty(v) == expected
+
+
+def test_vector_str_printing():
+    assert vsprint(w) == 'alpha*N.x + sin(omega)*N.y + alpha*beta*N.z'
+    assert vsprint(omega.diff() * N.x) == "omega'*N.x"
+    assert vsstrrepr(w) == 'alpha*N.x + sin(omega)*N.y + alpha*beta*N.z'
+
+
+def test_vector_str_arguments():
+    assert vsprint(N.x * 3.0, full_prec=False) == '3.0*N.x'
+    assert vsprint(N.x * 3.0, full_prec=True) == '3.00000000000000*N.x'
+
+
+def test_issue_14041():
+    import sympy.physics.mechanics as me
+
+    A_frame = me.ReferenceFrame('A')
+    thetad, phid = me.dynamicsymbols('theta, phi', 1)
+    L = symbols('L')
+
+    assert vlatex(L*(phid + thetad)**2*A_frame.x) == \
+        r"L \left(\dot{\phi} + \dot{\theta}\right)^{2}\mathbf{\hat{a}_x}"
+    assert vlatex((phid + thetad)**2*A_frame.x) == \
+        r"\left(\dot{\phi} + \dot{\theta}\right)^{2}\mathbf{\hat{a}_x}"
+    assert vlatex((phid*thetad)**a*A_frame.x) == \
+        r"\left(\dot{\phi} \dot{\theta}\right)^{a}\mathbf{\hat{a}_x}"

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/vector/tests/test_vector.py

@@ -0,0 +1,274 @@
+from sympy.core.numbers import (Float, pi)
+from sympy.core.symbol import symbols
+from sympy.core.sorting import ordered
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.matrices.immutable import ImmutableDenseMatrix as Matrix
+from sympy.physics.vector import ReferenceFrame, Vector, dynamicsymbols, dot
+from sympy.physics.vector.vector import VectorTypeError
+from sympy.abc import x, y, z
+from sympy.testing.pytest import raises
+
+A = ReferenceFrame('A')
+
+
+def test_free_dynamicsymbols():
+    A, B, C, D = symbols('A, B, C, D', cls=ReferenceFrame)
+    a, b, c, d, e, f = dynamicsymbols('a, b, c, d, e, f')
+    B.orient_axis(A, a, A.x)
+    C.orient_axis(B, b, B.y)
+    D.orient_axis(C, c, C.x)
+
+    v = d*D.x + e*D.y + f*D.z
+
+    assert set(ordered(v.free_dynamicsymbols(A))) == {a, b, c, d, e, f}
+    assert set(ordered(v.free_dynamicsymbols(B))) == {b, c, d, e, f}
+    assert set(ordered(v.free_dynamicsymbols(C))) == {c, d, e, f}
+    assert set(ordered(v.free_dynamicsymbols(D))) == {d, e, f}
+
+
+def test_Vector():
+    assert A.x != A.y
+    assert A.y != A.z
+    assert A.z != A.x
+
+    assert A.x + 0 == A.x
+
+    v1 = x*A.x + y*A.y + z*A.z
+    v2 = x**2*A.x + y**2*A.y + z**2*A.z
+    v3 = v1 + v2
+    v4 = v1 - v2
+
+    assert isinstance(v1, Vector)
+    assert dot(v1, A.x) == x
+    assert dot(v1, A.y) == y
+    assert dot(v1, A.z) == z
+
+    assert isinstance(v2, Vector)
+    assert dot(v2, A.x) == x**2
+    assert dot(v2, A.y) == y**2
+    assert dot(v2, A.z) == z**2
+
+    assert isinstance(v3, Vector)
+    # We probably shouldn't be using simplify in dot...
+    assert dot(v3, A.x) == x**2 + x
+    assert dot(v3, A.y) == y**2 + y
+    assert dot(v3, A.z) == z**2 + z
+
+    assert isinstance(v4, Vector)
+    # We probably shouldn't be using simplify in dot...
+    assert dot(v4, A.x) == x - x**2
+    assert dot(v4, A.y) == y - y**2
+    assert dot(v4, A.z) == z - z**2
+
+    assert v1.to_matrix(A) == Matrix([[x], [y], [z]])
+    q = symbols('q')
+    B = A.orientnew('B', 'Axis', (q, A.x))
+    assert v1.to_matrix(B) == Matrix([[x],
+                                      [ y * cos(q) + z * sin(q)],
+                                      [-y * sin(q) + z * cos(q)]])
+
+    #Test the separate method
+    B = ReferenceFrame('B')
+    v5 = x*A.x + y*A.y + z*B.z
+    assert Vector(0).separate() == {}
+    assert v1.separate() == {A: v1}
+    assert v5.separate() == {A: x*A.x + y*A.y, B: z*B.z}
+
+    #Test the free_symbols property
+    v6 = x*A.x + y*A.y + z*A.z
+    assert v6.free_symbols(A) == {x,y,z}
+
+    raises(TypeError, lambda: v3.applyfunc(v1))
+
+
+def test_Vector_diffs():
+    q1, q2, q3, q4 = dynamicsymbols('q1 q2 q3 q4')
+    q1d, q2d, q3d, q4d = dynamicsymbols('q1 q2 q3 q4', 1)
+    q1dd, q2dd, q3dd, q4dd = dynamicsymbols('q1 q2 q3 q4', 2)
+    N = ReferenceFrame('N')
+    A = N.orientnew('A', 'Axis', [q3, N.z])
+    B = A.orientnew('B', 'Axis', [q2, A.x])
+    v1 = q2 * A.x + q3 * N.y
+    v2 = q3 * B.x + v1
+    v3 = v1.dt(B)
+    v4 = v2.dt(B)
+    v5 = q1*A.x + q2*A.y + q3*A.z
+
+    assert v1.dt(N) == q2d * A.x + q2 * q3d * A.y + q3d * N.y
+    assert v1.dt(A) == q2d * A.x + q3 * q3d * N.x + q3d * N.y
+    assert v1.dt(B) == (q2d * A.x + q3 * q3d * N.x + q3d *
+                        N.y - q3 * cos(q3) * q2d * N.z)
+    assert v2.dt(N) == (q2d * A.x + (q2 + q3) * q3d * A.y + q3d * B.x + q3d *
+                        N.y)
+    assert v2.dt(A) == q2d * A.x + q3d * B.x + q3 * q3d * N.x + q3d * N.y
+    assert v2.dt(B) == (q2d * A.x + q3d * B.x + q3 * q3d * N.x + q3d * N.y -
+                        q3 * cos(q3) * q2d * N.z)
+    assert v3.dt(N) == (q2dd * A.x + q2d * q3d * A.y + (q3d**2 + q3 * q3dd) *
+                        N.x + q3dd * N.y + (q3 * sin(q3) * q2d * q3d -
+                        cos(q3) * q2d * q3d - q3 * cos(q3) * q2dd) * N.z)
+    assert v3.dt(A) == (q2dd * A.x + (2 * q3d**2 + q3 * q3dd) * N.x + (q3dd -
+                        q3 * q3d**2) * N.y + (q3 * sin(q3) * q2d * q3d -
+                        cos(q3) * q2d * q3d - q3 * cos(q3) * q2dd) * N.z)
+    assert (v3.dt(B) - (q2dd*A.x - q3*cos(q3)*q2d**2*A.y + (2*q3d**2 +
+        q3*q3dd)*N.x + (q3dd - q3*q3d**2)*N.y + (2*q3*sin(q3)*q2d*q3d -
+        2*cos(q3)*q2d*q3d - q3*cos(q3)*q2dd)*N.z)).express(B).simplify() == 0
+    assert v4.dt(N) == (q2dd * A.x + q3d * (q2d + q3d) * A.y + q3dd * B.x +
+                        (q3d**2 + q3 * q3dd) * N.x + q3dd * N.y + (q3 *
+                        sin(q3) * q2d * q3d - cos(q3) * q2d * q3d - q3 *
+                        cos(q3) * q2dd) * N.z)
+    assert v4.dt(A) == (q2dd * A.x + q3dd * B.x + (2 * q3d**2 + q3 * q3dd) *
+                        N.x + (q3dd - q3 * q3d**2) * N.y + (q3 * sin(q3) *
+                        q2d * q3d - cos(q3) * q2d * q3d - q3 * cos(q3) *
+                        q2dd) * N.z)
+    assert (v4.dt(B) - (q2dd*A.x - q3*cos(q3)*q2d**2*A.y + q3dd*B.x +
+                        (2*q3d**2 + q3*q3dd)*N.x + (q3dd - q3*q3d**2)*N.y +
+                        (2*q3*sin(q3)*q2d*q3d - 2*cos(q3)*q2d*q3d -
+                         q3*cos(q3)*q2dd)*N.z)).express(B).simplify() == 0
+    assert v5.dt(B) == q1d*A.x + (q3*q2d + q2d)*A.y + (-q2*q2d + q3d)*A.z
+    assert v5.dt(A) == q1d*A.x + q2d*A.y + q3d*A.z
+    assert v5.dt(N) == (-q2*q3d + q1d)*A.x + (q1*q3d + q2d)*A.y + q3d*A.z
+    assert v3.diff(q1d, N) == 0
+    assert v3.diff(q2d, N) == A.x - q3 * cos(q3) * N.z
+    assert v3.diff(q3d, N) == q3 * N.x + N.y
+    assert v3.diff(q1d, A) == 0
+    assert v3.diff(q2d, A) == A.x - q3 * cos(q3) * N.z
+    assert v3.diff(q3d, A) == q3 * N.x + N.y
+    assert v3.diff(q1d, B) == 0
+    assert v3.diff(q2d, B) == A.x - q3 * cos(q3) * N.z
+    assert v3.diff(q3d, B) == q3 * N.x + N.y
+    assert v4.diff(q1d, N) == 0
+    assert v4.diff(q2d, N) == A.x - q3 * cos(q3) * N.z
+    assert v4.diff(q3d, N) == B.x + q3 * N.x + N.y
+    assert v4.diff(q1d, A) == 0
+    assert v4.diff(q2d, A) == A.x - q3 * cos(q3) * N.z
+    assert v4.diff(q3d, A) == B.x + q3 * N.x + N.y
+    assert v4.diff(q1d, B) == 0
+    assert v4.diff(q2d, B) == A.x - q3 * cos(q3) * N.z
+    assert v4.diff(q3d, B) == B.x + q3 * N.x + N.y
+
+    # diff() should only express vector components in the derivative frame if
+    # the orientation of the component's frame depends on the variable
+    v6 = q2**2*N.y + q2**2*A.y + q2**2*B.y
+    # already expressed in N
+    n_measy = 2*q2
+    # A_C_N does not depend on q2, so don't express in N
+    a_measy = 2*q2
+    # B_C_N depends on q2, so express in N
+    b_measx = (q2**2*B.y).dot(N.x).diff(q2)
+    b_measy = (q2**2*B.y).dot(N.y).diff(q2)
+    b_measz = (q2**2*B.y).dot(N.z).diff(q2)
+    n_comp, a_comp = v6.diff(q2, N).args
+    assert len(v6.diff(q2, N).args) == 2  # only N and A parts
+    assert n_comp[1] == N
+    assert a_comp[1] == A
+    assert n_comp[0] == Matrix([b_measx, b_measy + n_measy, b_measz])
+    assert a_comp[0] == Matrix([0, a_measy, 0])
+
+
+def test_vector_var_in_dcm():
+
+    N = ReferenceFrame('N')
+    A = ReferenceFrame('A')
+    B = ReferenceFrame('B')
+    u1, u2, u3, u4 = dynamicsymbols('u1 u2 u3 u4')
+
+    v = u1 * u2 * A.x + u3 * N.y + u4**2 * N.z
+
+    assert v.diff(u1, N, var_in_dcm=False) == u2 * A.x
+    assert v.diff(u1, A, var_in_dcm=False) == u2 * A.x
+    assert v.diff(u3, N, var_in_dcm=False) == N.y
+    assert v.diff(u3, A, var_in_dcm=False) == N.y
+    assert v.diff(u3, B, var_in_dcm=False) == N.y
+    assert v.diff(u4, N, var_in_dcm=False) == 2 * u4 * N.z
+
+    raises(ValueError, lambda: v.diff(u1, N))
+
+
+def test_vector_simplify():
+    x, y, z, k, n, m, w, f, s, A = symbols('x, y, z, k, n, m, w, f, s, A')
+    N = ReferenceFrame('N')
+
+    test1 = (1 / x + 1 / y) * N.x
+    assert (test1 & N.x) != (x + y) / (x * y)
+    test1 = test1.simplify()
+    assert (test1 & N.x) == (x + y) / (x * y)
+
+    test2 = (A**2 * s**4 / (4 * pi * k * m**3)) * N.x
+    test2 = test2.simplify()
+    assert (test2 & N.x) == (A**2 * s**4 / (4 * pi * k * m**3))
+
+    test3 = ((4 + 4 * x - 2 * (2 + 2 * x)) / (2 + 2 * x)) * N.x
+    test3 = test3.simplify()
+    assert (test3 & N.x) == 0
+
+    test4 = ((-4 * x * y**2 - 2 * y**3 - 2 * x**2 * y) / (x + y)**2) * N.x
+    test4 = test4.simplify()
+    assert (test4 & N.x) == -2 * y
+
+
+def test_vector_evalf():
+    a, b = symbols('a b')
+    v = pi * A.x
+    assert v.evalf(2) == Float('3.1416', 2) * A.x
+    v = pi * A.x + 5 * a * A.y - b * A.z
+    assert v.evalf(3) == Float('3.1416', 3) * A.x + Float('5', 3) * a * A.y - b * A.z
+    assert v.evalf(5, subs={a: 1.234, b:5.8973}) == Float('3.1415926536', 5) * A.x + Float('6.17', 5) * A.y - Float('5.8973', 5) * A.z
+
+
+def test_vector_angle():
+    A = ReferenceFrame('A')
+    v1 = A.x + A.y
+    v2 = A.z
+    assert v1.angle_between(v2) == pi/2
+    B = ReferenceFrame('B')
+    B.orient_axis(A, A.x, pi)
+    v3 = A.x
+    v4 = B.x
+    assert v3.angle_between(v4) == 0
+
+
+def test_vector_xreplace():
+    x, y, z = symbols('x y z')
+    v = x**2 * A.x + x*y * A.y + x*y*z * A.z
+    assert v.xreplace({x : cos(x)}) == cos(x)**2 * A.x + y*cos(x) * A.y + y*z*cos(x) * A.z
+    assert v.xreplace({x*y : pi}) == x**2 * A.x + pi * A.y + x*y*z * A.z
+    assert v.xreplace({x*y*z : 1}) == x**2*A.x + x*y*A.y + A.z
+    assert v.xreplace({x:1, z:0}) == A.x + y * A.y
+    raises(TypeError, lambda: v.xreplace())
+    raises(TypeError, lambda: v.xreplace([x, y]))
+
+def test_issue_23366():
+    u1 = dynamicsymbols('u1')
+    N = ReferenceFrame('N')
+    N_v_A = u1*N.x
+    raises(VectorTypeError, lambda: N_v_A.diff(N, u1))
+
+
+def test_vector_outer():
+    a, b, c, d, e, f = symbols('a, b, c, d, e, f')
+    N = ReferenceFrame('N')
+    v1 = a*N.x + b*N.y + c*N.z
+    v2 = d*N.x + e*N.y + f*N.z
+    v1v2 = Matrix([[a*d, a*e, a*f],
+                   [b*d, b*e, b*f],
+                   [c*d, c*e, c*f]])
+    assert v1.outer(v2).to_matrix(N) == v1v2
+    assert (v1 | v2).to_matrix(N) == v1v2
+    v2v1 = Matrix([[d*a, d*b, d*c],
+                   [e*a, e*b, e*c],
+                   [f*a, f*b, f*c]])
+    assert v2.outer(v1).to_matrix(N) == v2v1
+    assert (v2 | v1).to_matrix(N) == v2v1
+
+
+def test_overloaded_operators():
+    a, b, c, d, e, f = symbols('a, b, c, d, e, f')
+    N = ReferenceFrame('N')
+    v1 = a*N.x + b*N.y + c*N.z
+    v2 = d*N.x + e*N.y + f*N.z
+
+    assert v1 + v2 == v2 + v1
+    assert v1 - v2 == -v2 + v1
+    assert v1 & v2 == v2 & v1
+    assert v1 ^ v2 == v1.cross(v2)
+    assert v2 ^ v1 == v2.cross(v1)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/physics/vector/vector.py

@@ -0,0 +1,806 @@
+from sympy import (S, sympify, expand, sqrt, Add, zeros, acos,
+                   ImmutableMatrix as Matrix, simplify)
+from sympy.simplify.trigsimp import trigsimp
+from sympy.printing.defaults import Printable
+from sympy.utilities.misc import filldedent
+from sympy.core.evalf import EvalfMixin
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+__all__ = ['Vector']
+
+
+class Vector(Printable, EvalfMixin):
+    """The class used to define vectors.
+
+    It along with ReferenceFrame are the building blocks of describing a
+    classical mechanics system in PyDy and sympy.physics.vector.
+
+    Attributes
+    ==========
+
+    simp : Boolean
+        Let certain methods use trigsimp on their outputs
+
+    """
+
+    simp = False
+    is_number = False
+
+    def __init__(self, inlist):
+        """This is the constructor for the Vector class. You should not be
+        calling this, it should only be used by other functions. You should be
+        treating Vectors like you would with if you were doing the math by
+        hand, and getting the first 3 from the standard basis vectors from a
+        ReferenceFrame.
+
+        The only exception is to create a zero vector:
+        zv = Vector(0)
+
+        """
+
+        self.args = []
+        if inlist == 0:
+            inlist = []
+        if isinstance(inlist, dict):
+            d = inlist
+        else:
+            d = {}
+            for inp in inlist:
+                if inp[1] in d:
+                    d[inp[1]] += inp[0]
+                else:
+                    d[inp[1]] = inp[0]
+
+        for k, v in d.items():
+            if v != Matrix([0, 0, 0]):
+                self.args.append((v, k))
+
+    @property
+    def func(self):
+        """Returns the class Vector. """
+        return Vector
+
+    def __hash__(self):
+        return hash(tuple(self.args))
+
+    def __add__(self, other):
+        """The add operator for Vector. """
+        if other == 0:
+            return self
+        other = _check_vector(other)
+        return Vector(self.args + other.args)
+
+    def dot(self, other):
+        """Dot product of two vectors.
+
+        Returns a scalar, the dot product of the two Vectors
+
+        Parameters
+        ==========
+
+        other : Vector
+            The Vector which we are dotting with
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, dot
+        >>> from sympy import symbols
+        >>> q1 = symbols('q1')
+        >>> N = ReferenceFrame('N')
+        >>> dot(N.x, N.x)
+        1
+        >>> dot(N.x, N.y)
+        0
+        >>> A = N.orientnew('A', 'Axis', [q1, N.x])
+        >>> dot(N.y, A.y)
+        cos(q1)
+
+        """
+
+        from sympy.physics.vector.dyadic import Dyadic, _check_dyadic
+        if isinstance(other, Dyadic):
+            other = _check_dyadic(other)
+            ol = Vector(0)
+            for v in other.args:
+                ol += v[0] * v[2] * (v[1].dot(self))
+            return ol
+        other = _check_vector(other)
+        out = S.Zero
+        for v1 in self.args:
+            for v2 in other.args:
+                out += ((v2[0].T) * (v2[1].dcm(v1[1])) * (v1[0]))[0]
+        if Vector.simp:
+            return trigsimp(out, recursive=True)
+        else:
+            return out
+
+    def __truediv__(self, other):
+        """This uses mul and inputs self and 1 divided by other. """
+        return self.__mul__(S.One / other)
+
+    def __eq__(self, other):
+        """Tests for equality.
+
+        It is very import to note that this is only as good as the SymPy
+        equality test; False does not always mean they are not equivalent
+        Vectors.
+        If other is 0, and self is empty, returns True.
+        If other is 0 and self is not empty, returns False.
+        If none of the above, only accepts other as a Vector.
+
+        """
+
+        if other == 0:
+            other = Vector(0)
+        try:
+            other = _check_vector(other)
+        except TypeError:
+            return False
+        if (self.args == []) and (other.args == []):
+            return True
+        elif (self.args == []) or (other.args == []):
+            return False
+
+        frame = self.args[0][1]
+        for v in frame:
+            if expand((self - other).dot(v)) != 0:
+                return False
+        return True
+
+    def __mul__(self, other):
+        """Multiplies the Vector by a sympifyable expression.
+
+        Parameters
+        ==========
+
+        other : Sympifyable
+            The scalar to multiply this Vector with
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> from sympy import Symbol
+        >>> N = ReferenceFrame('N')
+        >>> b = Symbol('b')
+        >>> V = 10 * b * N.x
+        >>> print(V)
+        10*b*N.x
+
+        """
+
+        newlist = list(self.args)
+        other = sympify(other)
+        for i in range(len(newlist)):
+            newlist[i] = (other * newlist[i][0], newlist[i][1])
+        return Vector(newlist)
+
+    def __neg__(self):
+        return self * -1
+
+    def outer(self, other):
+        """Outer product between two Vectors.
+
+        A rank increasing operation, which returns a Dyadic from two Vectors
+
+        Parameters
+        ==========
+
+        other : Vector
+            The Vector to take the outer product with
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, outer
+        >>> N = ReferenceFrame('N')
+        >>> outer(N.x, N.x)
+        (N.x|N.x)
+
+        """
+
+        from sympy.physics.vector.dyadic import Dyadic
+        other = _check_vector(other)
+        ol = Dyadic(0)
+        for v in self.args:
+            for v2 in other.args:
+                # it looks this way because if we are in the same frame and
+                # use the enumerate function on the same frame in a nested
+                # fashion, then bad things happen
+                ol += Dyadic([(v[0][0] * v2[0][0], v[1].x, v2[1].x)])
+                ol += Dyadic([(v[0][0] * v2[0][1], v[1].x, v2[1].y)])
+                ol += Dyadic([(v[0][0] * v2[0][2], v[1].x, v2[1].z)])
+                ol += Dyadic([(v[0][1] * v2[0][0], v[1].y, v2[1].x)])
+                ol += Dyadic([(v[0][1] * v2[0][1], v[1].y, v2[1].y)])
+                ol += Dyadic([(v[0][1] * v2[0][2], v[1].y, v2[1].z)])
+                ol += Dyadic([(v[0][2] * v2[0][0], v[1].z, v2[1].x)])
+                ol += Dyadic([(v[0][2] * v2[0][1], v[1].z, v2[1].y)])
+                ol += Dyadic([(v[0][2] * v2[0][2], v[1].z, v2[1].z)])
+        return ol
+
+    def _latex(self, printer):
+        """Latex Printing method. """
+
+        ar = self.args  # just to shorten things
+        if len(ar) == 0:
+            return str(0)
+        ol = []  # output list, to be concatenated to a string
+        for v in ar:
+            for j in 0, 1, 2:
+                # if the coef of the basis vector is 1, we skip the 1
+                if v[0][j] == 1:
+                    ol.append(' + ' + v[1].latex_vecs[j])
+                # if the coef of the basis vector is -1, we skip the 1
+                elif v[0][j] == -1:
+                    ol.append(' - ' + v[1].latex_vecs[j])
+                elif v[0][j] != 0:
+                    # If the coefficient of the basis vector is not 1 or -1;
+                    # also, we might wrap it in parentheses, for readability.
+                    arg_str = printer._print(v[0][j])
+                    if isinstance(v[0][j], Add):
+                        arg_str = "(%s)" % arg_str
+                    if arg_str[0] == '-':
+                        arg_str = arg_str[1:]
+                        str_start = ' - '
+                    else:
+                        str_start = ' + '
+                    ol.append(str_start + arg_str + v[1].latex_vecs[j])
+        outstr = ''.join(ol)
+        if outstr.startswith(' + '):
+            outstr = outstr[3:]
+        elif outstr.startswith(' '):
+            outstr = outstr[1:]
+        return outstr
+
+    def _pretty(self, printer):
+        """Pretty Printing method. """
+        from sympy.printing.pretty.stringpict import prettyForm
+
+        terms = []
+
+        def juxtapose(a, b):
+            pa = printer._print(a)
+            pb = printer._print(b)
+            if a.is_Add:
+                pa = prettyForm(*pa.parens())
+            return printer._print_seq([pa, pb], delimiter=' ')
+
+        for M, N in self.args:
+            for i in range(3):
+                if M[i] == 0:
+                    continue
+                elif M[i] == 1:
+                    terms.append(prettyForm(N.pretty_vecs[i]))
+                elif M[i] == -1:
+                    terms.append(prettyForm("-1") * prettyForm(N.pretty_vecs[i]))
+                else:
+                    terms.append(juxtapose(M[i], N.pretty_vecs[i]))
+
+        if terms:
+            pretty_result = prettyForm.__add__(*terms)
+        else:
+            pretty_result = prettyForm("0")
+
+        return pretty_result
+
+    def __rsub__(self, other):
+        return (-1 * self) + other
+
+    def _sympystr(self, printer, order=True):
+        """Printing method. """
+        if not order or len(self.args) == 1:
+            ar = list(self.args)
+        elif len(self.args) == 0:
+            return printer._print(0)
+        else:
+            d = {v[1]: v[0] for v in self.args}
+            keys = sorted(d.keys(), key=lambda x: x.index)
+            ar = []
+            for key in keys:
+                ar.append((d[key], key))
+        ol = []  # output list, to be concatenated to a string
+        for v in ar:
+            for j in 0, 1, 2:
+                # if the coef of the basis vector is 1, we skip the 1
+                if v[0][j] == 1:
+                    ol.append(' + ' + v[1].str_vecs[j])
+                # if the coef of the basis vector is -1, we skip the 1
+                elif v[0][j] == -1:
+                    ol.append(' - ' + v[1].str_vecs[j])
+                elif v[0][j] != 0:
+                    # If the coefficient of the basis vector is not 1 or -1;
+                    # also, we might wrap it in parentheses, for readability.
+                    arg_str = printer._print(v[0][j])
+                    if isinstance(v[0][j], Add):
+                        arg_str = "(%s)" % arg_str
+                    if arg_str[0] == '-':
+                        arg_str = arg_str[1:]
+                        str_start = ' - '
+                    else:
+                        str_start = ' + '
+                    ol.append(str_start + arg_str + '*' + v[1].str_vecs[j])
+        outstr = ''.join(ol)
+        if outstr.startswith(' + '):
+            outstr = outstr[3:]
+        elif outstr.startswith(' '):
+            outstr = outstr[1:]
+        return outstr
+
+    def __sub__(self, other):
+        """The subtraction operator. """
+        return self.__add__(other * -1)
+
+    def cross(self, other):
+        """The cross product operator for two Vectors.
+
+        Returns a Vector, expressed in the same ReferenceFrames as self.
+
+        Parameters
+        ==========
+
+        other : Vector
+            The Vector which we are crossing with
+
+        Examples
+        ========
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.vector import ReferenceFrame, cross
+        >>> q1 = symbols('q1')
+        >>> N = ReferenceFrame('N')
+        >>> cross(N.x, N.y)
+        N.z
+        >>> A = ReferenceFrame('A')
+        >>> A.orient_axis(N, q1, N.x)
+        >>> cross(A.x, N.y)
+        N.z
+        >>> cross(N.y, A.x)
+        - sin(q1)*A.y - cos(q1)*A.z
+
+        """
+
+        from sympy.physics.vector.dyadic import Dyadic, _check_dyadic
+        if isinstance(other, Dyadic):
+            other = _check_dyadic(other)
+            ol = Dyadic(0)
+            for i, v in enumerate(other.args):
+                ol += v[0] * ((self.cross(v[1])).outer(v[2]))
+            return ol
+        other = _check_vector(other)
+        if other.args == []:
+            return Vector(0)
+
+        def _det(mat):
+            """This is needed as a little method for to find the determinant
+            of a list in python; needs to work for a 3x3 list.
+            SymPy's Matrix will not take in Vector, so need a custom function.
+            You should not be calling this.
+
+            """
+
+            return (mat[0][0] * (mat[1][1] * mat[2][2] - mat[1][2] * mat[2][1])
+                    + mat[0][1] * (mat[1][2] * mat[2][0] - mat[1][0] *
+                    mat[2][2]) + mat[0][2] * (mat[1][0] * mat[2][1] -
+                    mat[1][1] * mat[2][0]))
+
+        outlist = []
+        ar = other.args  # For brevity
+        for v in ar:
+            tempx = v[1].x
+            tempy = v[1].y
+            tempz = v[1].z
+            tempm = ([[tempx, tempy, tempz],
+                      [self.dot(tempx), self.dot(tempy), self.dot(tempz)],
+                      [Vector([v]).dot(tempx), Vector([v]).dot(tempy),
+                       Vector([v]).dot(tempz)]])
+            outlist += _det(tempm).args
+        return Vector(outlist)
+
+    __radd__ = __add__
+    __rmul__ = __mul__
+
+    def separate(self):
+        """
+        The constituents of this vector in different reference frames,
+        as per its definition.
+
+        Returns a dict mapping each ReferenceFrame to the corresponding
+        constituent Vector.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> R1 = ReferenceFrame('R1')
+        >>> R2 = ReferenceFrame('R2')
+        >>> v = R1.x + R2.x
+        >>> v.separate() == {R1: R1.x, R2: R2.x}
+        True
+
+        """
+
+        components = {}
+        for x in self.args:
+            components[x[1]] = Vector([x])
+        return components
+
+    def __and__(self, other):
+        return self.dot(other)
+    __and__.__doc__ = dot.__doc__
+    __rand__ = __and__
+
+    def __xor__(self, other):
+        return self.cross(other)
+    __xor__.__doc__ = cross.__doc__
+
+    def __or__(self, other):
+        return self.outer(other)
+    __or__.__doc__ = outer.__doc__
+
+    def diff(self, var, frame, var_in_dcm=True):
+        """Returns the partial derivative of the vector with respect to a
+        variable in the provided reference frame.
+
+        Parameters
+        ==========
+        var : Symbol
+            What the partial derivative is taken with respect to.
+        frame : ReferenceFrame
+            The reference frame that the partial derivative is taken in.
+        var_in_dcm : boolean
+            If true, the differentiation algorithm assumes that the variable
+            may be present in any of the direction cosine matrices that relate
+            the frame to the frames of any component of the vector. But if it
+            is known that the variable is not present in the direction cosine
+            matrices, false can be set to skip full reexpression in the desired
+            frame.
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol
+        >>> from sympy.physics.vector import dynamicsymbols, ReferenceFrame
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> t = Symbol('t')
+        >>> q1 = dynamicsymbols('q1')
+        >>> N = ReferenceFrame('N')
+        >>> A = N.orientnew('A', 'Axis', [q1, N.y])
+        >>> A.x.diff(t, N)
+        - sin(q1)*q1'*N.x - cos(q1)*q1'*N.z
+        >>> A.x.diff(t, N).express(A).simplify()
+        - q1'*A.z
+        >>> B = ReferenceFrame('B')
+        >>> u1, u2 = dynamicsymbols('u1, u2')
+        >>> v = u1 * A.x + u2 * B.y
+        >>> v.diff(u2, N, var_in_dcm=False)
+        B.y
+
+        """
+
+        from sympy.physics.vector.frame import _check_frame
+
+        _check_frame(frame)
+        var = sympify(var)
+
+        inlist = []
+
+        for vector_component in self.args:
+            measure_number = vector_component[0]
+            component_frame = vector_component[1]
+            if component_frame == frame:
+                inlist += [(measure_number.diff(var), frame)]
+            else:
+                # If the direction cosine matrix relating the component frame
+                # with the derivative frame does not contain the variable.
+                if not var_in_dcm or (frame.dcm(component_frame).diff(var) ==
+                                      zeros(3, 3)):
+                    inlist += [(measure_number.diff(var), component_frame)]
+                else:  # else express in the frame
+                    reexp_vec_comp = Vector([vector_component]).express(frame)
+                    deriv = reexp_vec_comp.args[0][0].diff(var)
+                    inlist += Vector([(deriv, frame)]).args
+
+        return Vector(inlist)
+
+    def express(self, otherframe, variables=False):
+        """
+        Returns a Vector equivalent to this one, expressed in otherframe.
+        Uses the global express method.
+
+        Parameters
+        ==========
+
+        otherframe : ReferenceFrame
+            The frame for this Vector to be described in
+
+        variables : boolean
+            If True, the coordinate symbols(if present) in this Vector
+            are re-expressed in terms otherframe
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame, dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> q1 = dynamicsymbols('q1')
+        >>> N = ReferenceFrame('N')
+        >>> A = N.orientnew('A', 'Axis', [q1, N.y])
+        >>> A.x.express(N)
+        cos(q1)*N.x - sin(q1)*N.z
+
+        """
+        from sympy.physics.vector import express
+        return express(self, otherframe, variables=variables)
+
+    def to_matrix(self, reference_frame):
+        """Returns the matrix form of the vector with respect to the given
+        frame.
+
+        Parameters
+        ----------
+        reference_frame : ReferenceFrame
+            The reference frame that the rows of the matrix correspond to.
+
+        Returns
+        -------
+        matrix : ImmutableMatrix, shape(3,1)
+            The matrix that gives the 1D vector.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> a, b, c = symbols('a, b, c')
+        >>> N = ReferenceFrame('N')
+        >>> vector = a * N.x + b * N.y + c * N.z
+        >>> vector.to_matrix(N)
+        Matrix([
+        [a],
+        [b],
+        [c]])
+        >>> beta = symbols('beta')
+        >>> A = N.orientnew('A', 'Axis', (beta, N.x))
+        >>> vector.to_matrix(A)
+        Matrix([
+        [                         a],
+        [ b*cos(beta) + c*sin(beta)],
+        [-b*sin(beta) + c*cos(beta)]])
+
+        """
+
+        return Matrix([self.dot(unit_vec) for unit_vec in
+                       reference_frame]).reshape(3, 1)
+
+    def doit(self, **hints):
+        """Calls .doit() on each term in the Vector"""
+        d = {}
+        for v in self.args:
+            d[v[1]] = v[0].applyfunc(lambda x: x.doit(**hints))
+        return Vector(d)
+
+    def dt(self, otherframe):
+        """
+        Returns a Vector which is the time derivative of
+        the self Vector, taken in frame otherframe.
+
+        Calls the global time_derivative method
+
+        Parameters
+        ==========
+
+        otherframe : ReferenceFrame
+            The frame to calculate the time derivative in
+
+        """
+        from sympy.physics.vector import time_derivative
+        return time_derivative(self, otherframe)
+
+    def simplify(self):
+        """Returns a simplified Vector."""
+        d = {}
+        for v in self.args:
+            d[v[1]] = simplify(v[0])
+        return Vector(d)
+
+    def subs(self, *args, **kwargs):
+        """Substitution on the Vector.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> from sympy import Symbol
+        >>> N = ReferenceFrame('N')
+        >>> s = Symbol('s')
+        >>> a = N.x * s
+        >>> a.subs({s: 2})
+        2*N.x
+
+        """
+
+        d = {}
+        for v in self.args:
+            d[v[1]] = v[0].subs(*args, **kwargs)
+        return Vector(d)
+
+    def magnitude(self):
+        """Returns the magnitude (Euclidean norm) of self.
+
+        Warnings
+        ========
+
+        Python ignores the leading negative sign so that might
+        give wrong results.
+        ``-A.x.magnitude()`` would be treated as ``-(A.x.magnitude())``,
+        instead of ``(-A.x).magnitude()``.
+
+        """
+        return sqrt(self.dot(self))
+
+    def normalize(self):
+        """Returns a Vector of magnitude 1, codirectional with self."""
+        return Vector(self.args + []) / self.magnitude()
+
+    def applyfunc(self, f):
+        """Apply a function to each component of a vector."""
+        if not callable(f):
+            raise TypeError("`f` must be callable.")
+
+        d = {}
+        for v in self.args:
+            d[v[1]] = v[0].applyfunc(f)
+        return Vector(d)
+
+    def angle_between(self, vec):
+        """
+        Returns the smallest angle between Vector 'vec' and self.
+
+        Parameter
+        =========
+
+        vec : Vector
+            The Vector between which angle is needed.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> A = ReferenceFrame("A")
+        >>> v1 = A.x
+        >>> v2 = A.y
+        >>> v1.angle_between(v2)
+        pi/2
+
+        >>> v3 = A.x + A.y + A.z
+        >>> v1.angle_between(v3)
+        acos(sqrt(3)/3)
+
+        Warnings
+        ========
+
+        Python ignores the leading negative sign so that might give wrong
+        results. ``-A.x.angle_between()`` would be treated as
+        ``-(A.x.angle_between())``, instead of ``(-A.x).angle_between()``.
+
+        """
+
+        vec1 = self.normalize()
+        vec2 = vec.normalize()
+        angle = acos(vec1.dot(vec2))
+        return angle
+
+    def free_symbols(self, reference_frame):
+        """Returns the free symbols in the measure numbers of the vector
+        expressed in the given reference frame.
+
+        Parameters
+        ==========
+        reference_frame : ReferenceFrame
+            The frame with respect to which the free symbols of the given
+            vector is to be determined.
+
+        Returns
+        =======
+        set of Symbol
+            set of symbols present in the measure numbers of
+            ``reference_frame``.
+
+        """
+
+        return self.to_matrix(reference_frame).free_symbols
+
+    def free_dynamicsymbols(self, reference_frame):
+        """Returns the free dynamic symbols (functions of time ``t``) in the
+        measure numbers of the vector expressed in the given reference frame.
+
+        Parameters
+        ==========
+        reference_frame : ReferenceFrame
+            The frame with respect to which the free dynamic symbols of the
+            given vector is to be determined.
+
+        Returns
+        =======
+        set
+            Set of functions of time ``t``, e.g.
+            ``Function('f')(me.dynamicsymbols._t)``.
+
+        """
+        # TODO : Circular dependency if imported at top. Should move
+        # find_dynamicsymbols into physics.vector.functions.
+        from sympy.physics.mechanics.functions import find_dynamicsymbols
+
+        return find_dynamicsymbols(self, reference_frame=reference_frame)
+
+    def _eval_evalf(self, prec):
+        if not self.args:
+            return self
+        new_args = []
+        dps = prec_to_dps(prec)
+        for mat, frame in self.args:
+            new_args.append([mat.evalf(n=dps), frame])
+        return Vector(new_args)
+
+    def xreplace(self, rule):
+        """Replace occurrences of objects within the measure numbers of the
+        vector.
+
+        Parameters
+        ==========
+
+        rule : dict-like
+            Expresses a replacement rule.
+
+        Returns
+        =======
+
+        Vector
+            Result of the replacement.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, pi
+        >>> from sympy.physics.vector import ReferenceFrame
+        >>> A = ReferenceFrame('A')
+        >>> x, y, z = symbols('x y z')
+        >>> ((1 + x*y) * A.x).xreplace({x: pi})
+        (pi*y + 1)*A.x
+        >>> ((1 + x*y) * A.x).xreplace({x: pi, y: 2})
+        (1 + 2*pi)*A.x
+
+        Replacements occur only if an entire node in the expression tree is
+        matched:
+
+        >>> ((x*y + z) * A.x).xreplace({x*y: pi})
+        (z + pi)*A.x
+        >>> ((x*y*z) * A.x).xreplace({x*y: pi})
+        x*y*z*A.x
+
+        """
+
+        new_args = []
+        for mat, frame in self.args:
+            mat = mat.xreplace(rule)
+            new_args.append([mat, frame])
+        return Vector(new_args)
+
+
+class VectorTypeError(TypeError):
+
+    def __init__(self, other, want):
+        msg = filldedent("Expected an instance of %s, but received object "
+                         "'%s' of %s." % (type(want), other, type(other)))
+        super().__init__(msg)
+
+
+def _check_vector(other):
+    if not isinstance(other, Vector):
+        raise TypeError('A Vector must be supplied')
+    return other

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/__init__.py

@@ -0,0 +1,22 @@
+from .plot import plot_backends
+from .plot_implicit import plot_implicit
+from .textplot import textplot
+from .pygletplot import PygletPlot
+from .plot import PlotGrid
+from .plot import (plot, plot_parametric, plot3d, plot3d_parametric_surface,
+                  plot3d_parametric_line, plot_contour)
+
+__all__ = [
+    'plot_backends',
+
+    'plot_implicit',
+
+    'textplot',
+
+    'PygletPlot',
+
+    'PlotGrid',
+
+    'plot', 'plot_parametric', 'plot3d', 'plot3d_parametric_surface',
+    'plot3d_parametric_line', 'plot_contour'
+]

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/backends/base_backend.py

@@ -0,0 +1,419 @@
+from sympy.plotting.series import BaseSeries, GenericDataSeries
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import is_sequence
+
+
+__doctest_requires__ = {
+    ('Plot.append', 'Plot.extend'): ['matplotlib'],
+}
+
+
+# Global variable
+# Set to False when running tests / doctests so that the plots don't show.
+_show = True
+
+def unset_show():
+    """
+    Disable show(). For use in the tests.
+    """
+    global _show
+    _show = False
+
+
+def _deprecation_msg_m_a_r_f(attr):
+    sympy_deprecation_warning(
+        f"The `{attr}` property is deprecated. The `{attr}` keyword "
+        "argument should be passed to a plotting function, which generates "
+        "the appropriate data series. If needed, index the plot object to "
+        "retrieve a specific data series.",
+        deprecated_since_version="1.13",
+        active_deprecations_target="deprecated-markers-annotations-fill-rectangles",
+        stacklevel=4)
+
+
+def _create_generic_data_series(**kwargs):
+    keywords = ["annotations", "markers", "fill", "rectangles"]
+    series = []
+    for kw in keywords:
+        dictionaries = kwargs.pop(kw, [])
+        if dictionaries is None:
+            dictionaries = []
+        if isinstance(dictionaries, dict):
+            dictionaries = [dictionaries]
+        for d in dictionaries:
+            args = d.pop("args", [])
+            series.append(GenericDataSeries(kw, *args, **d))
+    return series
+
+
+class Plot:
+    """Base class for all backends. A backend represents the plotting library,
+    which implements the necessary functionalities in order to use SymPy
+    plotting functions.
+
+    For interactive work the function :func:`plot` is better suited.
+
+    This class permits the plotting of SymPy expressions using numerous
+    backends (:external:mod:`matplotlib`, textplot, the old pyglet module for SymPy, Google
+    charts api, etc).
+
+    The figure can contain an arbitrary number of plots of SymPy expressions,
+    lists of coordinates of points, etc. Plot has a private attribute _series that
+    contains all data series to be plotted (expressions for lines or surfaces,
+    lists of points, etc (all subclasses of BaseSeries)). Those data series are
+    instances of classes not imported by ``from sympy import *``.
+
+    The customization of the figure is on two levels. Global options that
+    concern the figure as a whole (e.g. title, xlabel, scale, etc) and
+    per-data series options (e.g. name) and aesthetics (e.g. color, point shape,
+    line type, etc.).
+
+    The difference between options and aesthetics is that an aesthetic can be
+    a function of the coordinates (or parameters in a parametric plot). The
+    supported values for an aesthetic are:
+
+    - None (the backend uses default values)
+    - a constant
+    - a function of one variable (the first coordinate or parameter)
+    - a function of two variables (the first and second coordinate or parameters)
+    - a function of three variables (only in nonparametric 3D plots)
+
+    Their implementation depends on the backend so they may not work in some
+    backends.
+
+    If the plot is parametric and the arity of the aesthetic function permits
+    it the aesthetic is calculated over parameters and not over coordinates.
+    If the arity does not permit calculation over parameters the calculation is
+    done over coordinates.
+
+    Only cartesian coordinates are supported for the moment, but you can use
+    the parametric plots to plot in polar, spherical and cylindrical
+    coordinates.
+
+    The arguments for the constructor Plot must be subclasses of BaseSeries.
+
+    Any global option can be specified as a keyword argument.
+
+    The global options for a figure are:
+
+    - title : str
+    - xlabel : str or Symbol
+    - ylabel : str or Symbol
+    - zlabel : str or Symbol
+    - legend : bool
+    - xscale : {'linear', 'log'}
+    - yscale : {'linear', 'log'}
+    - axis : bool
+    - axis_center : tuple of two floats or {'center', 'auto'}
+    - xlim : tuple of two floats
+    - ylim : tuple of two floats
+    - aspect_ratio : tuple of two floats or {'auto'}
+    - autoscale : bool
+    - margin : float in [0, 1]
+    - backend : {'default', 'matplotlib', 'text'} or a subclass of BaseBackend
+    - size : optional tuple of two floats, (width, height); default: None
+
+    The per data series options and aesthetics are:
+    There are none in the base series. See below for options for subclasses.
+
+    Some data series support additional aesthetics or options:
+
+    :class:`~.LineOver1DRangeSeries`, :class:`~.Parametric2DLineSeries`, and
+    :class:`~.Parametric3DLineSeries` support the following:
+
+    Aesthetics:
+
+    - line_color : string, or float, or function, optional
+        Specifies the color for the plot, which depends on the backend being
+        used.
+
+        For example, if ``MatplotlibBackend`` is being used, then
+        Matplotlib string colors are acceptable (``"red"``, ``"r"``,
+        ``"cyan"``, ``"c"``, ...).
+        Alternatively, we can use a float number, 0 < color < 1, wrapped in a
+        string (for example, ``line_color="0.5"``) to specify grayscale colors.
+        Alternatively, We can specify a function returning a single
+        float value: this will be used to apply a color-loop (for example,
+        ``line_color=lambda x: math.cos(x)``).
+
+        Note that by setting line_color, it would be applied simultaneously
+        to all the series.
+
+    Options:
+
+    - label : str
+    - steps : bool
+    - integers_only : bool
+
+    :class:`~.SurfaceOver2DRangeSeries` and :class:`~.ParametricSurfaceSeries`
+    support the following:
+
+    Aesthetics:
+
+    - surface_color : function which returns a float.
+
+    Notes
+    =====
+
+    How the plotting module works:
+
+    1. Whenever a plotting function is called, the provided expressions are
+       processed and a list of instances of the
+       :class:`~sympy.plotting.series.BaseSeries` class is created, containing
+       the necessary information to plot the expressions
+       (e.g. the expression, ranges, series name, ...). Eventually, these
+       objects will generate the numerical data to be plotted.
+    2. A subclass of :class:`~.Plot` class is instantiaed (referred to as
+       backend, from now on), which stores the list of series and the main
+       attributes of the plot (e.g. axis labels, title, ...).
+       The backend implements the logic to generate the actual figure with
+       some plotting library.
+    3. When the ``show`` command is executed, series are processed one by one
+       to generate numerical data and add it to the figure. The backend is also
+       going to set the axis labels, title, ..., according to the values stored
+       in the Plot instance.
+
+    The backend should check if it supports the data series that it is given
+    (e.g. :class:`TextBackend` supports only
+    :class:`~sympy.plotting.series.LineOver1DRangeSeries`).
+
+    It is the backend responsibility to know how to use the class of data series
+    that it's given. Note that the current implementation of the ``*Series``
+    classes is "matplotlib-centric": the numerical data returned by the
+    ``get_points`` and ``get_meshes`` methods is meant to be used directly by
+    Matplotlib. Therefore, the new backend will have to pre-process the
+    numerical data to make it compatible with the chosen plotting library.
+    Keep in mind that future SymPy versions may improve the ``*Series`` classes
+    in order to return numerical data "non-matplotlib-centric", hence if you code
+    a new backend you have the responsibility to check if its working on each
+    SymPy release.
+
+    Please explore the :class:`MatplotlibBackend` source code to understand
+    how a backend should be coded.
+
+    In order to be used by SymPy plotting functions, a backend must implement
+    the following methods:
+
+    * show(self): used to loop over the data series, generate the numerical
+        data, plot it and set the axis labels, title, ...
+    * save(self, path): used to save the current plot to the specified file
+        path.
+    * close(self): used to close the current plot backend (note: some plotting
+        library does not support this functionality. In that case, just raise a
+        warning).
+    """
+
+    def __init__(self, *args,
+        title=None, xlabel=None, ylabel=None, zlabel=None, aspect_ratio='auto',
+        xlim=None, ylim=None, axis_center='auto', axis=True,
+        xscale='linear', yscale='linear', legend=False, autoscale=True,
+        margin=0, annotations=None, markers=None, rectangles=None,
+        fill=None, backend='default', size=None, **kwargs):
+
+        # Options for the graph as a whole.
+        # The possible values for each option are described in the docstring of
+        # Plot. They are based purely on convention, no checking is done.
+        self.title = title
+        self.xlabel = xlabel
+        self.ylabel = ylabel
+        self.zlabel = zlabel
+        self.aspect_ratio = aspect_ratio
+        self.axis_center = axis_center
+        self.axis = axis
+        self.xscale = xscale
+        self.yscale = yscale
+        self.legend = legend
+        self.autoscale = autoscale
+        self.margin = margin
+        self._annotations = annotations
+        self._markers = markers
+        self._rectangles = rectangles
+        self._fill = fill
+
+        # Contains the data objects to be plotted. The backend should be smart
+        # enough to iterate over this list.
+        self._series = []
+        self._series.extend(args)
+        self._series.extend(_create_generic_data_series(
+            annotations=annotations, markers=markers, rectangles=rectangles,
+            fill=fill))
+
+        is_real = \
+            lambda lim: all(getattr(i, 'is_real', True) for i in lim)
+        is_finite = \
+            lambda lim: all(getattr(i, 'is_finite', True) for i in lim)
+
+        # reduce code repetition
+        def check_and_set(t_name, t):
+            if t:
+                if not is_real(t):
+                    raise ValueError(
+                    "All numbers from {}={} must be real".format(t_name, t))
+                if not is_finite(t):
+                    raise ValueError(
+                    "All numbers from {}={} must be finite".format(t_name, t))
+                setattr(self, t_name, (float(t[0]), float(t[1])))
+
+        self.xlim = None
+        check_and_set("xlim", xlim)
+        self.ylim = None
+        check_and_set("ylim", ylim)
+        self.size = None
+        check_and_set("size", size)
+
+    @property
+    def _backend(self):
+        return self
+
+    @property
+    def backend(self):
+        return type(self)
+
+    def __str__(self):
+        series_strs = [('[%d]: ' % i) + str(s)
+                       for i, s in enumerate(self._series)]
+        return 'Plot object containing:\n' + '\n'.join(series_strs)
+
+    def __getitem__(self, index):
+        return self._series[index]
+
+    def __setitem__(self, index, *args):
+        if len(args) == 1 and isinstance(args[0], BaseSeries):
+            self._series[index] = args
+
+    def __delitem__(self, index):
+        del self._series[index]
+
+    def append(self, arg):
+        """Adds an element from a plot's series to an existing plot.
+
+        Examples
+        ========
+
+        Consider two ``Plot`` objects, ``p1`` and ``p2``. To add the
+        second plot's first series object to the first, use the
+        ``append`` method, like so:
+
+        .. plot::
+           :format: doctest
+           :include-source: True
+
+           >>> from sympy import symbols
+           >>> from sympy.plotting import plot
+           >>> x = symbols('x')
+           >>> p1 = plot(x*x, show=False)
+           >>> p2 = plot(x, show=False)
+           >>> p1.append(p2[0])
+           >>> p1
+           Plot object containing:
+           [0]: cartesian line: x**2 for x over (-10.0, 10.0)
+           [1]: cartesian line: x for x over (-10.0, 10.0)
+           >>> p1.show()
+
+        See Also
+        ========
+
+        extend
+
+        """
+        if isinstance(arg, BaseSeries):
+            self._series.append(arg)
+        else:
+            raise TypeError('Must specify element of plot to append.')
+
+    def extend(self, arg):
+        """Adds all series from another plot.
+
+        Examples
+        ========
+
+        Consider two ``Plot`` objects, ``p1`` and ``p2``. To add the
+        second plot to the first, use the ``extend`` method, like so:
+
+        .. plot::
+           :format: doctest
+           :include-source: True
+
+           >>> from sympy import symbols
+           >>> from sympy.plotting import plot
+           >>> x = symbols('x')
+           >>> p1 = plot(x**2, show=False)
+           >>> p2 = plot(x, -x, show=False)
+           >>> p1.extend(p2)
+           >>> p1
+           Plot object containing:
+           [0]: cartesian line: x**2 for x over (-10.0, 10.0)
+           [1]: cartesian line: x for x over (-10.0, 10.0)
+           [2]: cartesian line: -x for x over (-10.0, 10.0)
+           >>> p1.show()
+
+        """
+        if isinstance(arg, Plot):
+            self._series.extend(arg._series)
+        elif is_sequence(arg):
+            self._series.extend(arg)
+        else:
+            raise TypeError('Expecting Plot or sequence of BaseSeries')
+
+    def show(self):
+        raise NotImplementedError
+
+    def save(self, path):
+        raise NotImplementedError
+
+    def close(self):
+        raise NotImplementedError
+
+    # deprecations
+
+    @property
+    def markers(self):
+        """.. deprecated:: 1.13"""
+        _deprecation_msg_m_a_r_f("markers")
+        return self._markers
+
+    @markers.setter
+    def markers(self, v):
+        """.. deprecated:: 1.13"""
+        _deprecation_msg_m_a_r_f("markers")
+        self._series.extend(_create_generic_data_series(markers=v))
+        self._markers = v
+
+    @property
+    def annotations(self):
+        """.. deprecated:: 1.13"""
+        _deprecation_msg_m_a_r_f("annotations")
+        return self._annotations
+
+    @annotations.setter
+    def annotations(self, v):
+        """.. deprecated:: 1.13"""
+        _deprecation_msg_m_a_r_f("annotations")
+        self._series.extend(_create_generic_data_series(annotations=v))
+        self._annotations = v
+
+    @property
+    def rectangles(self):
+        """.. deprecated:: 1.13"""
+        _deprecation_msg_m_a_r_f("rectangles")
+        return self._rectangles
+
+    @rectangles.setter
+    def rectangles(self, v):
+        """.. deprecated:: 1.13"""
+        _deprecation_msg_m_a_r_f("rectangles")
+        self._series.extend(_create_generic_data_series(rectangles=v))
+        self._rectangles = v
+
+    @property
+    def fill(self):
+        """.. deprecated:: 1.13"""
+        _deprecation_msg_m_a_r_f("fill")
+        return self._fill
+
+    @fill.setter
+    def fill(self, v):
+        """.. deprecated:: 1.13"""
+        _deprecation_msg_m_a_r_f("fill")
+        self._series.extend(_create_generic_data_series(fill=v))
+        self._fill = v

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/backends/matplotlibbackend/__init__.py

@@ -0,0 +1,5 @@
+from sympy.plotting.backends.matplotlibbackend.matplotlib import (
+    MatplotlibBackend, _matplotlib_list
+)
+
+__all__ = ["MatplotlibBackend", "_matplotlib_list"]

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/backends/matplotlibbackend/matplotlib.py

@@ -0,0 +1,318 @@
+from collections.abc import Callable
+from sympy.core.basic import Basic
+from sympy.external import import_module
+import sympy.plotting.backends.base_backend as base_backend
+from sympy.printing.latex import latex
+
+
+# N.B.
+# When changing the minimum module version for matplotlib, please change
+# the same in the `SymPyDocTestFinder`` in `sympy/testing/runtests.py`
+
+
+def _str_or_latex(label):
+    if isinstance(label, Basic):
+        return latex(label, mode='inline')
+    return str(label)
+
+
+def _matplotlib_list(interval_list):
+    """
+    Returns lists for matplotlib ``fill`` command from a list of bounding
+    rectangular intervals
+    """
+    xlist = []
+    ylist = []
+    if len(interval_list):
+        for intervals in interval_list:
+            intervalx = intervals[0]
+            intervaly = intervals[1]
+            xlist.extend([intervalx.start, intervalx.start,
+                          intervalx.end, intervalx.end, None])
+            ylist.extend([intervaly.start, intervaly.end,
+                          intervaly.end, intervaly.start, None])
+    else:
+        #XXX Ugly hack. Matplotlib does not accept empty lists for ``fill``
+        xlist.extend((None, None, None, None))
+        ylist.extend((None, None, None, None))
+    return xlist, ylist
+
+
+# Don't have to check for the success of importing matplotlib in each case;
+# we will only be using this backend if we can successfully import matploblib
+class MatplotlibBackend(base_backend.Plot):
+    """ This class implements the functionalities to use Matplotlib with SymPy
+    plotting functions.
+    """
+
+    def __init__(self, *series, **kwargs):
+        super().__init__(*series, **kwargs)
+        self.matplotlib = import_module('matplotlib',
+            import_kwargs={'fromlist': ['pyplot', 'cm', 'collections']},
+            min_module_version='1.1.0', catch=(RuntimeError,))
+        self.plt = self.matplotlib.pyplot
+        self.cm = self.matplotlib.cm
+        self.LineCollection = self.matplotlib.collections.LineCollection
+        self.aspect = kwargs.get('aspect_ratio', 'auto')
+        if self.aspect != 'auto':
+            self.aspect = float(self.aspect[1]) / self.aspect[0]
+        # PlotGrid can provide its figure and axes to be populated with
+        # the data from the series.
+        self._plotgrid_fig = kwargs.pop("fig", None)
+        self._plotgrid_ax = kwargs.pop("ax", None)
+
+    def _create_figure(self):
+        def set_spines(ax):
+            ax.spines['left'].set_position('zero')
+            ax.spines['right'].set_color('none')
+            ax.spines['bottom'].set_position('zero')
+            ax.spines['top'].set_color('none')
+            ax.xaxis.set_ticks_position('bottom')
+            ax.yaxis.set_ticks_position('left')
+
+        if self._plotgrid_fig is not None:
+            self.fig = self._plotgrid_fig
+            self.ax = self._plotgrid_ax
+            if not any(s.is_3D for s in self._series):
+                set_spines(self.ax)
+        else:
+            self.fig = self.plt.figure(figsize=self.size)
+            if any(s.is_3D for s in self._series):
+                self.ax = self.fig.add_subplot(1, 1, 1, projection="3d")
+            else:
+                self.ax = self.fig.add_subplot(1, 1, 1)
+                set_spines(self.ax)
+
+    @staticmethod
+    def get_segments(x, y, z=None):
+        """ Convert two list of coordinates to a list of segments to be used
+        with Matplotlib's :external:class:`~matplotlib.collections.LineCollection`.
+
+        Parameters
+        ==========
+            x : list
+                List of x-coordinates
+
+            y : list
+                List of y-coordinates
+
+            z : list
+                List of z-coordinates for a 3D line.
+        """
+        np = import_module('numpy')
+        if z is not None:
+            dim = 3
+            points = (x, y, z)
+        else:
+            dim = 2
+            points = (x, y)
+        points = np.ma.array(points).T.reshape(-1, 1, dim)
+        return np.ma.concatenate([points[:-1], points[1:]], axis=1)
+
+    def _process_series(self, series, ax):
+        np = import_module('numpy')
+        mpl_toolkits = import_module(
+            'mpl_toolkits', import_kwargs={'fromlist': ['mplot3d']})
+
+        # XXX Workaround for matplotlib issue
+        # https://github.com/matplotlib/matplotlib/issues/17130
+        xlims, ylims, zlims = [], [], []
+
+        for s in series:
+            # Create the collections
+            if s.is_2Dline:
+                if s.is_parametric:
+                    x, y, param = s.get_data()
+                else:
+                    x, y = s.get_data()
+                if (isinstance(s.line_color, (int, float)) or
+                        callable(s.line_color)):
+                    segments = self.get_segments(x, y)
+                    collection = self.LineCollection(segments)
+                    collection.set_array(s.get_color_array())
+                    ax.add_collection(collection)
+                else:
+                    lbl = _str_or_latex(s.label)
+                    line, = ax.plot(x, y, label=lbl, color=s.line_color)
+            elif s.is_contour:
+                ax.contour(*s.get_data())
+            elif s.is_3Dline:
+                x, y, z, param = s.get_data()
+                if (isinstance(s.line_color, (int, float)) or
+                        callable(s.line_color)):
+                    art3d = mpl_toolkits.mplot3d.art3d
+                    segments = self.get_segments(x, y, z)
+                    collection = art3d.Line3DCollection(segments)
+                    collection.set_array(s.get_color_array())
+                    ax.add_collection(collection)
+                else:
+                    lbl = _str_or_latex(s.label)
+                    ax.plot(x, y, z, label=lbl, color=s.line_color)
+
+                xlims.append(s._xlim)
+                ylims.append(s._ylim)
+                zlims.append(s._zlim)
+            elif s.is_3Dsurface:
+                if s.is_parametric:
+                    x, y, z, u, v = s.get_data()
+                else:
+                    x, y, z = s.get_data()
+                collection = ax.plot_surface(x, y, z,
+                    cmap=getattr(self.cm, 'viridis', self.cm.jet),
+                    rstride=1, cstride=1, linewidth=0.1)
+                if isinstance(s.surface_color, (float, int, Callable)):
+                    color_array = s.get_color_array()
+                    color_array = color_array.reshape(color_array.size)
+                    collection.set_array(color_array)
+                else:
+                    collection.set_color(s.surface_color)
+
+                xlims.append(s._xlim)
+                ylims.append(s._ylim)
+                zlims.append(s._zlim)
+            elif s.is_implicit:
+                points = s.get_data()
+                if len(points) == 2:
+                    # interval math plotting
+                    x, y = _matplotlib_list(points[0])
+                    ax.fill(x, y, facecolor=s.line_color, edgecolor='None')
+                else:
+                    # use contourf or contour depending on whether it is
+                    # an inequality or equality.
+                    # XXX: ``contour`` plots multiple lines. Should be fixed.
+                    ListedColormap = self.matplotlib.colors.ListedColormap
+                    colormap = ListedColormap(["white", s.line_color])
+                    xarray, yarray, zarray, plot_type = points
+                    if plot_type == 'contour':
+                        ax.contour(xarray, yarray, zarray, cmap=colormap)
+                    else:
+                        ax.contourf(xarray, yarray, zarray, cmap=colormap)
+            elif s.is_generic:
+                if s.type == "markers":
+                    # s.rendering_kw["color"] = s.line_color
+                    ax.plot(*s.args, **s.rendering_kw)
+                elif s.type == "annotations":
+                    ax.annotate(*s.args, **s.rendering_kw)
+                elif s.type == "fill":
+                    # s.rendering_kw["color"] = s.line_color
+                    ax.fill_between(*s.args, **s.rendering_kw)
+                elif s.type == "rectangles":
+                    # s.rendering_kw["color"] = s.line_color
+                    ax.add_patch(
+                        self.matplotlib.patches.Rectangle(
+                            *s.args, **s.rendering_kw))
+            else:
+                raise NotImplementedError(
+                    '{} is not supported in the SymPy plotting module '
+                    'with matplotlib backend. Please report this issue.'
+                    .format(ax))
+
+        Axes3D = mpl_toolkits.mplot3d.Axes3D
+        if not isinstance(ax, Axes3D):
+            ax.autoscale_view(
+                scalex=ax.get_autoscalex_on(),
+                scaley=ax.get_autoscaley_on())
+        else:
+            # XXX Workaround for matplotlib issue
+            # https://github.com/matplotlib/matplotlib/issues/17130
+            if xlims:
+                xlims = np.array(xlims)
+                xlim = (np.amin(xlims[:, 0]), np.amax(xlims[:, 1]))
+                ax.set_xlim(xlim)
+            else:
+                ax.set_xlim([0, 1])
+
+            if ylims:
+                ylims = np.array(ylims)
+                ylim = (np.amin(ylims[:, 0]), np.amax(ylims[:, 1]))
+                ax.set_ylim(ylim)
+            else:
+                ax.set_ylim([0, 1])
+
+            if zlims:
+                zlims = np.array(zlims)
+                zlim = (np.amin(zlims[:, 0]), np.amax(zlims[:, 1]))
+                ax.set_zlim(zlim)
+            else:
+                ax.set_zlim([0, 1])
+
+        # Set global options.
+        # TODO The 3D stuff
+        # XXX The order of those is important.
+        if self.xscale and not isinstance(ax, Axes3D):
+            ax.set_xscale(self.xscale)
+        if self.yscale and not isinstance(ax, Axes3D):
+            ax.set_yscale(self.yscale)
+        if not isinstance(ax, Axes3D) or self.matplotlib.__version__ >= '1.2.0':  # XXX in the distant future remove this check
+            ax.set_autoscale_on(self.autoscale)
+        if self.axis_center:
+            val = self.axis_center
+            if isinstance(ax, Axes3D):
+                pass
+            elif val == 'center':
+                ax.spines['left'].set_position('center')
+                ax.spines['bottom'].set_position('center')
+            elif val == 'auto':
+                xl, xh = ax.get_xlim()
+                yl, yh = ax.get_ylim()
+                pos_left = ('data', 0) if xl*xh <= 0 else 'center'
+                pos_bottom = ('data', 0) if yl*yh <= 0 else 'center'
+                ax.spines['left'].set_position(pos_left)
+                ax.spines['bottom'].set_position(pos_bottom)
+            else:
+                ax.spines['left'].set_position(('data', val[0]))
+                ax.spines['bottom'].set_position(('data', val[1]))
+        if not self.axis:
+            ax.set_axis_off()
+        if self.legend:
+            if ax.legend():
+                ax.legend_.set_visible(self.legend)
+        if self.margin:
+            ax.set_xmargin(self.margin)
+            ax.set_ymargin(self.margin)
+        if self.title:
+            ax.set_title(self.title)
+        if self.xlabel:
+            xlbl = _str_or_latex(self.xlabel)
+            ax.set_xlabel(xlbl, position=(1, 0))
+        if self.ylabel:
+            ylbl = _str_or_latex(self.ylabel)
+            ax.set_ylabel(ylbl, position=(0, 1))
+        if isinstance(ax, Axes3D) and self.zlabel:
+            zlbl = _str_or_latex(self.zlabel)
+            ax.set_zlabel(zlbl, position=(0, 1))
+
+        # xlim and ylim should always be set at last so that plot limits
+        # doesn't get altered during the process.
+        if self.xlim:
+            ax.set_xlim(self.xlim)
+        if self.ylim:
+            ax.set_ylim(self.ylim)
+        self.ax.set_aspect(self.aspect)
+
+
+    def process_series(self):
+        """
+        Iterates over every ``Plot`` object and further calls
+        _process_series()
+        """
+        self._create_figure()
+        self._process_series(self._series, self.ax)
+
+    def show(self):
+        self.process_series()
+        #TODO after fixing https://github.com/ipython/ipython/issues/1255
+        # you can uncomment the next line and remove the pyplot.show() call
+        #self.fig.show()
+        if base_backend._show:
+            self.fig.tight_layout()
+            self.plt.show()
+        else:
+            self.close()
+
+    def save(self, path):
+        self.process_series()
+        self.fig.savefig(path)
+
+    def close(self):
+        self.plt.close(self.fig)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/backends/textbackend/__init__.py

@@ -0,0 +1,3 @@
+from sympy.plotting.backends.textbackend.text import TextBackend
+
+__all__ = ["TextBackend"]

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/backends/textbackend/text.py

@@ -0,0 +1,24 @@
+import sympy.plotting.backends.base_backend as base_backend
+from sympy.plotting.series import LineOver1DRangeSeries
+from sympy.plotting.textplot import textplot
+
+
+class TextBackend(base_backend.Plot):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def show(self):
+        if not base_backend._show:
+            return
+        if len(self._series) != 1:
+            raise ValueError(
+                'The TextBackend supports only one graph per Plot.')
+        elif not isinstance(self._series[0], LineOver1DRangeSeries):
+            raise ValueError(
+                'The TextBackend supports only expressions over a 1D range')
+        else:
+            ser = self._series[0]
+            textplot(ser.expr, ser.start, ser.end)
+
+    def close(self):
+        pass

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/experimental_lambdify.py

@@ -0,0 +1,641 @@
+""" rewrite of lambdify - This stuff is not stable at all.
+
+It is for internal use in the new plotting module.
+It may (will! see the Q'n'A in the source) be rewritten.
+
+It's completely self contained. Especially it does not use lambdarepr.
+
+It does not aim to replace the current lambdify. Most importantly it will never
+ever support anything else than SymPy expressions (no Matrices, dictionaries
+and so on).
+"""
+
+
+import re
+from sympy.core.numbers import (I, NumberSymbol, oo, zoo)
+from sympy.core.symbol import Symbol
+from sympy.utilities.iterables import numbered_symbols
+
+#  We parse the expression string into a tree that identifies functions. Then
+# we translate the names of the functions and we translate also some strings
+# that are not names of functions (all this according to translation
+# dictionaries).
+#  If the translation goes to another module (like numpy) the
+# module is imported and 'func' is translated to 'module.func'.
+#  If a function can not be translated, the inner nodes of that part of the
+# tree are not translated. So if we have Integral(sqrt(x)), sqrt is not
+# translated to np.sqrt and the Integral does not crash.
+#  A namespace for all this is generated by crawling the (func, args) tree of
+# the expression. The creation of this namespace involves many ugly
+# workarounds.
+#  The namespace consists of all the names needed for the SymPy expression and
+# all the name of modules used for translation. Those modules are imported only
+# as a name (import numpy as np) in order to keep the namespace small and
+# manageable.
+
+#  Please, if there is a bug, do not try to fix it here! Rewrite this by using
+# the method proposed in the last Q'n'A below. That way the new function will
+# work just as well, be just as simple, but it wont need any new workarounds.
+#  If you insist on fixing it here, look at the workarounds in the function
+# sympy_expression_namespace and in lambdify.
+
+# Q: Why are you not using Python abstract syntax tree?
+# A: Because it is more complicated and not much more powerful in this case.
+
+# Q: What if I have Symbol('sin') or g=Function('f')?
+# A: You will break the algorithm. We should use srepr to defend against this?
+#  The problem with Symbol('sin') is that it will be printed as 'sin'. The
+# parser will distinguish it from the function 'sin' because functions are
+# detected thanks to the opening parenthesis, but the lambda expression won't
+# understand the difference if we have also the sin function.
+# The solution (complicated) is to use srepr and maybe ast.
+#  The problem with the g=Function('f') is that it will be printed as 'f' but in
+# the global namespace we have only 'g'. But as the same printer is used in the
+# constructor of the namespace there will be no problem.
+
+# Q: What if some of the printers are not printing as expected?
+# A: The algorithm wont work. You must use srepr for those cases. But even
+# srepr may not print well. All problems with printers should be considered
+# bugs.
+
+# Q: What about _imp_ functions?
+# A: Those are taken care for by evalf. A special case treatment will work
+# faster but it's not worth the code complexity.
+
+# Q: Will ast fix all possible problems?
+# A: No. You will always have to use some printer. Even srepr may not work in
+# some cases. But if the printer does not work, that should be considered a
+# bug.
+
+# Q: Is there same way to fix all possible problems?
+# A: Probably by constructing our strings ourself by traversing the (func,
+# args) tree and creating the namespace at the same time. That actually sounds
+# good.
+
+from sympy.external import import_module
+import warnings
+
+#TODO debugging output
+
+
+class vectorized_lambdify:
+    """ Return a sufficiently smart, vectorized and lambdified function.
+
+    Returns only reals.
+
+    Explanation
+    ===========
+
+    This function uses experimental_lambdify to created a lambdified
+    expression ready to be used with numpy. Many of the functions in SymPy
+    are not implemented in numpy so in some cases we resort to Python cmath or
+    even to evalf.
+
+    The following translations are tried:
+      only numpy complex
+      - on errors raised by SymPy trying to work with ndarray:
+          only Python cmath and then vectorize complex128
+
+    When using Python cmath there is no need for evalf or float/complex
+    because Python cmath calls those.
+
+    This function never tries to mix numpy directly with evalf because numpy
+    does not understand SymPy Float. If this is needed one can use the
+    float_wrap_evalf/complex_wrap_evalf options of experimental_lambdify or
+    better one can be explicit about the dtypes that numpy works with.
+    Check numpy bug http://projects.scipy.org/numpy/ticket/1013 to know what
+    types of errors to expect.
+    """
+    def __init__(self, args, expr):
+        self.args = args
+        self.expr = expr
+        self.np = import_module('numpy')
+
+        self.lambda_func_1 = experimental_lambdify(
+            args, expr, use_np=True)
+        self.vector_func_1 = self.lambda_func_1
+
+        self.lambda_func_2 = experimental_lambdify(
+            args, expr, use_python_cmath=True)
+        self.vector_func_2 = self.np.vectorize(
+            self.lambda_func_2, otypes=[complex])
+
+        self.vector_func = self.vector_func_1
+        self.failure = False
+
+    def __call__(self, *args):
+        np = self.np
+
+        try:
+            temp_args = (np.array(a, dtype=complex) for a in args)
+            results = self.vector_func(*temp_args)
+            results = np.ma.masked_where(
+                np.abs(results.imag) > 1e-7 * np.abs(results),
+                results.real, copy=False)
+            return results
+        except ValueError:
+            if self.failure:
+                raise
+
+            self.failure = True
+            self.vector_func = self.vector_func_2
+            warnings.warn(
+                'The evaluation of the expression is problematic. '
+                'We are trying a failback method that may still work. '
+                'Please report this as a bug.')
+            return self.__call__(*args)
+
+
+class lambdify:
+    """Returns the lambdified function.
+
+    Explanation
+    ===========
+
+    This function uses experimental_lambdify to create a lambdified
+    expression. It uses cmath to lambdify the expression. If the function
+    is not implemented in Python cmath, Python cmath calls evalf on those
+    functions.
+    """
+
+    def __init__(self, args, expr):
+        self.args = args
+        self.expr = expr
+        self.lambda_func_1 = experimental_lambdify(
+            args, expr, use_python_cmath=True, use_evalf=True)
+        self.lambda_func_2 = experimental_lambdify(
+            args, expr, use_python_math=True, use_evalf=True)
+        self.lambda_func_3 = experimental_lambdify(
+            args, expr, use_evalf=True, complex_wrap_evalf=True)
+        self.lambda_func = self.lambda_func_1
+        self.failure = False
+
+    def __call__(self, args):
+        try:
+            #The result can be sympy.Float. Hence wrap it with complex type.
+            result = complex(self.lambda_func(args))
+            if abs(result.imag) > 1e-7 * abs(result):
+                return None
+            return result.real
+        except (ZeroDivisionError, OverflowError):
+            return None
+        except TypeError as e:
+            if self.failure:
+                raise e
+
+            if self.lambda_func == self.lambda_func_1:
+                self.lambda_func = self.lambda_func_2
+                return self.__call__(args)
+
+            self.failure = True
+            self.lambda_func = self.lambda_func_3
+            warnings.warn(
+                'The evaluation of the expression is problematic. '
+                'We are trying a failback method that may still work. '
+                'Please report this as a bug.', stacklevel=2)
+            return self.__call__(args)
+
+
+def experimental_lambdify(*args, **kwargs):
+    l = Lambdifier(*args, **kwargs)
+    return l
+
+
+class Lambdifier:
+    def __init__(self, args, expr, print_lambda=False, use_evalf=False,
+                 float_wrap_evalf=False, complex_wrap_evalf=False,
+                 use_np=False, use_python_math=False, use_python_cmath=False,
+                 use_interval=False):
+
+        self.print_lambda = print_lambda
+        self.use_evalf = use_evalf
+        self.float_wrap_evalf = float_wrap_evalf
+        self.complex_wrap_evalf = complex_wrap_evalf
+        self.use_np = use_np
+        self.use_python_math = use_python_math
+        self.use_python_cmath = use_python_cmath
+        self.use_interval = use_interval
+
+        # Constructing the argument string
+        # - check
+        if not all(isinstance(a, Symbol) for a in args):
+            raise ValueError('The arguments must be Symbols.')
+        # - use numbered symbols
+        syms = numbered_symbols(exclude=expr.free_symbols)
+        newargs = [next(syms) for _ in args]
+        expr = expr.xreplace(dict(zip(args, newargs)))
+        argstr = ', '.join([str(a) for a in newargs])
+        del syms, newargs, args
+
+        # Constructing the translation dictionaries and making the translation
+        self.dict_str = self.get_dict_str()
+        self.dict_fun = self.get_dict_fun()
+        exprstr = str(expr)
+        newexpr = self.tree2str_translate(self.str2tree(exprstr))
+
+        # Constructing the namespaces
+        namespace = {}
+        namespace.update(self.sympy_atoms_namespace(expr))
+        namespace.update(self.sympy_expression_namespace(expr))
+        # XXX Workaround
+        # Ugly workaround because Pow(a,Half) prints as sqrt(a)
+        # and sympy_expression_namespace can not catch it.
+        from sympy.functions.elementary.miscellaneous import sqrt
+        namespace.update({'sqrt': sqrt})
+        namespace.update({'Eq': lambda x, y: x == y})
+        namespace.update({'Ne': lambda x, y: x != y})
+        # End workaround.
+        if use_python_math:
+            namespace.update({'math': __import__('math')})
+        if use_python_cmath:
+            namespace.update({'cmath': __import__('cmath')})
+        if use_np:
+            try:
+                namespace.update({'np': __import__('numpy')})
+            except ImportError:
+                raise ImportError(
+                    'experimental_lambdify failed to import numpy.')
+        if use_interval:
+            namespace.update({'imath': __import__(
+                'sympy.plotting.intervalmath', fromlist=['intervalmath'])})
+            namespace.update({'math': __import__('math')})
+
+        # Construct the lambda
+        if self.print_lambda:
+            print(newexpr)
+        eval_str = 'lambda %s : ( %s )' % (argstr, newexpr)
+        self.eval_str = eval_str
+        exec("MYNEWLAMBDA = %s" % eval_str, namespace)
+        self.lambda_func = namespace['MYNEWLAMBDA']
+
+    def __call__(self, *args, **kwargs):
+        return self.lambda_func(*args, **kwargs)
+
+
+    ##############################################################################
+    # Dicts for translating from SymPy to other modules
+    ##############################################################################
+    ###
+    # builtins
+    ###
+    # Functions with different names in builtins
+    builtin_functions_different = {
+        'Min': 'min',
+        'Max': 'max',
+        'Abs': 'abs',
+    }
+
+    # Strings that should be translated
+    builtin_not_functions = {
+        'I': '1j',
+#        'oo': '1e400',
+    }
+
+    ###
+    # numpy
+    ###
+
+    # Functions that are the same in numpy
+    numpy_functions_same = [
+        'sin', 'cos', 'tan', 'sinh', 'cosh', 'tanh', 'exp', 'log',
+        'sqrt', 'floor', 'conjugate', 'sign',
+    ]
+
+    # Functions with different names in numpy
+    numpy_functions_different = {
+        "acos": "arccos",
+        "acosh": "arccosh",
+        "arg": "angle",
+        "asin": "arcsin",
+        "asinh": "arcsinh",
+        "atan": "arctan",
+        "atan2": "arctan2",
+        "atanh": "arctanh",
+        "ceiling": "ceil",
+        "im": "imag",
+        "ln": "log",
+        "Max": "amax",
+        "Min": "amin",
+        "re": "real",
+        "Abs": "abs",
+    }
+
+    # Strings that should be translated
+    numpy_not_functions = {
+        'pi': 'np.pi',
+        'oo': 'np.inf',
+        'E': 'np.e',
+    }
+
+    ###
+    # Python math
+    ###
+
+    # Functions that are the same in math
+    math_functions_same = [
+        'sin', 'cos', 'tan', 'asin', 'acos', 'atan', 'atan2',
+        'sinh', 'cosh', 'tanh', 'asinh', 'acosh', 'atanh',
+        'exp', 'log', 'erf', 'sqrt', 'floor', 'factorial', 'gamma',
+    ]
+
+    # Functions with different names in math
+    math_functions_different = {
+        'ceiling': 'ceil',
+        'ln': 'log',
+        'loggamma': 'lgamma'
+    }
+
+    # Strings that should be translated
+    math_not_functions = {
+        'pi': 'math.pi',
+        'E': 'math.e',
+    }
+
+    ###
+    # Python cmath
+    ###
+
+    # Functions that are the same in cmath
+    cmath_functions_same = [
+        'sin', 'cos', 'tan', 'asin', 'acos', 'atan',
+        'sinh', 'cosh', 'tanh', 'asinh', 'acosh', 'atanh',
+        'exp', 'log', 'sqrt',
+    ]
+
+    # Functions with different names in cmath
+    cmath_functions_different = {
+        'ln': 'log',
+        'arg': 'phase',
+    }
+
+    # Strings that should be translated
+    cmath_not_functions = {
+        'pi': 'cmath.pi',
+        'E': 'cmath.e',
+    }
+
+    ###
+    # intervalmath
+    ###
+
+    interval_not_functions = {
+        'pi': 'math.pi',
+        'E': 'math.e'
+    }
+
+    interval_functions_same = [
+        'sin', 'cos', 'exp', 'tan', 'atan', 'log',
+        'sqrt', 'cosh', 'sinh', 'tanh', 'floor',
+        'acos', 'asin', 'acosh', 'asinh', 'atanh',
+        'Abs', 'And', 'Or'
+    ]
+
+    interval_functions_different = {
+        'Min': 'imin',
+        'Max': 'imax',
+        'ceiling': 'ceil',
+
+    }
+
+    ###
+    # mpmath, etc
+    ###
+    #TODO
+
+    ###
+    # Create the final ordered tuples of dictionaries
+    ###
+
+    # For strings
+    def get_dict_str(self):
+        dict_str = dict(self.builtin_not_functions)
+        if self.use_np:
+            dict_str.update(self.numpy_not_functions)
+        if self.use_python_math:
+            dict_str.update(self.math_not_functions)
+        if self.use_python_cmath:
+            dict_str.update(self.cmath_not_functions)
+        if self.use_interval:
+            dict_str.update(self.interval_not_functions)
+        return dict_str
+
+    # For functions
+    def get_dict_fun(self):
+        dict_fun = dict(self.builtin_functions_different)
+        if self.use_np:
+            for s in self.numpy_functions_same:
+                dict_fun[s] = 'np.' + s
+            for k, v in self.numpy_functions_different.items():
+                dict_fun[k] = 'np.' + v
+        if self.use_python_math:
+            for s in self.math_functions_same:
+                dict_fun[s] = 'math.' + s
+            for k, v in self.math_functions_different.items():
+                dict_fun[k] = 'math.' + v
+        if self.use_python_cmath:
+            for s in self.cmath_functions_same:
+                dict_fun[s] = 'cmath.' + s
+            for k, v in self.cmath_functions_different.items():
+                dict_fun[k] = 'cmath.' + v
+        if self.use_interval:
+            for s in self.interval_functions_same:
+                dict_fun[s] = 'imath.' + s
+            for k, v in self.interval_functions_different.items():
+                dict_fun[k] = 'imath.' + v
+        return dict_fun
+
+    ##############################################################################
+    # The translator functions, tree parsers, etc.
+    ##############################################################################
+
+    def str2tree(self, exprstr):
+        """Converts an expression string to a tree.
+
+        Explanation
+        ===========
+
+        Functions are represented by ('func_name(', tree_of_arguments).
+        Other expressions are (head_string, mid_tree, tail_str).
+        Expressions that do not contain functions are directly returned.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y, z
+        >>> from sympy import Integral, sin
+        >>> from sympy.plotting.experimental_lambdify import Lambdifier
+        >>> str2tree = Lambdifier([x], x).str2tree
+
+        >>> str2tree(str(Integral(x, (x, 1, y))))
+        ('', ('Integral(', 'x, (x, 1, y)'), ')')
+        >>> str2tree(str(x+y))
+        'x + y'
+        >>> str2tree(str(x+y*sin(z)+1))
+        ('x + y*', ('sin(', 'z'), ') + 1')
+        >>> str2tree('sin(y*(y + 1.1) + (sin(y)))')
+        ('', ('sin(', ('y*(y + 1.1) + (', ('sin(', 'y'), '))')), ')')
+        """
+        #matches the first 'function_name('
+        first_par = re.search(r'(\w+\()', exprstr)
+        if first_par is None:
+            return exprstr
+        else:
+            start = first_par.start()
+            end = first_par.end()
+            head = exprstr[:start]
+            func = exprstr[start:end]
+            tail = exprstr[end:]
+            count = 0
+            for i, c in enumerate(tail):
+                if c == '(':
+                    count += 1
+                elif c == ')':
+                    count -= 1
+                if count == -1:
+                    break
+            func_tail = self.str2tree(tail[:i])
+            tail = self.str2tree(tail[i:])
+            return (head, (func, func_tail), tail)
+
+    @classmethod
+    def tree2str(cls, tree):
+        """Converts a tree to string without translations.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y, z
+        >>> from sympy import sin
+        >>> from sympy.plotting.experimental_lambdify import Lambdifier
+        >>> str2tree = Lambdifier([x], x).str2tree
+        >>> tree2str = Lambdifier([x], x).tree2str
+
+        >>> tree2str(str2tree(str(x+y*sin(z)+1)))
+        'x + y*sin(z) + 1'
+        """
+        if isinstance(tree, str):
+            return tree
+        else:
+            return ''.join(map(cls.tree2str, tree))
+
+    def tree2str_translate(self, tree):
+        """Converts a tree to string with translations.
+
+        Explanation
+        ===========
+
+        Function names are translated by translate_func.
+        Other strings are translated by translate_str.
+        """
+        if isinstance(tree, str):
+            return self.translate_str(tree)
+        elif isinstance(tree, tuple) and len(tree) == 2:
+            return self.translate_func(tree[0][:-1], tree[1])
+        else:
+            return ''.join([self.tree2str_translate(t) for t in tree])
+
+    def translate_str(self, estr):
+        """Translate substrings of estr using in order the dictionaries in
+        dict_tuple_str."""
+        for pattern, repl in self.dict_str.items():
+                estr = re.sub(pattern, repl, estr)
+        return estr
+
+    def translate_func(self, func_name, argtree):
+        """Translate function names and the tree of arguments.
+
+        Explanation
+        ===========
+
+        If the function name is not in the dictionaries of dict_tuple_fun then the
+        function is surrounded by a float((...).evalf()).
+
+        The use of float is necessary as np.<function>(sympy.Float(..)) raises an
+        error."""
+        if func_name in self.dict_fun:
+            new_name = self.dict_fun[func_name]
+            argstr = self.tree2str_translate(argtree)
+            return new_name + '(' + argstr
+        elif func_name in ['Eq', 'Ne']:
+            op = {'Eq': '==', 'Ne': '!='}
+            return "(lambda x, y: x {} y)({}".format(op[func_name], self.tree2str_translate(argtree))
+        else:
+            template = '(%s(%s)).evalf(' if self.use_evalf else '%s(%s'
+            if self.float_wrap_evalf:
+                template = 'float(%s)' % template
+            elif self.complex_wrap_evalf:
+                template = 'complex(%s)' % template
+
+            # Wrapping should only happen on the outermost expression, which
+            # is the only thing we know will be a number.
+            float_wrap_evalf = self.float_wrap_evalf
+            complex_wrap_evalf = self.complex_wrap_evalf
+            self.float_wrap_evalf = False
+            self.complex_wrap_evalf = False
+            ret =  template % (func_name, self.tree2str_translate(argtree))
+            self.float_wrap_evalf = float_wrap_evalf
+            self.complex_wrap_evalf = complex_wrap_evalf
+            return ret
+
+    ##############################################################################
+    # The namespace constructors
+    ##############################################################################
+
+    @classmethod
+    def sympy_expression_namespace(cls, expr):
+        """Traverses the (func, args) tree of an expression and creates a SymPy
+        namespace. All other modules are imported only as a module name. That way
+        the namespace is not polluted and rests quite small. It probably causes much
+        more variable lookups and so it takes more time, but there are no tests on
+        that for the moment."""
+        if expr is None:
+            return {}
+        else:
+            funcname = str(expr.func)
+            # XXX Workaround
+            # Here we add an ugly workaround because str(func(x))
+            # is not always the same as str(func). Eg
+            # >>> str(Integral(x))
+            # "Integral(x)"
+            # >>> str(Integral)
+            # "<class 'sympy.integrals.integrals.Integral'>"
+            # >>> str(sqrt(x))
+            # "sqrt(x)"
+            # >>> str(sqrt)
+            # "<function sqrt at 0x3d92de8>"
+            # >>> str(sin(x))
+            # "sin(x)"
+            # >>> str(sin)
+            # "sin"
+            # Either one of those can be used but not all at the same time.
+            # The code considers the sin example as the right one.
+            regexlist = [
+                r'<class \'sympy[\w.]*?.([\w]*)\'>$',
+                # the example Integral
+                r'<function ([\w]*) at 0x[\w]*>$',    # the example sqrt
+            ]
+            for r in regexlist:
+                m = re.match(r, funcname)
+                if m is not None:
+                    funcname = m.groups()[0]
+            # End of the workaround
+            # XXX debug: print funcname
+            args_dict = {}
+            for a in expr.args:
+                if (isinstance(a, (Symbol, NumberSymbol)) or a in [I, zoo, oo]):
+                    continue
+                else:
+                    args_dict.update(cls.sympy_expression_namespace(a))
+            args_dict.update({funcname: expr.func})
+            return args_dict
+
+    @staticmethod
+    def sympy_atoms_namespace(expr):
+        """For no real reason this function is separated from
+        sympy_expression_namespace. It can be moved to it."""
+        atoms = expr.atoms(Symbol, NumberSymbol, I, zoo, oo)
+        d = {}
+        for a in atoms:
+            # XXX debug: print 'atom:' + str(a)
+            d[str(a)] = a
+        return d

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/intervalmath/__init__.py

@@ -0,0 +1,12 @@
+from .interval_arithmetic import interval
+from .lib_interval import (Abs, exp, log, log10, sin, cos, tan, sqrt,
+                          imin, imax, sinh, cosh, tanh, acosh, asinh, atanh,
+                          asin, acos, atan, ceil, floor, And, Or)
+
+__all__ = [
+    'interval',
+
+    'Abs', 'exp', 'log', 'log10', 'sin', 'cos', 'tan', 'sqrt', 'imin', 'imax',
+    'sinh', 'cosh', 'tanh', 'acosh', 'asinh', 'atanh', 'asin', 'acos', 'atan',
+    'ceil', 'floor', 'And', 'Or',
+]

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/intervalmath/interval_arithmetic.py

@@ -0,0 +1,413 @@
+"""
+Interval Arithmetic for plotting.
+This module does not implement interval arithmetic accurately and
+hence cannot be used for purposes other than plotting. If you want
+to use interval arithmetic, use mpmath's interval arithmetic.
+
+The module implements interval arithmetic using numpy and
+python floating points. The rounding up and down is not handled
+and hence this is not an accurate implementation of interval
+arithmetic.
+
+The module uses numpy for speed which cannot be achieved with mpmath.
+"""
+
+# Q: Why use numpy? Why not simply use mpmath's interval arithmetic?
+# A: mpmath's interval arithmetic simulates a floating point unit
+# and hence is slow, while numpy evaluations are orders of magnitude
+# faster.
+
+# Q: Why create a separate class for intervals? Why not use SymPy's
+# Interval Sets?
+# A: The functionalities that will be required for plotting is quite
+# different from what Interval Sets implement.
+
+# Q: Why is rounding up and down according to IEEE754 not handled?
+# A: It is not possible to do it in both numpy and python. An external
+# library has to used, which defeats the whole purpose i.e., speed. Also
+# rounding is handled for very few functions in those libraries.
+
+# Q Will my plots be affected?
+# A It will not affect most of the plots. The interval arithmetic
+# module based suffers the same problems as that of floating point
+# arithmetic.
+
+from sympy.core.numbers import int_valued
+from sympy.core.logic import fuzzy_and
+from sympy.simplify.simplify import nsimplify
+
+from .interval_membership import intervalMembership
+
+
+class interval:
+    """ Represents an interval containing floating points as start and
+    end of the interval
+    The is_valid variable tracks whether the interval obtained as the
+    result of the function is in the domain and is continuous.
+    - True: Represents the interval result of a function is continuous and
+            in the domain of the function.
+    - False: The interval argument of the function was not in the domain of
+             the function, hence the is_valid of the result interval is False
+    - None: The function was not continuous over the interval or
+            the function's argument interval is partly in the domain of the
+            function
+
+    A comparison between an interval and a real number, or a
+    comparison between two intervals may return ``intervalMembership``
+    of two 3-valued logic values.
+    """
+
+    def __init__(self, *args, is_valid=True, **kwargs):
+        self.is_valid = is_valid
+        if len(args) == 1:
+            if isinstance(args[0], interval):
+                self.start, self.end = args[0].start, args[0].end
+            else:
+                self.start = float(args[0])
+                self.end = float(args[0])
+        elif len(args) == 2:
+            if args[0] < args[1]:
+                self.start = float(args[0])
+                self.end = float(args[1])
+            else:
+                self.start = float(args[1])
+                self.end = float(args[0])
+
+        else:
+            raise ValueError("interval takes a maximum of two float values "
+                            "as arguments")
+
+    @property
+    def mid(self):
+        return (self.start + self.end) / 2.0
+
+    @property
+    def width(self):
+        return self.end - self.start
+
+    def __repr__(self):
+        return "interval(%f, %f)" % (self.start, self.end)
+
+    def __str__(self):
+        return "[%f, %f]" % (self.start, self.end)
+
+    def __lt__(self, other):
+        if isinstance(other, (int, float)):
+            if self.end < other:
+                return intervalMembership(True, self.is_valid)
+            elif self.start > other:
+                return intervalMembership(False, self.is_valid)
+            else:
+                return intervalMembership(None, self.is_valid)
+
+        elif isinstance(other, interval):
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            if self.end < other. start:
+                return intervalMembership(True, valid)
+            if self.start > other.end:
+                return intervalMembership(False, valid)
+            return intervalMembership(None, valid)
+        else:
+            return NotImplemented
+
+    def __gt__(self, other):
+        if isinstance(other, (int, float)):
+            if self.start > other:
+                return intervalMembership(True, self.is_valid)
+            elif self.end < other:
+                return intervalMembership(False, self.is_valid)
+            else:
+                return intervalMembership(None, self.is_valid)
+        elif isinstance(other, interval):
+            return other.__lt__(self)
+        else:
+            return NotImplemented
+
+    def __eq__(self, other):
+        if isinstance(other, (int, float)):
+            if self.start == other and self.end == other:
+                return intervalMembership(True, self.is_valid)
+            if other in self:
+                return intervalMembership(None, self.is_valid)
+            else:
+                return intervalMembership(False, self.is_valid)
+
+        if isinstance(other, interval):
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            if self.start == other.start and self.end == other.end:
+                return intervalMembership(True, valid)
+            elif self.__lt__(other)[0] is not None:
+                return intervalMembership(False, valid)
+            else:
+                return intervalMembership(None, valid)
+        else:
+            return NotImplemented
+
+    def __ne__(self, other):
+        if isinstance(other, (int, float)):
+            if self.start == other and self.end == other:
+                return intervalMembership(False, self.is_valid)
+            if other in self:
+                return intervalMembership(None, self.is_valid)
+            else:
+                return intervalMembership(True, self.is_valid)
+
+        if isinstance(other, interval):
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            if self.start == other.start and self.end == other.end:
+                return intervalMembership(False, valid)
+            if not self.__lt__(other)[0] is None:
+                return intervalMembership(True, valid)
+            return intervalMembership(None, valid)
+        else:
+            return NotImplemented
+
+    def __le__(self, other):
+        if isinstance(other, (int, float)):
+            if self.end <= other:
+                return intervalMembership(True, self.is_valid)
+            if self.start > other:
+                return intervalMembership(False, self.is_valid)
+            else:
+                return intervalMembership(None, self.is_valid)
+
+        if isinstance(other, interval):
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            if self.end <= other.start:
+                return intervalMembership(True, valid)
+            if self.start > other.end:
+                return intervalMembership(False, valid)
+            return intervalMembership(None, valid)
+        else:
+            return NotImplemented
+
+    def __ge__(self, other):
+        if isinstance(other, (int, float)):
+            if self.start >= other:
+                return intervalMembership(True, self.is_valid)
+            elif self.end < other:
+                return intervalMembership(False, self.is_valid)
+            else:
+                return intervalMembership(None, self.is_valid)
+        elif isinstance(other, interval):
+            return other.__le__(self)
+
+    def __add__(self, other):
+        if isinstance(other, (int, float)):
+            if self.is_valid:
+                return interval(self.start + other, self.end + other)
+            else:
+                start = self.start + other
+                end = self.end + other
+                return interval(start, end, is_valid=self.is_valid)
+
+        elif isinstance(other, interval):
+            start = self.start + other.start
+            end = self.end + other.end
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            return interval(start, end, is_valid=valid)
+        else:
+            return NotImplemented
+
+    __radd__ = __add__
+
+    def __sub__(self, other):
+        if isinstance(other, (int, float)):
+            start = self.start - other
+            end = self.end - other
+            return interval(start, end, is_valid=self.is_valid)
+
+        elif isinstance(other, interval):
+            start = self.start - other.end
+            end = self.end - other.start
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            return interval(start, end, is_valid=valid)
+        else:
+            return NotImplemented
+
+    def __rsub__(self, other):
+        if isinstance(other, (int, float)):
+            start = other - self.end
+            end = other - self.start
+            return interval(start, end, is_valid=self.is_valid)
+        elif isinstance(other, interval):
+            return other.__sub__(self)
+        else:
+            return NotImplemented
+
+    def __neg__(self):
+        if self.is_valid:
+            return interval(-self.end, -self.start)
+        else:
+            return interval(-self.end, -self.start, is_valid=self.is_valid)
+
+    def __mul__(self, other):
+        if isinstance(other, interval):
+            if self.is_valid is False or other.is_valid is False:
+                return interval(-float('inf'), float('inf'), is_valid=False)
+            elif self.is_valid is None or other.is_valid is None:
+                return interval(-float('inf'), float('inf'), is_valid=None)
+            else:
+                inters = []
+                inters.append(self.start * other.start)
+                inters.append(self.end * other.start)
+                inters.append(self.start * other.end)
+                inters.append(self.end * other.end)
+                start = min(inters)
+                end = max(inters)
+                return interval(start, end)
+        elif isinstance(other, (int, float)):
+            return interval(self.start*other, self.end*other, is_valid=self.is_valid)
+        else:
+            return NotImplemented
+
+    __rmul__ = __mul__
+
+    def __contains__(self, other):
+        if isinstance(other, (int, float)):
+            return self.start <= other and self.end >= other
+        else:
+            return self.start <= other.start and other.end <= self.end
+
+    def __rtruediv__(self, other):
+        if isinstance(other, (int, float)):
+            other = interval(other)
+            return other.__truediv__(self)
+        elif isinstance(other, interval):
+            return other.__truediv__(self)
+        else:
+            return NotImplemented
+
+    def __truediv__(self, other):
+        # Both None and False are handled
+        if not self.is_valid:
+            # Don't divide as the value is not valid
+            return interval(-float('inf'), float('inf'), is_valid=self.is_valid)
+        if isinstance(other, (int, float)):
+            if other == 0:
+                # Divide by zero encountered. valid nowhere
+                return interval(-float('inf'), float('inf'), is_valid=False)
+            else:
+                return interval(self.start / other, self.end / other)
+
+        elif isinstance(other, interval):
+            if other.is_valid is False or self.is_valid is False:
+                return interval(-float('inf'), float('inf'), is_valid=False)
+            elif other.is_valid is None or self.is_valid is None:
+                return interval(-float('inf'), float('inf'), is_valid=None)
+            else:
+               # denominator contains both signs, i.e. being divided by zero
+               # return the whole real line with is_valid = None
+                if 0 in other:
+                    return interval(-float('inf'), float('inf'), is_valid=None)
+
+                # denominator negative
+                this = self
+                if other.end < 0:
+                    this = -this
+                    other = -other
+
+                # denominator positive
+                inters = []
+                inters.append(this.start / other.start)
+                inters.append(this.end / other.start)
+                inters.append(this.start / other.end)
+                inters.append(this.end / other.end)
+                start = max(inters)
+                end = min(inters)
+                return interval(start, end)
+        else:
+            return NotImplemented
+
+    def __pow__(self, other):
+        # Implements only power to an integer.
+        from .lib_interval import exp, log
+        if not self.is_valid:
+            return self
+        if isinstance(other, interval):
+            return exp(other * log(self))
+        elif isinstance(other, (float, int)):
+            if other < 0:
+                return 1 / self.__pow__(abs(other))
+            else:
+                if int_valued(other):
+                    return _pow_int(self, other)
+                else:
+                    return _pow_float(self, other)
+        else:
+            return NotImplemented
+
+    def __rpow__(self, other):
+        if isinstance(other, (float, int)):
+            if not self.is_valid:
+                #Don't do anything
+                return self
+            elif other < 0:
+                if self.width > 0:
+                    return interval(-float('inf'), float('inf'), is_valid=False)
+                else:
+                    power_rational = nsimplify(self.start)
+                    num, denom = power_rational.as_numer_denom()
+                    if denom % 2 == 0:
+                        return interval(-float('inf'), float('inf'),
+                                        is_valid=False)
+                    else:
+                        start = -abs(other)**self.start
+                        end = start
+                        return interval(start, end)
+            else:
+                return interval(other**self.start, other**self.end)
+        elif isinstance(other, interval):
+            return other.__pow__(self)
+        else:
+            return NotImplemented
+
+    def __hash__(self):
+        return hash((self.is_valid, self.start, self.end))
+
+
+def _pow_float(inter, power):
+    """Evaluates an interval raised to a floating point."""
+    power_rational = nsimplify(power)
+    num, denom = power_rational.as_numer_denom()
+    if num % 2 == 0:
+        start = abs(inter.start)**power
+        end = abs(inter.end)**power
+        if start < 0:
+            ret = interval(0, max(start, end))
+        else:
+            ret = interval(start, end)
+        return ret
+    elif denom % 2 == 0:
+        if inter.end < 0:
+            return interval(-float('inf'), float('inf'), is_valid=False)
+        elif inter.start < 0:
+            return interval(0, inter.end**power, is_valid=None)
+        else:
+            return interval(inter.start**power, inter.end**power)
+    else:
+        if inter.start < 0:
+            start = -abs(inter.start)**power
+        else:
+            start = inter.start**power
+
+        if inter.end < 0:
+            end = -abs(inter.end)**power
+        else:
+            end = inter.end**power
+
+        return interval(start, end, is_valid=inter.is_valid)
+
+
+def _pow_int(inter, power):
+    """Evaluates an interval raised to an integer power"""
+    power = int(power)
+    if power & 1:
+        return interval(inter.start**power, inter.end**power)
+    else:
+        if inter.start < 0 and inter.end > 0:
+            start = 0
+            end = max(inter.start**power, inter.end**power)
+            return interval(start, end)
+        else:
+            return interval(inter.start**power, inter.end**power)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/intervalmath/interval_membership.py

@@ -0,0 +1,78 @@
+from sympy.core.logic import fuzzy_and, fuzzy_or, fuzzy_not, fuzzy_xor
+
+
+class intervalMembership:
+    """Represents a boolean expression returned by the comparison of
+    the interval object.
+
+    Parameters
+    ==========
+
+    (a, b) : (bool, bool)
+        The first value determines the comparison as follows:
+        - True: If the comparison is True throughout the intervals.
+        - False: If the comparison is False throughout the intervals.
+        - None: If the comparison is True for some part of the intervals.
+
+        The second value is determined as follows:
+        - True: If both the intervals in comparison are valid.
+        - False: If at least one of the intervals is False, else
+        - None
+    """
+    def __init__(self, a, b):
+        self._wrapped = (a, b)
+
+    def __getitem__(self, i):
+        try:
+            return self._wrapped[i]
+        except IndexError:
+            raise IndexError(
+                "{} must be a valid indexing for the 2-tuple."
+                .format(i))
+
+    def __len__(self):
+        return 2
+
+    def __iter__(self):
+        return iter(self._wrapped)
+
+    def __str__(self):
+        return "intervalMembership({}, {})".format(*self)
+    __repr__ = __str__
+
+    def __and__(self, other):
+        if not isinstance(other, intervalMembership):
+            raise ValueError(
+                "The comparison is not supported for {}.".format(other))
+
+        a1, b1 = self
+        a2, b2 = other
+        return intervalMembership(fuzzy_and([a1, a2]), fuzzy_and([b1, b2]))
+
+    def __or__(self, other):
+        if not isinstance(other, intervalMembership):
+            raise ValueError(
+                "The comparison is not supported for {}.".format(other))
+
+        a1, b1 = self
+        a2, b2 = other
+        return intervalMembership(fuzzy_or([a1, a2]), fuzzy_and([b1, b2]))
+
+    def __invert__(self):
+        a, b = self
+        return intervalMembership(fuzzy_not(a), b)
+
+    def __xor__(self, other):
+        if not isinstance(other, intervalMembership):
+            raise ValueError(
+                "The comparison is not supported for {}.".format(other))
+
+        a1, b1 = self
+        a2, b2 = other
+        return intervalMembership(fuzzy_xor([a1, a2]), fuzzy_and([b1, b2]))
+
+    def __eq__(self, other):
+        return self._wrapped == other
+
+    def __ne__(self, other):
+        return self._wrapped != other

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/intervalmath/lib_interval.py

@@ -0,0 +1,452 @@
+""" The module contains implemented functions for interval arithmetic."""
+from functools import reduce
+
+from sympy.plotting.intervalmath import interval
+from sympy.external import import_module
+
+
+def Abs(x):
+    if isinstance(x, (int, float)):
+        return interval(abs(x))
+    elif isinstance(x, interval):
+        if x.start < 0 and x.end > 0:
+            return interval(0, max(abs(x.start), abs(x.end)), is_valid=x.is_valid)
+        else:
+            return interval(abs(x.start), abs(x.end))
+    else:
+        raise NotImplementedError
+
+#Monotonic
+
+
+def exp(x):
+    """evaluates the exponential of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.exp(x), np.exp(x))
+    elif isinstance(x, interval):
+        return interval(np.exp(x.start), np.exp(x.end), is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+#Monotonic
+def log(x):
+    """evaluates the natural logarithm of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        if x <= 0:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            return interval(np.log(x))
+    elif isinstance(x, interval):
+        if not x.is_valid:
+            return interval(-np.inf, np.inf, is_valid=x.is_valid)
+        elif x.end <= 0:
+            return interval(-np.inf, np.inf, is_valid=False)
+        elif x.start <= 0:
+            return interval(-np.inf, np.inf, is_valid=None)
+
+        return interval(np.log(x.start), np.log(x.end))
+    else:
+        raise NotImplementedError
+
+
+#Monotonic
+def log10(x):
+    """evaluates the logarithm to the base 10 of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        if x <= 0:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            return interval(np.log10(x))
+    elif isinstance(x, interval):
+        if not x.is_valid:
+            return interval(-np.inf, np.inf, is_valid=x.is_valid)
+        elif x.end <= 0:
+            return interval(-np.inf, np.inf, is_valid=False)
+        elif x.start <= 0:
+            return interval(-np.inf, np.inf, is_valid=None)
+        return interval(np.log10(x.start), np.log10(x.end))
+    else:
+        raise NotImplementedError
+
+
+#Monotonic
+def atan(x):
+    """evaluates the tan inverse of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.arctan(x))
+    elif isinstance(x, interval):
+        start = np.arctan(x.start)
+        end = np.arctan(x.end)
+        return interval(start, end, is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+#periodic
+def sin(x):
+    """evaluates the sine of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.sin(x))
+    elif isinstance(x, interval):
+        if not x.is_valid:
+            return interval(-1, 1, is_valid=x.is_valid)
+        na, __ = divmod(x.start, np.pi / 2.0)
+        nb, __ = divmod(x.end, np.pi / 2.0)
+        start = min(np.sin(x.start), np.sin(x.end))
+        end = max(np.sin(x.start), np.sin(x.end))
+        if nb - na > 4:
+            return interval(-1, 1, is_valid=x.is_valid)
+        elif na == nb:
+            return interval(start, end, is_valid=x.is_valid)
+        else:
+            if (na - 1) // 4 != (nb - 1) // 4:
+                #sin has max
+                end = 1
+            if (na - 3) // 4 != (nb - 3) // 4:
+                #sin has min
+                start = -1
+            return interval(start, end)
+    else:
+        raise NotImplementedError
+
+
+#periodic
+def cos(x):
+    """Evaluates the cos of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.sin(x))
+    elif isinstance(x, interval):
+        if not (np.isfinite(x.start) and np.isfinite(x.end)):
+            return interval(-1, 1, is_valid=x.is_valid)
+        na, __ = divmod(x.start, np.pi / 2.0)
+        nb, __ = divmod(x.end, np.pi / 2.0)
+        start = min(np.cos(x.start), np.cos(x.end))
+        end = max(np.cos(x.start), np.cos(x.end))
+        if nb - na > 4:
+            #differ more than 2*pi
+            return interval(-1, 1, is_valid=x.is_valid)
+        elif na == nb:
+            #in the same quadarant
+            return interval(start, end, is_valid=x.is_valid)
+        else:
+            if (na) // 4 != (nb) // 4:
+                #cos has max
+                end = 1
+            if (na - 2) // 4 != (nb - 2) // 4:
+                #cos has min
+                start = -1
+            return interval(start, end, is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+def tan(x):
+    """Evaluates the tan of an interval"""
+    return sin(x) / cos(x)
+
+
+#Monotonic
+def sqrt(x):
+    """Evaluates the square root of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        if x > 0:
+            return interval(np.sqrt(x))
+        else:
+            return interval(-np.inf, np.inf, is_valid=False)
+    elif isinstance(x, interval):
+        #Outside the domain
+        if x.end < 0:
+            return interval(-np.inf, np.inf, is_valid=False)
+        #Partially outside the domain
+        elif x.start < 0:
+            return interval(-np.inf, np.inf, is_valid=None)
+        else:
+            return interval(np.sqrt(x.start), np.sqrt(x.end),
+                    is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+def imin(*args):
+    """Evaluates the minimum of a list of intervals"""
+    np = import_module('numpy')
+    if not all(isinstance(arg, (int, float, interval)) for arg in args):
+        return NotImplementedError
+    else:
+        new_args = [a for a in args if isinstance(a, (int, float))
+                    or a.is_valid]
+        if len(new_args) == 0:
+            if all(a.is_valid is False for a in args):
+                return interval(-np.inf, np.inf, is_valid=False)
+            else:
+                return interval(-np.inf, np.inf, is_valid=None)
+        start_array = [a if isinstance(a, (int, float)) else a.start
+                       for a in new_args]
+
+        end_array = [a if isinstance(a, (int, float)) else a.end
+                     for a in new_args]
+        return interval(min(start_array), min(end_array))
+
+
+def imax(*args):
+    """Evaluates the maximum of a list of intervals"""
+    np = import_module('numpy')
+    if not all(isinstance(arg, (int, float, interval)) for arg in args):
+        return NotImplementedError
+    else:
+        new_args = [a for a in args if isinstance(a, (int, float))
+                    or a.is_valid]
+        if len(new_args) == 0:
+            if all(a.is_valid is False for a in args):
+                return interval(-np.inf, np.inf, is_valid=False)
+            else:
+                return interval(-np.inf, np.inf, is_valid=None)
+        start_array = [a if isinstance(a, (int, float)) else a.start
+                       for a in new_args]
+
+        end_array = [a if isinstance(a, (int, float)) else a.end
+                     for a in new_args]
+
+        return interval(max(start_array), max(end_array))
+
+
+#Monotonic
+def sinh(x):
+    """Evaluates the hyperbolic sine of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.sinh(x), np.sinh(x))
+    elif isinstance(x, interval):
+        return interval(np.sinh(x.start), np.sinh(x.end), is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+def cosh(x):
+    """Evaluates the hyperbolic cos of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.cosh(x), np.cosh(x))
+    elif isinstance(x, interval):
+        #both signs
+        if x.start < 0 and x.end > 0:
+            end = max(np.cosh(x.start), np.cosh(x.end))
+            return interval(1, end, is_valid=x.is_valid)
+        else:
+            #Monotonic
+            start = np.cosh(x.start)
+            end = np.cosh(x.end)
+            return interval(start, end, is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+#Monotonic
+def tanh(x):
+    """Evaluates the hyperbolic tan of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.tanh(x), np.tanh(x))
+    elif isinstance(x, interval):
+        return interval(np.tanh(x.start), np.tanh(x.end), is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+def asin(x):
+    """Evaluates the inverse sine of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        #Outside the domain
+        if abs(x) > 1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            return interval(np.arcsin(x), np.arcsin(x))
+    elif isinstance(x, interval):
+        #Outside the domain
+        if x.is_valid is False or x.start > 1 or x.end < -1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        #Partially outside the domain
+        elif x.start < -1 or x.end > 1:
+            return interval(-np.inf, np.inf, is_valid=None)
+        else:
+            start = np.arcsin(x.start)
+            end = np.arcsin(x.end)
+            return interval(start, end, is_valid=x.is_valid)
+
+
+def acos(x):
+    """Evaluates the inverse cos of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        if abs(x) > 1:
+            #Outside the domain
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            return interval(np.arccos(x), np.arccos(x))
+    elif isinstance(x, interval):
+        #Outside the domain
+        if x.is_valid is False or x.start > 1 or x.end < -1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        #Partially outside the domain
+        elif x.start < -1 or x.end > 1:
+            return interval(-np.inf, np.inf, is_valid=None)
+        else:
+            start = np.arccos(x.start)
+            end = np.arccos(x.end)
+            return interval(start, end, is_valid=x.is_valid)
+
+
+def ceil(x):
+    """Evaluates the ceiling of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.ceil(x))
+    elif isinstance(x, interval):
+        if x.is_valid is False:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            start = np.ceil(x.start)
+            end = np.ceil(x.end)
+            #Continuous over the interval
+            if start == end:
+                return interval(start, end, is_valid=x.is_valid)
+            else:
+                #Not continuous over the interval
+                return interval(start, end, is_valid=None)
+    else:
+        return NotImplementedError
+
+
+def floor(x):
+    """Evaluates the floor of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.floor(x))
+    elif isinstance(x, interval):
+        if x.is_valid is False:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            start = np.floor(x.start)
+            end = np.floor(x.end)
+            #continuous over the argument
+            if start == end:
+                return interval(start, end, is_valid=x.is_valid)
+            else:
+                #not continuous over the interval
+                return interval(start, end, is_valid=None)
+    else:
+        return NotImplementedError
+
+
+def acosh(x):
+    """Evaluates the inverse hyperbolic cosine of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        #Outside the domain
+        if x < 1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            return interval(np.arccosh(x))
+    elif isinstance(x, interval):
+        #Outside the domain
+        if x.end < 1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        #Partly outside the domain
+        elif x.start < 1:
+            return interval(-np.inf, np.inf, is_valid=None)
+        else:
+            start = np.arccosh(x.start)
+            end = np.arccosh(x.end)
+            return interval(start, end, is_valid=x.is_valid)
+    else:
+        return NotImplementedError
+
+
+#Monotonic
+def asinh(x):
+    """Evaluates the inverse hyperbolic sine of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.arcsinh(x))
+    elif isinstance(x, interval):
+        start = np.arcsinh(x.start)
+        end = np.arcsinh(x.end)
+        return interval(start, end, is_valid=x.is_valid)
+    else:
+        return NotImplementedError
+
+
+def atanh(x):
+    """Evaluates the inverse hyperbolic tangent of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        #Outside the domain
+        if abs(x) >= 1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            return interval(np.arctanh(x))
+    elif isinstance(x, interval):
+        #outside the domain
+        if x.is_valid is False or x.start >= 1 or x.end <= -1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        #partly outside the domain
+        elif x.start <= -1 or x.end >= 1:
+            return interval(-np.inf, np.inf, is_valid=None)
+        else:
+            start = np.arctanh(x.start)
+            end = np.arctanh(x.end)
+            return interval(start, end, is_valid=x.is_valid)
+    else:
+        return NotImplementedError
+
+
+#Three valued logic for interval plotting.
+
+def And(*args):
+    """Defines the three valued ``And`` behaviour for a 2-tuple of
+     three valued logic values"""
+    def reduce_and(cmp_intervala, cmp_intervalb):
+        if cmp_intervala[0] is False or cmp_intervalb[0] is False:
+            first = False
+        elif cmp_intervala[0] is None or cmp_intervalb[0] is None:
+            first = None
+        else:
+            first = True
+        if cmp_intervala[1] is False or cmp_intervalb[1] is False:
+            second = False
+        elif cmp_intervala[1] is None or cmp_intervalb[1] is None:
+            second = None
+        else:
+            second = True
+        return (first, second)
+    return reduce(reduce_and, args)
+
+
+def Or(*args):
+    """Defines the three valued ``Or`` behaviour for a 2-tuple of
+     three valued logic values"""
+    def reduce_or(cmp_intervala, cmp_intervalb):
+        if cmp_intervala[0] is True or cmp_intervalb[0] is True:
+            first = True
+        elif cmp_intervala[0] is None or cmp_intervalb[0] is None:
+            first = None
+        else:
+            first = False
+
+        if cmp_intervala[1] is True or cmp_intervalb[1] is True:
+            second = True
+        elif cmp_intervala[1] is None or cmp_intervalb[1] is None:
+            second = None
+        else:
+            second = False
+        return (first, second)
+    return reduce(reduce_or, args)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/intervalmath/tests/test_interval_functions.py

@@ -0,0 +1,415 @@
+from sympy.external import import_module
+from sympy.plotting.intervalmath import (
+    Abs, acos, acosh, And, asin, asinh, atan, atanh, ceil, cos, cosh,
+    exp, floor, imax, imin, interval, log, log10, Or, sin, sinh, sqrt,
+    tan, tanh,
+)
+
+np = import_module('numpy')
+if not np:
+    disabled = True
+
+
+#requires Numpy. Hence included in interval_functions
+
+
+def test_interval_pow():
+    a = 2**interval(1, 2) == interval(2, 4)
+    assert a == (True, True)
+    a = interval(1, 2)**interval(1, 2) == interval(1, 4)
+    assert a == (True, True)
+    a = interval(-1, 1)**interval(0.5, 2)
+    assert a.is_valid is None
+    a = interval(-2, -1) ** interval(1, 2)
+    assert a.is_valid is False
+    a = interval(-2, -1) ** (1.0 / 2)
+    assert a.is_valid is False
+    a = interval(-1, 1)**(1.0 / 2)
+    assert a.is_valid is None
+    a = interval(-1, 1)**(1.0 / 3) == interval(-1, 1)
+    assert a == (True, True)
+    a = interval(-1, 1)**2 == interval(0, 1)
+    assert a == (True, True)
+    a = interval(-1, 1) ** (1.0 / 29) == interval(-1, 1)
+    assert a == (True, True)
+    a = -2**interval(1, 1) == interval(-2, -2)
+    assert a == (True, True)
+
+    a = interval(1, 2, is_valid=False)**2
+    assert a.is_valid is False
+
+    a = (-3)**interval(1, 2)
+    assert a.is_valid is False
+    a = (-4)**interval(0.5, 0.5)
+    assert a.is_valid is False
+    assert ((-3)**interval(1, 1) == interval(-3, -3)) == (True, True)
+
+    a = interval(8, 64)**(2.0 / 3)
+    assert abs(a.start - 4) < 1e-10  # eps
+    assert abs(a.end - 16) < 1e-10
+    a = interval(-8, 64)**(2.0 / 3)
+    assert abs(a.start - 4) < 1e-10  # eps
+    assert abs(a.end - 16) < 1e-10
+
+
+def test_exp():
+    a = exp(interval(-np.inf, 0))
+    assert a.start == np.exp(-np.inf)
+    assert a.end == np.exp(0)
+    a = exp(interval(1, 2))
+    assert a.start == np.exp(1)
+    assert a.end == np.exp(2)
+    a = exp(1)
+    assert a.start == np.exp(1)
+    assert a.end == np.exp(1)
+
+
+def test_log():
+    a = log(interval(1, 2))
+    assert a.start == 0
+    assert a.end == np.log(2)
+    a = log(interval(-1, 1))
+    assert a.is_valid is None
+    a = log(interval(-3, -1))
+    assert a.is_valid is False
+    a = log(-3)
+    assert a.is_valid is False
+    a = log(2)
+    assert a.start == np.log(2)
+    assert a.end == np.log(2)
+
+
+def test_log10():
+    a = log10(interval(1, 2))
+    assert a.start == 0
+    assert a.end == np.log10(2)
+    a = log10(interval(-1, 1))
+    assert a.is_valid is None
+    a = log10(interval(-3, -1))
+    assert a.is_valid is False
+    a = log10(-3)
+    assert a.is_valid is False
+    a = log10(2)
+    assert a.start == np.log10(2)
+    assert a.end == np.log10(2)
+
+
+def test_atan():
+    a = atan(interval(0, 1))
+    assert a.start == np.arctan(0)
+    assert a.end == np.arctan(1)
+    a = atan(1)
+    assert a.start == np.arctan(1)
+    assert a.end == np.arctan(1)
+
+
+def test_sin():
+    a = sin(interval(0, np.pi / 4))
+    assert a.start == np.sin(0)
+    assert a.end == np.sin(np.pi / 4)
+
+    a = sin(interval(-np.pi / 4, np.pi / 4))
+    assert a.start == np.sin(-np.pi / 4)
+    assert a.end == np.sin(np.pi / 4)
+
+    a = sin(interval(np.pi / 4, 3 * np.pi / 4))
+    assert a.start == np.sin(np.pi / 4)
+    assert a.end == 1
+
+    a = sin(interval(7 * np.pi / 6, 7 * np.pi / 4))
+    assert a.start == -1
+    assert a.end == np.sin(7 * np.pi / 6)
+
+    a = sin(interval(0, 3 * np.pi))
+    assert a.start == -1
+    assert a.end == 1
+
+    a = sin(interval(np.pi / 3, 7 * np.pi / 4))
+    assert a.start == -1
+    assert a.end == 1
+
+    a = sin(np.pi / 4)
+    assert a.start == np.sin(np.pi / 4)
+    assert a.end == np.sin(np.pi / 4)
+
+    a = sin(interval(1, 2, is_valid=False))
+    assert a.is_valid is False
+
+
+def test_cos():
+    a = cos(interval(0, np.pi / 4))
+    assert a.start == np.cos(np.pi / 4)
+    assert a.end == 1
+
+    a = cos(interval(-np.pi / 4, np.pi / 4))
+    assert a.start == np.cos(-np.pi / 4)
+    assert a.end == 1
+
+    a = cos(interval(np.pi / 4, 3 * np.pi / 4))
+    assert a.start == np.cos(3 * np.pi / 4)
+    assert a.end == np.cos(np.pi / 4)
+
+    a = cos(interval(3 * np.pi / 4, 5 * np.pi / 4))
+    assert a.start == -1
+    assert a.end == np.cos(3 * np.pi / 4)
+
+    a = cos(interval(0, 3 * np.pi))
+    assert a.start == -1
+    assert a.end == 1
+
+    a = cos(interval(- np.pi / 3, 5 * np.pi / 4))
+    assert a.start == -1
+    assert a.end == 1
+
+    a = cos(interval(1, 2, is_valid=False))
+    assert a.is_valid is False
+
+
+def test_tan():
+    a = tan(interval(0, np.pi / 4))
+    assert a.start == 0
+    # must match lib_interval definition of tan:
+    assert a.end == np.sin(np.pi / 4)/np.cos(np.pi / 4)
+
+    a = tan(interval(np.pi / 4, 3 * np.pi / 4))
+    #discontinuity
+    assert a.is_valid is None
+
+
+def test_sqrt():
+    a = sqrt(interval(1, 4))
+    assert a.start == 1
+    assert a.end == 2
+
+    a = sqrt(interval(0.01, 1))
+    assert a.start == np.sqrt(0.01)
+    assert a.end == 1
+
+    a = sqrt(interval(-1, 1))
+    assert a.is_valid is None
+
+    a = sqrt(interval(-3, -1))
+    assert a.is_valid is False
+
+    a = sqrt(4)
+    assert (a == interval(2, 2)) == (True, True)
+
+    a = sqrt(-3)
+    assert a.is_valid is False
+
+
+def test_imin():
+    a = imin(interval(1, 3), interval(2, 5), interval(-1, 3))
+    assert a.start == -1
+    assert a.end == 3
+
+    a = imin(-2, interval(1, 4))
+    assert a.start == -2
+    assert a.end == -2
+
+    a = imin(5, interval(3, 4), interval(-2, 2, is_valid=False))
+    assert a.start == 3
+    assert a.end == 4
+
+
+def test_imax():
+    a = imax(interval(-2, 2), interval(2, 7), interval(-3, 9))
+    assert a.start == 2
+    assert a.end == 9
+
+    a = imax(8, interval(1, 4))
+    assert a.start == 8
+    assert a.end == 8
+
+    a = imax(interval(1, 2), interval(3, 4), interval(-2, 2, is_valid=False))
+    assert a.start == 3
+    assert a.end == 4
+
+
+def test_sinh():
+    a = sinh(interval(-1, 1))
+    assert a.start == np.sinh(-1)
+    assert a.end == np.sinh(1)
+
+    a = sinh(1)
+    assert a.start == np.sinh(1)
+    assert a.end == np.sinh(1)
+
+
+def test_cosh():
+    a = cosh(interval(1, 2))
+    assert a.start == np.cosh(1)
+    assert a.end == np.cosh(2)
+    a = cosh(interval(-2, -1))
+    assert a.start == np.cosh(-1)
+    assert a.end == np.cosh(-2)
+
+    a = cosh(interval(-2, 1))
+    assert a.start == 1
+    assert a.end == np.cosh(-2)
+
+    a = cosh(1)
+    assert a.start == np.cosh(1)
+    assert a.end == np.cosh(1)
+
+
+def test_tanh():
+    a = tanh(interval(-3, 3))
+    assert a.start == np.tanh(-3)
+    assert a.end == np.tanh(3)
+
+    a = tanh(3)
+    assert a.start == np.tanh(3)
+    assert a.end == np.tanh(3)
+
+
+def test_asin():
+    a = asin(interval(-0.5, 0.5))
+    assert a.start == np.arcsin(-0.5)
+    assert a.end == np.arcsin(0.5)
+
+    a = asin(interval(-1.5, 1.5))
+    assert a.is_valid is None
+    a = asin(interval(-2, -1.5))
+    assert a.is_valid is False
+
+    a = asin(interval(0, 2))
+    assert a.is_valid is None
+
+    a = asin(interval(2, 5))
+    assert a.is_valid is False
+
+    a = asin(0.5)
+    assert a.start == np.arcsin(0.5)
+    assert a.end == np.arcsin(0.5)
+
+    a = asin(1.5)
+    assert a.is_valid is False
+
+
+def test_acos():
+    a = acos(interval(-0.5, 0.5))
+    assert a.start == np.arccos(0.5)
+    assert a.end == np.arccos(-0.5)
+
+    a = acos(interval(-1.5, 1.5))
+    assert a.is_valid is None
+    a = acos(interval(-2, -1.5))
+    assert a.is_valid is False
+
+    a = acos(interval(0, 2))
+    assert a.is_valid is None
+
+    a = acos(interval(2, 5))
+    assert a.is_valid is False
+
+    a = acos(0.5)
+    assert a.start == np.arccos(0.5)
+    assert a.end == np.arccos(0.5)
+
+    a = acos(1.5)
+    assert a.is_valid is False
+
+
+def test_ceil():
+    a = ceil(interval(0.2, 0.5))
+    assert a.start == 1
+    assert a.end == 1
+
+    a = ceil(interval(0.5, 1.5))
+    assert a.start == 1
+    assert a.end == 2
+    assert a.is_valid is None
+
+    a = ceil(interval(-5, 5))
+    assert a.is_valid is None
+
+    a = ceil(5.4)
+    assert a.start == 6
+    assert a.end == 6
+
+
+def test_floor():
+    a = floor(interval(0.2, 0.5))
+    assert a.start == 0
+    assert a.end == 0
+
+    a = floor(interval(0.5, 1.5))
+    assert a.start == 0
+    assert a.end == 1
+    assert a.is_valid is None
+
+    a = floor(interval(-5, 5))
+    assert a.is_valid is None
+
+    a = floor(5.4)
+    assert a.start == 5
+    assert a.end == 5
+
+
+def test_asinh():
+    a = asinh(interval(1, 2))
+    assert a.start == np.arcsinh(1)
+    assert a.end == np.arcsinh(2)
+
+    a = asinh(0.5)
+    assert a.start == np.arcsinh(0.5)
+    assert a.end == np.arcsinh(0.5)
+
+
+def test_acosh():
+    a = acosh(interval(3, 5))
+    assert a.start == np.arccosh(3)
+    assert a.end == np.arccosh(5)
+
+    a = acosh(interval(0, 3))
+    assert a.is_valid is None
+    a = acosh(interval(-3, 0.5))
+    assert a.is_valid is False
+
+    a = acosh(0.5)
+    assert a.is_valid is False
+
+    a = acosh(2)
+    assert a.start == np.arccosh(2)
+    assert a.end == np.arccosh(2)
+
+
+def test_atanh():
+    a = atanh(interval(-0.5, 0.5))
+    assert a.start == np.arctanh(-0.5)
+    assert a.end == np.arctanh(0.5)
+
+    a = atanh(interval(0, 3))
+    assert a.is_valid is None
+
+    a = atanh(interval(-3, -2))
+    assert a.is_valid is False
+
+    a = atanh(0.5)
+    assert a.start == np.arctanh(0.5)
+    assert a.end == np.arctanh(0.5)
+
+    a = atanh(1.5)
+    assert a.is_valid is False
+
+
+def test_Abs():
+    assert (Abs(interval(-0.5, 0.5)) == interval(0, 0.5)) == (True, True)
+    assert (Abs(interval(-3, -2)) == interval(2, 3)) == (True, True)
+    assert (Abs(-3) == interval(3, 3)) == (True, True)
+
+
+def test_And():
+    args = [(True, True), (True, False), (True, None)]
+    assert And(*args) == (True, False)
+
+    args = [(False, True), (None, None), (True, True)]
+    assert And(*args) == (False, None)
+
+
+def test_Or():
+    args = [(True, True), (True, False), (False, None)]
+    assert Or(*args) == (True, True)
+    args = [(None, None), (False, None), (False, False)]
+    assert Or(*args) == (None, None)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/intervalmath/tests/test_interval_membership.py

@@ -0,0 +1,150 @@
+from sympy.core.symbol import Symbol
+from sympy.plotting.intervalmath import interval
+from sympy.plotting.intervalmath.interval_membership import intervalMembership
+from sympy.plotting.experimental_lambdify import experimental_lambdify
+from sympy.testing.pytest import raises
+
+
+def test_creation():
+    assert intervalMembership(True, True)
+    raises(TypeError, lambda: intervalMembership(True))
+    raises(TypeError, lambda: intervalMembership(True, True, True))
+
+
+def test_getitem():
+    a = intervalMembership(True, False)
+    assert a[0] is True
+    assert a[1] is False
+    raises(IndexError, lambda: a[2])
+
+
+def test_str():
+    a = intervalMembership(True, False)
+    assert str(a) == 'intervalMembership(True, False)'
+    assert repr(a) == 'intervalMembership(True, False)'
+
+
+def test_equivalence():
+    a = intervalMembership(True, True)
+    b = intervalMembership(True, False)
+    assert (a == b) is False
+    assert (a != b) is True
+
+    a = intervalMembership(True, False)
+    b = intervalMembership(True, False)
+    assert (a == b) is True
+    assert (a != b) is False
+
+
+def test_not():
+    x = Symbol('x')
+
+    r1 = x > -1
+    r2 = x <= -1
+
+    i = interval
+
+    f1 = experimental_lambdify((x,), r1)
+    f2 = experimental_lambdify((x,), r2)
+
+    tt = i(-0.1, 0.1, is_valid=True)
+    tn = i(-0.1, 0.1, is_valid=None)
+    tf = i(-0.1, 0.1, is_valid=False)
+
+    assert f1(tt) == ~f2(tt)
+    assert f1(tn) == ~f2(tn)
+    assert f1(tf) == ~f2(tf)
+
+    nt = i(0.9, 1.1, is_valid=True)
+    nn = i(0.9, 1.1, is_valid=None)
+    nf = i(0.9, 1.1, is_valid=False)
+
+    assert f1(nt) == ~f2(nt)
+    assert f1(nn) == ~f2(nn)
+    assert f1(nf) == ~f2(nf)
+
+    ft = i(1.9, 2.1, is_valid=True)
+    fn = i(1.9, 2.1, is_valid=None)
+    ff = i(1.9, 2.1, is_valid=False)
+
+    assert f1(ft) == ~f2(ft)
+    assert f1(fn) == ~f2(fn)
+    assert f1(ff) == ~f2(ff)
+
+
+def test_boolean():
+    # There can be 9*9 test cases in full mapping of the cartesian product.
+    # But we only consider 3*3 cases for simplicity.
+    s = [
+        intervalMembership(False, False),
+        intervalMembership(None, None),
+        intervalMembership(True, True)
+    ]
+
+    # Reduced tests for 'And'
+    a1 = [
+        intervalMembership(False, False),
+        intervalMembership(False, False),
+        intervalMembership(False, False),
+        intervalMembership(False, False),
+        intervalMembership(None, None),
+        intervalMembership(None, None),
+        intervalMembership(False, False),
+        intervalMembership(None, None),
+        intervalMembership(True, True)
+    ]
+    a1_iter = iter(a1)
+    for i in range(len(s)):
+        for j in range(len(s)):
+            assert s[i] & s[j] == next(a1_iter)
+
+    # Reduced tests for 'Or'
+    a1 = [
+        intervalMembership(False, False),
+        intervalMembership(None, False),
+        intervalMembership(True, False),
+        intervalMembership(None, False),
+        intervalMembership(None, None),
+        intervalMembership(True, None),
+        intervalMembership(True, False),
+        intervalMembership(True, None),
+        intervalMembership(True, True)
+    ]
+    a1_iter = iter(a1)
+    for i in range(len(s)):
+        for j in range(len(s)):
+            assert s[i] | s[j] == next(a1_iter)
+
+    # Reduced tests for 'Xor'
+    a1 = [
+        intervalMembership(False, False),
+        intervalMembership(None, False),
+        intervalMembership(True, False),
+        intervalMembership(None, False),
+        intervalMembership(None, None),
+        intervalMembership(None, None),
+        intervalMembership(True, False),
+        intervalMembership(None, None),
+        intervalMembership(False, True)
+    ]
+    a1_iter = iter(a1)
+    for i in range(len(s)):
+        for j in range(len(s)):
+            assert s[i] ^ s[j] == next(a1_iter)
+
+    # Reduced tests for 'Not'
+    a1 = [
+        intervalMembership(True, False),
+        intervalMembership(None, None),
+        intervalMembership(False, True)
+    ]
+    a1_iter = iter(a1)
+    for i in range(len(s)):
+        assert ~s[i] == next(a1_iter)
+
+
+def test_boolean_errors():
+    a = intervalMembership(True, True)
+    raises(ValueError, lambda: a & 1)
+    raises(ValueError, lambda: a | 1)
+    raises(ValueError, lambda: a ^ 1)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/intervalmath/tests/test_intervalmath.py

@@ -0,0 +1,213 @@
+from sympy.plotting.intervalmath import interval
+from sympy.testing.pytest import raises
+
+
+def test_interval():
+    assert (interval(1, 1) == interval(1, 1, is_valid=True)) == (True, True)
+    assert (interval(1, 1) == interval(1, 1, is_valid=False)) == (True, False)
+    assert (interval(1, 1) == interval(1, 1, is_valid=None)) == (True, None)
+    assert (interval(1, 1.5) == interval(1, 2)) == (None, True)
+    assert (interval(0, 1) == interval(2, 3)) == (False, True)
+    assert (interval(0, 1) == interval(1, 2)) == (None, True)
+    assert (interval(1, 2) != interval(1, 2)) == (False, True)
+    assert (interval(1, 3) != interval(2, 3)) == (None, True)
+    assert (interval(1, 3) != interval(-5, -3)) == (True, True)
+    assert (
+        interval(1, 3, is_valid=False) != interval(-5, -3)) == (True, False)
+    assert (interval(1, 3, is_valid=None) != interval(-5, 3)) == (None, None)
+    assert (interval(4, 4) != 4) == (False, True)
+    assert (interval(1, 1) == 1) == (True, True)
+    assert (interval(1, 3, is_valid=False) == interval(1, 3)) == (True, False)
+    assert (interval(1, 3, is_valid=None) == interval(1, 3)) == (True, None)
+    inter = interval(-5, 5)
+    assert (interval(inter) == interval(-5, 5)) == (True, True)
+    assert inter.width == 10
+    assert 0 in inter
+    assert -5 in inter
+    assert 5 in inter
+    assert interval(0, 3) in inter
+    assert interval(-6, 2) not in inter
+    assert -5.05 not in inter
+    assert 5.3 not in inter
+    interb = interval(-float('inf'), float('inf'))
+    assert 0 in inter
+    assert inter in interb
+    assert interval(0, float('inf')) in interb
+    assert interval(-float('inf'), 5) in interb
+    assert interval(-1e50, 1e50) in interb
+    assert (
+        -interval(-1, -2, is_valid=False) == interval(1, 2)) == (True, False)
+    raises(ValueError, lambda: interval(1, 2, 3))
+
+
+def test_interval_add():
+    assert (interval(1, 2) + interval(2, 3) == interval(3, 5)) == (True, True)
+    assert (1 + interval(1, 2) == interval(2, 3)) == (True, True)
+    assert (interval(1, 2) + 1 == interval(2, 3)) == (True, True)
+    compare = (1 + interval(0, float('inf')) == interval(1, float('inf')))
+    assert compare == (True, True)
+    a = 1 + interval(2, 5, is_valid=False)
+    assert a.is_valid is False
+    a = 1 + interval(2, 5, is_valid=None)
+    assert a.is_valid is None
+    a = interval(2, 5, is_valid=False) + interval(3, 5, is_valid=None)
+    assert a.is_valid is False
+    a = interval(3, 5) + interval(-1, 1, is_valid=None)
+    assert a.is_valid is None
+    a = interval(2, 5, is_valid=False) + 1
+    assert a.is_valid is False
+
+
+def test_interval_sub():
+    assert (interval(1, 2) - interval(1, 5) == interval(-4, 1)) == (True, True)
+    assert (interval(1, 2) - 1 == interval(0, 1)) == (True, True)
+    assert (1 - interval(1, 2) == interval(-1, 0)) == (True, True)
+    a = 1 - interval(1, 2, is_valid=False)
+    assert a.is_valid is False
+    a = interval(1, 4, is_valid=None) - 1
+    assert a.is_valid is None
+    a = interval(1, 3, is_valid=False) - interval(1, 3)
+    assert a.is_valid is False
+    a = interval(1, 3, is_valid=None) - interval(1, 3)
+    assert a.is_valid is None
+
+
+def test_interval_inequality():
+    assert (interval(1, 2) < interval(3, 4)) == (True, True)
+    assert (interval(1, 2) < interval(2, 4)) == (None, True)
+    assert (interval(1, 2) < interval(-2, 0)) == (False, True)
+    assert (interval(1, 2) <= interval(2, 4)) == (True, True)
+    assert (interval(1, 2) <= interval(1.5, 6)) == (None, True)
+    assert (interval(2, 3) <= interval(1, 2)) == (None, True)
+    assert (interval(2, 3) <= interval(1, 1.5)) == (False, True)
+    assert (
+        interval(1, 2, is_valid=False) <= interval(-2, 0)) == (False, False)
+    assert (interval(1, 2, is_valid=None) <= interval(-2, 0)) == (False, None)
+    assert (interval(1, 2) <= 1.5) == (None, True)
+    assert (interval(1, 2) <= 3) == (True, True)
+    assert (interval(1, 2) <= 0) == (False, True)
+    assert (interval(5, 8) > interval(2, 3)) == (True, True)
+    assert (interval(2, 5) > interval(1, 3)) == (None, True)
+    assert (interval(2, 3) > interval(3.1, 5)) == (False, True)
+
+    assert (interval(-1, 1) == 0) == (None, True)
+    assert (interval(-1, 1) == 2) == (False, True)
+    assert (interval(-1, 1) != 0) == (None, True)
+    assert (interval(-1, 1) != 2) == (True, True)
+
+    assert (interval(3, 5) > 2) == (True, True)
+    assert (interval(3, 5) < 2) == (False, True)
+    assert (interval(1, 5) < 2) == (None, True)
+    assert (interval(1, 5) > 2) == (None, True)
+    assert (interval(0, 1) > 2) == (False, True)
+    assert (interval(1, 2) >= interval(0, 1)) == (True, True)
+    assert (interval(1, 2) >= interval(0, 1.5)) == (None, True)
+    assert (interval(1, 2) >= interval(3, 4)) == (False, True)
+    assert (interval(1, 2) >= 0) == (True, True)
+    assert (interval(1, 2) >= 1.2) == (None, True)
+    assert (interval(1, 2) >= 3) == (False, True)
+    assert (2 > interval(0, 1)) == (True, True)
+    a = interval(-1, 1, is_valid=False) < interval(2, 5, is_valid=None)
+    assert a == (True, False)
+    a = interval(-1, 1, is_valid=None) < interval(2, 5, is_valid=False)
+    assert a == (True, False)
+    a = interval(-1, 1, is_valid=None) < interval(2, 5, is_valid=None)
+    assert a == (True, None)
+    a = interval(-1, 1, is_valid=False) > interval(-5, -2, is_valid=None)
+    assert a == (True, False)
+    a = interval(-1, 1, is_valid=None) > interval(-5, -2, is_valid=False)
+    assert a == (True, False)
+    a = interval(-1, 1, is_valid=None) > interval(-5, -2, is_valid=None)
+    assert a == (True, None)
+
+
+def test_interval_mul():
+    assert (
+        interval(1, 5) * interval(2, 10) == interval(2, 50)) == (True, True)
+    a = interval(-1, 1) * interval(2, 10) == interval(-10, 10)
+    assert a == (True, True)
+
+    a = interval(-1, 1) * interval(-5, 3) == interval(-5, 5)
+    assert a == (True, True)
+
+    assert (interval(1, 3) * 2 == interval(2, 6)) == (True, True)
+    assert (3 * interval(-1, 2) == interval(-3, 6)) == (True, True)
+
+    a = 3 * interval(1, 2, is_valid=False)
+    assert a.is_valid is False
+
+    a = 3 * interval(1, 2, is_valid=None)
+    assert a.is_valid is None
+
+    a = interval(1, 5, is_valid=False) * interval(1, 2, is_valid=None)
+    assert a.is_valid is False
+
+
+def test_interval_div():
+    div = interval(1, 2, is_valid=False) / 3
+    assert div == interval(-float('inf'), float('inf'), is_valid=False)
+
+    div = interval(1, 2, is_valid=None) / 3
+    assert div == interval(-float('inf'), float('inf'), is_valid=None)
+
+    div = 3 / interval(1, 2, is_valid=None)
+    assert div == interval(-float('inf'), float('inf'), is_valid=None)
+    a = interval(1, 2) / 0
+    assert a.is_valid is False
+    a = interval(0.5, 1) / interval(-1, 0)
+    assert a.is_valid is None
+    a = interval(0, 1) / interval(0, 1)
+    assert a.is_valid is None
+
+    a = interval(-1, 1) / interval(-1, 1)
+    assert a.is_valid is None
+
+    a = interval(-1, 2) / interval(0.5, 1) == interval(-2.0, 4.0)
+    assert a == (True, True)
+    a = interval(0, 1) / interval(0.5, 1) == interval(0.0, 2.0)
+    assert a == (True, True)
+    a = interval(-1, 0) / interval(0.5, 1) == interval(-2.0, 0.0)
+    assert a == (True, True)
+    a = interval(-0.5, -0.25) / interval(0.5, 1) == interval(-1.0, -0.25)
+    assert a == (True, True)
+    a = interval(0.5, 1) / interval(0.5, 1) == interval(0.5, 2.0)
+    assert a == (True, True)
+    a = interval(0.5, 4) / interval(0.5, 1) == interval(0.5, 8.0)
+    assert a == (True, True)
+    a = interval(-1, -0.5) / interval(0.5, 1) == interval(-2.0, -0.5)
+    assert a == (True, True)
+    a = interval(-4, -0.5) / interval(0.5, 1) == interval(-8.0, -0.5)
+    assert a == (True, True)
+    a = interval(-1, 2) / interval(-2, -0.5) == interval(-4.0, 2.0)
+    assert a == (True, True)
+    a = interval(0, 1) / interval(-2, -0.5) == interval(-2.0, 0.0)
+    assert a == (True, True)
+    a = interval(-1, 0) / interval(-2, -0.5) == interval(0.0, 2.0)
+    assert a == (True, True)
+    a = interval(-0.5, -0.25) / interval(-2, -0.5) == interval(0.125, 1.0)
+    assert a == (True, True)
+    a = interval(0.5, 1) / interval(-2, -0.5) == interval(-2.0, -0.25)
+    assert a == (True, True)
+    a = interval(0.5, 4) / interval(-2, -0.5) == interval(-8.0, -0.25)
+    assert a == (True, True)
+    a = interval(-1, -0.5) / interval(-2, -0.5) == interval(0.25, 2.0)
+    assert a == (True, True)
+    a = interval(-4, -0.5) / interval(-2, -0.5) == interval(0.25, 8.0)
+    assert a == (True, True)
+    a = interval(-5, 5, is_valid=False) / 2
+    assert a.is_valid is False
+
+def test_hashable():
+    '''
+    test that interval objects are hashable.
+    this is required in order to be able to put them into the cache, which
+    appears to be necessary for plotting in py3k. For details, see:
+
+    https://github.com/sympy/sympy/pull/2101
+    https://github.com/sympy/sympy/issues/6533
+    '''
+    hash(interval(1, 1))
+    hash(interval(1, 1, is_valid=True))
+    hash(interval(-4, -0.5))
+    hash(interval(-2, -0.5))
+    hash(interval(0.25, 8.0))

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/plot.py

@@ -0,0 +1,1234 @@
+"""Plotting module for SymPy.
+
+A plot is represented by the ``Plot`` class that contains a reference to the
+backend and a list of the data series to be plotted. The data series are
+instances of classes meant to simplify getting points and meshes from SymPy
+expressions. ``plot_backends`` is a dictionary with all the backends.
+
+This module gives only the essential. For all the fancy stuff use directly
+the backend. You can get the backend wrapper for every plot from the
+``_backend`` attribute. Moreover the data series classes have various useful
+methods like ``get_points``, ``get_meshes``, etc, that may
+be useful if you wish to use another plotting library.
+
+Especially if you need publication ready graphs and this module is not enough
+for you - just get the ``_backend`` attribute and add whatever you want
+directly to it. In the case of matplotlib (the common way to graph data in
+python) just copy ``_backend.fig`` which is the figure and ``_backend.ax``
+which is the axis and work on them as you would on any other matplotlib object.
+
+Simplicity of code takes much greater importance than performance. Do not use it
+if you care at all about performance. A new backend instance is initialized
+every time you call ``show()`` and the old one is left to the garbage collector.
+"""
+
+from sympy.concrete.summations import Sum
+from sympy.core.containers import Tuple
+from sympy.core.expr import Expr
+from sympy.core.function import Function, AppliedUndef
+from sympy.core.symbol import (Dummy, Symbol, Wild)
+from sympy.external import import_module
+from sympy.functions import sign
+from sympy.plotting.backends.base_backend import Plot
+from sympy.plotting.backends.matplotlibbackend import MatplotlibBackend
+from sympy.plotting.backends.textbackend import TextBackend
+from sympy.plotting.series import (
+    LineOver1DRangeSeries, Parametric2DLineSeries, Parametric3DLineSeries,
+    ParametricSurfaceSeries, SurfaceOver2DRangeSeries, ContourSeries)
+from sympy.plotting.utils import _check_arguments, _plot_sympify
+from sympy.tensor.indexed import Indexed
+# to maintain back-compatibility
+from sympy.plotting.plotgrid import PlotGrid # noqa: F401
+from sympy.plotting.series import BaseSeries # noqa: F401
+from sympy.plotting.series import Line2DBaseSeries # noqa: F401
+from sympy.plotting.series import Line3DBaseSeries # noqa: F401
+from sympy.plotting.series import SurfaceBaseSeries # noqa: F401
+from sympy.plotting.series import List2DSeries # noqa: F401
+from sympy.plotting.series import GenericDataSeries # noqa: F401
+from sympy.plotting.series import centers_of_faces # noqa: F401
+from sympy.plotting.series import centers_of_segments # noqa: F401
+from sympy.plotting.series import flat # noqa: F401
+from sympy.plotting.backends.base_backend import unset_show # noqa: F401
+from sympy.plotting.backends.matplotlibbackend import _matplotlib_list # noqa: F401
+from sympy.plotting.textplot import textplot # noqa: F401
+
+
+__doctest_requires__ = {
+    ('plot3d',
+     'plot3d_parametric_line',
+     'plot3d_parametric_surface',
+     'plot_parametric'): ['matplotlib'],
+    # XXX: The plot doctest possibly should not require matplotlib. It fails at
+    # plot(x**2, (x, -5, 5)) which should be fine for text backend.
+    ('plot',): ['matplotlib'],
+}
+
+
+def _process_summations(sum_bound, *args):
+    """Substitute oo (infinity) in the lower/upper bounds of a summation with
+    some integer number.
+
+    Parameters
+    ==========
+
+    sum_bound : int
+        oo will be substituted with this integer number.
+    *args : list/tuple
+        pre-processed arguments of the form (expr, range, ...)
+
+    Notes
+    =====
+    Let's consider the following summation: ``Sum(1 / x**2, (x, 1, oo))``.
+    The current implementation of lambdify (SymPy 1.12 at the time of
+    writing this) will create something of this form:
+    ``sum(1 / x**2 for x in range(1, INF))``
+    The problem is that ``type(INF)`` is float, while ``range`` requires
+    integers: the evaluation fails.
+    Instead of modifying ``lambdify`` (which requires a deep knowledge), just
+    replace it with some integer number.
+    """
+    def new_bound(t, bound):
+        if (not t.is_number) or t.is_finite:
+            return t
+        if sign(t) >= 0:
+            return bound
+        return -bound
+
+    args = list(args)
+    expr = args[0]
+
+    # select summations whose lower/upper bound is infinity
+    w = Wild("w", properties=[
+        lambda t: isinstance(t, Sum),
+        lambda t: any((not a[1].is_finite) or (not a[2].is_finite) for i, a in enumerate(t.args) if i > 0)
+    ])
+
+    for t in list(expr.find(w)):
+        sums_args = list(t.args)
+        for i, a in enumerate(sums_args):
+            if i > 0:
+                sums_args[i] = (a[0], new_bound(a[1], sum_bound),
+                    new_bound(a[2], sum_bound))
+        s = Sum(*sums_args)
+        expr = expr.subs(t, s)
+    args[0] = expr
+    return args
+
+
+def _build_line_series(*args, **kwargs):
+    """Loop over the provided arguments and create the necessary line series.
+    """
+    series = []
+    sum_bound = int(kwargs.get("sum_bound", 1000))
+    for arg in args:
+        expr, r, label, rendering_kw = arg
+        kw = kwargs.copy()
+        if rendering_kw is not None:
+            kw["rendering_kw"] = rendering_kw
+        # TODO: _process_piecewise check goes here
+        if not callable(expr):
+            arg = _process_summations(sum_bound, *arg)
+        series.append(LineOver1DRangeSeries(*arg[:-1], **kw))
+    return series
+
+
+def _create_series(series_type, plot_expr, **kwargs):
+    """Extract the rendering_kw dictionary from the provided arguments and
+    create an appropriate data series.
+    """
+    series = []
+    for args in plot_expr:
+        kw = kwargs.copy()
+        if args[-1] is not None:
+            kw["rendering_kw"] = args[-1]
+        series.append(series_type(*args[:-1], **kw))
+    return series
+
+
+def _set_labels(series, labels, rendering_kw):
+    """Apply the `label` and `rendering_kw` keyword arguments to the series.
+    """
+    if not isinstance(labels, (list, tuple)):
+        labels = [labels]
+    if len(labels) > 0:
+        if len(labels) == 1 and len(series) > 1:
+            # if one label is provided and multiple series are being plotted,
+            # set the same label to all data series. It maintains
+            # back-compatibility
+            labels *= len(series)
+        if len(series) != len(labels):
+            raise ValueError("The number of labels must be equal to the "
+                "number of expressions being plotted.\nReceived "
+                f"{len(series)} expressions and {len(labels)} labels")
+
+        for s, l in zip(series, labels):
+            s.label = l
+
+    if rendering_kw:
+        if isinstance(rendering_kw, dict):
+            rendering_kw = [rendering_kw]
+        if len(rendering_kw) == 1:
+            rendering_kw *= len(series)
+        elif len(series) != len(rendering_kw):
+            raise ValueError("The number of rendering dictionaries must be "
+                "equal to the number of expressions being plotted.\nReceived "
+                f"{len(series)} expressions and {len(labels)} labels")
+        for s, r in zip(series, rendering_kw):
+            s.rendering_kw = r
+
+
+def plot_factory(*args, **kwargs):
+    backend = kwargs.pop("backend", "default")
+    if isinstance(backend, str):
+        if backend == "default":
+            matplotlib = import_module('matplotlib',
+                min_module_version='1.1.0', catch=(RuntimeError,))
+            if matplotlib:
+                return MatplotlibBackend(*args, **kwargs)
+            return TextBackend(*args, **kwargs)
+        return plot_backends[backend](*args, **kwargs)
+    elif (type(backend) == type) and issubclass(backend, Plot):
+        return backend(*args, **kwargs)
+    else:
+        raise TypeError("backend must be either a string or a subclass of ``Plot``.")
+
+
+plot_backends = {
+    'matplotlib': MatplotlibBackend,
+    'text': TextBackend,
+}
+
+
+####New API for plotting module ####
+
+# TODO: Add color arrays for plots.
+# TODO: Add more plotting options for 3d plots.
+# TODO: Adaptive sampling for 3D plots.
+
+def plot(*args, show=True, **kwargs):
+    """Plots a function of a single variable as a curve.
+
+    Parameters
+    ==========
+
+    args :
+        The first argument is the expression representing the function
+        of single variable to be plotted.
+
+        The last argument is a 3-tuple denoting the range of the free
+        variable. e.g. ``(x, 0, 5)``
+
+        Typical usage examples are in the following:
+
+        - Plotting a single expression with a single range.
+            ``plot(expr, range, **kwargs)``
+        - Plotting a single expression with the default range (-10, 10).
+            ``plot(expr, **kwargs)``
+        - Plotting multiple expressions with a single range.
+            ``plot(expr1, expr2, ..., range, **kwargs)``
+        - Plotting multiple expressions with multiple ranges.
+            ``plot((expr1, range1), (expr2, range2), ..., **kwargs)``
+
+        It is best practice to specify range explicitly because default
+        range may change in the future if a more advanced default range
+        detection algorithm is implemented.
+
+    show : bool, optional
+        The default value is set to ``True``. Set show to ``False`` and
+        the function will not display the plot. The returned instance of
+        the ``Plot`` class can then be used to save or display the plot
+        by calling the ``save()`` and ``show()`` methods respectively.
+
+    line_color : string, or float, or function, optional
+        Specifies the color for the plot.
+        See ``Plot`` to see how to set color for the plots.
+        Note that by setting ``line_color``, it would be applied simultaneously
+        to all the series.
+
+    title : str, optional
+        Title of the plot. It is set to the latex representation of
+        the expression, if the plot has only one expression.
+
+    label : str, optional
+        The label of the expression in the plot. It will be used when
+        called with ``legend``. Default is the name of the expression.
+        e.g. ``sin(x)``
+
+    xlabel : str or expression, optional
+        Label for the x-axis.
+
+    ylabel : str or expression, optional
+        Label for the y-axis.
+
+    xscale : 'linear' or 'log', optional
+        Sets the scaling of the x-axis.
+
+    yscale : 'linear' or 'log', optional
+        Sets the scaling of the y-axis.
+
+    axis_center : (float, float), optional
+        Tuple of two floats denoting the coordinates of the center or
+        {'center', 'auto'}
+
+    xlim : (float, float), optional
+        Denotes the x-axis limits, ``(min, max)```.
+
+    ylim : (float, float), optional
+        Denotes the y-axis limits, ``(min, max)```.
+
+    annotations : list, optional
+        A list of dictionaries specifying the type of annotation
+        required. The keys in the dictionary should be equivalent
+        to the arguments of the :external:mod:`matplotlib`'s
+        :external:meth:`~matplotlib.axes.Axes.annotate` method.
+
+    markers : list, optional
+        A list of dictionaries specifying the type the markers required.
+        The keys in the dictionary should be equivalent to the arguments
+        of the :external:mod:`matplotlib`'s :external:func:`~matplotlib.pyplot.plot()` function
+        along with the marker related keyworded arguments.
+
+    rectangles : list, optional
+        A list of dictionaries specifying the dimensions of the
+        rectangles to be plotted. The keys in the dictionary should be
+        equivalent to the arguments of the :external:mod:`matplotlib`'s
+        :external:class:`~matplotlib.patches.Rectangle` class.
+
+    fill : dict, optional
+        A dictionary specifying the type of color filling required in
+        the plot. The keys in the dictionary should be equivalent to the
+        arguments of the :external:mod:`matplotlib`'s
+        :external:meth:`~matplotlib.axes.Axes.fill_between` method.
+
+    adaptive : bool, optional
+        The default value for the ``adaptive`` parameter is now ``False``.
+        To enable adaptive sampling, set ``adaptive=True`` and specify ``n`` if uniform sampling is required.
+
+        The plotting uses an adaptive algorithm which samples
+        recursively to accurately plot. The adaptive algorithm uses a
+        random point near the midpoint of two points that has to be
+        further sampled. Hence the same plots can appear slightly
+        different.
+
+    depth : int, optional
+        Recursion depth of the adaptive algorithm. A depth of value
+        `n` samples a maximum of `2^{n}` points.
+
+        If the ``adaptive`` flag is set to ``False``, this will be
+        ignored.
+
+    n : int, optional
+        Used when the ``adaptive`` is set to ``False``. The function
+        is uniformly sampled at ``n`` number of points. If the ``adaptive``
+        flag is set to ``True``, this will be ignored.
+        This keyword argument replaces ``nb_of_points``, which should be
+        considered deprecated.
+
+    size : (float, float), optional
+        A tuple in the form (width, height) in inches to specify the size of
+        the overall figure. The default value is set to ``None``, meaning
+        the size will be set by the default backend.
+
+    Examples
+    ========
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+       >>> from sympy import symbols
+       >>> from sympy.plotting import plot
+       >>> x = symbols('x')
+
+    Single Plot
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+       >>> plot(x**2, (x, -5, 5))
+       Plot object containing:
+       [0]: cartesian line: x**2 for x over (-5.0, 5.0)
+
+    Multiple plots with single range.
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+       >>> plot(x, x**2, x**3, (x, -5, 5))
+       Plot object containing:
+       [0]: cartesian line: x for x over (-5.0, 5.0)
+       [1]: cartesian line: x**2 for x over (-5.0, 5.0)
+       [2]: cartesian line: x**3 for x over (-5.0, 5.0)
+
+    Multiple plots with different ranges.
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+       >>> plot((x**2, (x, -6, 6)), (x, (x, -5, 5)))
+       Plot object containing:
+       [0]: cartesian line: x**2 for x over (-6.0, 6.0)
+       [1]: cartesian line: x for x over (-5.0, 5.0)
+
+    No adaptive sampling by default. If adaptive sampling is required, set ``adaptive=True``.
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+       >>> plot(x**2, adaptive=True, n=400)
+       Plot object containing:
+       [0]: cartesian line: x**2 for x over (-10.0, 10.0)
+
+    See Also
+    ========
+
+    Plot, LineOver1DRangeSeries
+
+    """
+    args = _plot_sympify(args)
+    plot_expr = _check_arguments(args, 1, 1, **kwargs)
+    params = kwargs.get("params", None)
+    free = set()
+    for p in plot_expr:
+        if not isinstance(p[1][0], str):
+            free |= {p[1][0]}
+        else:
+            free |= {Symbol(p[1][0])}
+    if params:
+        free = free.difference(params.keys())
+    x = free.pop() if free else Symbol("x")
+    kwargs.setdefault('xlabel', x)
+    kwargs.setdefault('ylabel', Function('f')(x))
+
+    labels = kwargs.pop("label", [])
+    rendering_kw = kwargs.pop("rendering_kw", None)
+    series = _build_line_series(*plot_expr, **kwargs)
+    _set_labels(series, labels, rendering_kw)
+
+    plots = plot_factory(*series, **kwargs)
+    if show:
+        plots.show()
+    return plots
+
+
+def plot_parametric(*args, show=True, **kwargs):
+    """
+    Plots a 2D parametric curve.
+
+    Parameters
+    ==========
+
+    args
+        Common specifications are:
+
+        - Plotting a single parametric curve with a range
+            ``plot_parametric((expr_x, expr_y), range)``
+        - Plotting multiple parametric curves with the same range
+            ``plot_parametric((expr_x, expr_y), ..., range)``
+        - Plotting multiple parametric curves with different ranges
+            ``plot_parametric((expr_x, expr_y, range), ...)``
+
+        ``expr_x`` is the expression representing $x$ component of the
+        parametric function.
+
+        ``expr_y`` is the expression representing $y$ component of the
+        parametric function.
+
+        ``range`` is a 3-tuple denoting the parameter symbol, start and
+        stop. For example, ``(u, 0, 5)``.
+
+        If the range is not specified, then a default range of (-10, 10)
+        is used.
+
+        However, if the arguments are specified as
+        ``(expr_x, expr_y, range), ...``, you must specify the ranges
+        for each expressions manually.
+
+        Default range may change in the future if a more advanced
+        algorithm is implemented.
+
+    adaptive : bool, optional
+        Specifies whether to use the adaptive sampling or not.
+
+        The default value is set to ``True``. Set adaptive to ``False``
+        and specify ``n`` if uniform sampling is required.
+
+    depth :  int, optional
+        The recursion depth of the adaptive algorithm. A depth of
+        value $n$ samples a maximum of $2^n$ points.
+
+    n : int, optional
+        Used when the ``adaptive`` flag is set to ``False``. Specifies the
+        number of the points used for the uniform sampling.
+        This keyword argument replaces ``nb_of_points``, which should be
+        considered deprecated.
+
+    line_color : string, or float, or function, optional
+        Specifies the color for the plot.
+        See ``Plot`` to see how to set color for the plots.
+        Note that by setting ``line_color``, it would be applied simultaneously
+        to all the series.
+
+    label : str, optional
+        The label of the expression in the plot. It will be used when
+        called with ``legend``. Default is the name of the expression.
+        e.g. ``sin(x)``
+
+    xlabel : str, optional
+        Label for the x-axis.
+
+    ylabel : str, optional
+        Label for the y-axis.
+
+    xscale : 'linear' or 'log', optional
+        Sets the scaling of the x-axis.
+
+    yscale : 'linear' or 'log', optional
+        Sets the scaling of the y-axis.
+
+    axis_center : (float, float), optional
+        Tuple of two floats denoting the coordinates of the center or
+        {'center', 'auto'}
+
+    xlim : (float, float), optional
+        Denotes the x-axis limits, ``(min, max)```.
+
+    ylim : (float, float), optional
+        Denotes the y-axis limits, ``(min, max)```.
+
+    size : (float, float), optional
+        A tuple in the form (width, height) in inches to specify the size of
+        the overall figure. The default value is set to ``None``, meaning
+        the size will be set by the default backend.
+
+    Examples
+    ========
+
+    .. plot::
+       :context: reset
+       :format: doctest
+       :include-source: True
+
+       >>> from sympy import plot_parametric, symbols, cos, sin
+       >>> u = symbols('u')
+
+    A parametric plot with a single expression:
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+       >>> plot_parametric((cos(u), sin(u)), (u, -5, 5))
+       Plot object containing:
+       [0]: parametric cartesian line: (cos(u), sin(u)) for u over (-5.0, 5.0)
+
+    A parametric plot with multiple expressions with the same range:
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+       >>> plot_parametric((cos(u), sin(u)), (u, cos(u)), (u, -10, 10))
+       Plot object containing:
+       [0]: parametric cartesian line: (cos(u), sin(u)) for u over (-10.0, 10.0)
+       [1]: parametric cartesian line: (u, cos(u)) for u over (-10.0, 10.0)
+
+    A parametric plot with multiple expressions with different ranges
+    for each curve:
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+       >>> plot_parametric((cos(u), sin(u), (u, -5, 5)),
+       ...     (cos(u), u, (u, -5, 5)))
+       Plot object containing:
+       [0]: parametric cartesian line: (cos(u), sin(u)) for u over (-5.0, 5.0)
+       [1]: parametric cartesian line: (cos(u), u) for u over (-5.0, 5.0)
+
+    Notes
+    =====
+
+    The plotting uses an adaptive algorithm which samples recursively to
+    accurately plot the curve. The adaptive algorithm uses a random point
+    near the midpoint of two points that has to be further sampled.
+    Hence, repeating the same plot command can give slightly different
+    results because of the random sampling.
+
+    If there are multiple plots, then the same optional arguments are
+    applied to all the plots drawn in the same canvas. If you want to
+    set these options separately, you can index the returned ``Plot``
+    object and set it.
+
+    For example, when you specify ``line_color`` once, it would be
+    applied simultaneously to both series.
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+        >>> from sympy import pi
+        >>> expr1 = (u, cos(2*pi*u)/2 + 1/2)
+        >>> expr2 = (u, sin(2*pi*u)/2 + 1/2)
+        >>> p = plot_parametric(expr1, expr2, (u, 0, 1), line_color='blue')
+
+    If you want to specify the line color for the specific series, you
+    should index each item and apply the property manually.
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+        >>> p[0].line_color = 'red'
+        >>> p.show()
+
+    See Also
+    ========
+
+    Plot, Parametric2DLineSeries
+    """
+    args = _plot_sympify(args)
+    plot_expr = _check_arguments(args, 2, 1, **kwargs)
+
+    labels = kwargs.pop("label", [])
+    rendering_kw = kwargs.pop("rendering_kw", None)
+    series = _create_series(Parametric2DLineSeries, plot_expr, **kwargs)
+    _set_labels(series, labels, rendering_kw)
+
+    plots = plot_factory(*series, **kwargs)
+    if show:
+        plots.show()
+    return plots
+
+
+def plot3d_parametric_line(*args, show=True, **kwargs):
+    """
+    Plots a 3D parametric line plot.
+
+    Usage
+    =====
+
+    Single plot:
+
+    ``plot3d_parametric_line(expr_x, expr_y, expr_z, range, **kwargs)``
+
+    If the range is not specified, then a default range of (-10, 10) is used.
+
+    Multiple plots.
+
+    ``plot3d_parametric_line((expr_x, expr_y, expr_z, range), ..., **kwargs)``
+
+    Ranges have to be specified for every expression.
+
+    Default range may change in the future if a more advanced default range
+    detection algorithm is implemented.
+
+    Arguments
+    =========
+
+    expr_x : Expression representing the function along x.
+
+    expr_y : Expression representing the function along y.
+
+    expr_z : Expression representing the function along z.
+
+    range : (:class:`~.Symbol`, float, float)
+        A 3-tuple denoting the range of the parameter variable, e.g., (u, 0, 5).
+
+    Keyword Arguments
+    =================
+
+    Arguments for ``Parametric3DLineSeries`` class.
+
+    n : int
+        The range is uniformly sampled at ``n`` number of points.
+        This keyword argument replaces ``nb_of_points``, which should be
+        considered deprecated.
+
+    Aesthetics:
+
+    line_color : string, or float, or function, optional
+        Specifies the color for the plot.
+        See ``Plot`` to see how to set color for the plots.
+        Note that by setting ``line_color``, it would be applied simultaneously
+        to all the series.
+
+    label : str
+        The label to the plot. It will be used when called with ``legend=True``
+        to denote the function with the given label in the plot.
+
+    If there are multiple plots, then the same series arguments are applied to
+    all the plots. If you want to set these options separately, you can index
+    the returned ``Plot`` object and set it.
+
+    Arguments for ``Plot`` class.
+
+    title : str
+        Title of the plot.
+
+    size : (float, float), optional
+        A tuple in the form (width, height) in inches to specify the size of
+        the overall figure. The default value is set to ``None``, meaning
+        the size will be set by the default backend.
+
+    Examples
+    ========
+
+    .. plot::
+       :context: reset
+       :format: doctest
+       :include-source: True
+
+       >>> from sympy import symbols, cos, sin
+       >>> from sympy.plotting import plot3d_parametric_line
+       >>> u = symbols('u')
+
+    Single plot.
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+       >>> plot3d_parametric_line(cos(u), sin(u), u, (u, -5, 5))
+       Plot object containing:
+       [0]: 3D parametric cartesian line: (cos(u), sin(u), u) for u over (-5.0, 5.0)
+
+
+    Multiple plots.
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+       >>> plot3d_parametric_line((cos(u), sin(u), u, (u, -5, 5)),
+       ...     (sin(u), u**2, u, (u, -5, 5)))
+       Plot object containing:
+       [0]: 3D parametric cartesian line: (cos(u), sin(u), u) for u over (-5.0, 5.0)
+       [1]: 3D parametric cartesian line: (sin(u), u**2, u) for u over (-5.0, 5.0)
+
+
+    See Also
+    ========
+
+    Plot, Parametric3DLineSeries
+
+    """
+    args = _plot_sympify(args)
+    plot_expr = _check_arguments(args, 3, 1, **kwargs)
+    kwargs.setdefault("xlabel", "x")
+    kwargs.setdefault("ylabel", "y")
+    kwargs.setdefault("zlabel", "z")
+
+    labels = kwargs.pop("label", [])
+    rendering_kw = kwargs.pop("rendering_kw", None)
+    series = _create_series(Parametric3DLineSeries, plot_expr, **kwargs)
+    _set_labels(series, labels, rendering_kw)
+
+    plots = plot_factory(*series, **kwargs)
+    if show:
+        plots.show()
+    return plots
+
+
+def _plot3d_plot_contour_helper(Series, *args, **kwargs):
+    """plot3d and plot_contour are structurally identical. Let's reduce
+    code repetition.
+    """
+    # NOTE: if this import would be at the top-module level, it would trigger
+    # SymPy's optional-dependencies tests to fail.
+    from sympy.vector import BaseScalar
+
+    args = _plot_sympify(args)
+    plot_expr = _check_arguments(args, 1, 2, **kwargs)
+
+    free_x = set()
+    free_y = set()
+    _types = (Symbol, BaseScalar, Indexed, AppliedUndef)
+    for p in plot_expr:
+        free_x |= {p[1][0]} if isinstance(p[1][0], _types) else {Symbol(p[1][0])}
+        free_y |= {p[2][0]} if isinstance(p[2][0], _types) else {Symbol(p[2][0])}
+    x = free_x.pop() if free_x else Symbol("x")
+    y = free_y.pop() if free_y else Symbol("y")
+    kwargs.setdefault("xlabel", x)
+    kwargs.setdefault("ylabel", y)
+    kwargs.setdefault("zlabel", Function('f')(x, y))
+
+    # if a polar discretization is requested and automatic labelling has ben
+    # applied, hide the labels on the x-y axis.
+    if kwargs.get("is_polar", False):
+        if callable(kwargs["xlabel"]):
+            kwargs["xlabel"] = ""
+        if callable(kwargs["ylabel"]):
+            kwargs["ylabel"] = ""
+
+    labels = kwargs.pop("label", [])
+    rendering_kw = kwargs.pop("rendering_kw", None)
+    series = _create_series(Series, plot_expr, **kwargs)
+    _set_labels(series, labels, rendering_kw)
+    plots = plot_factory(*series, **kwargs)
+    if kwargs.get("show", True):
+        plots.show()
+    return plots
+
+
+def plot3d(*args, show=True, **kwargs):
+    """
+    Plots a 3D surface plot.
+
+    Usage
+    =====
+
+    Single plot
+
+    ``plot3d(expr, range_x, range_y, **kwargs)``
+
+    If the ranges are not specified, then a default range of (-10, 10) is used.
+
+    Multiple plot with the same range.
+
+    ``plot3d(expr1, expr2, range_x, range_y, **kwargs)``
+
+    If the ranges are not specified, then a default range of (-10, 10) is used.
+
+    Multiple plots with different ranges.
+
+    ``plot3d((expr1, range_x, range_y), (expr2, range_x, range_y), ..., **kwargs)``
+
+    Ranges have to be specified for every expression.
+
+    Default range may change in the future if a more advanced default range
+    detection algorithm is implemented.
+
+    Arguments
+    =========
+
+    expr : Expression representing the function along x.
+
+    range_x : (:class:`~.Symbol`, float, float)
+        A 3-tuple denoting the range of the x variable, e.g. (x, 0, 5).
+
+    range_y : (:class:`~.Symbol`, float, float)
+        A 3-tuple denoting the range of the y variable, e.g. (y, 0, 5).
+
+    Keyword Arguments
+    =================
+
+    Arguments for ``SurfaceOver2DRangeSeries`` class:
+
+    n1 : int
+        The x range is sampled uniformly at ``n1`` of points.
+        This keyword argument replaces ``nb_of_points_x``, which should be
+        considered deprecated.
+
+    n2 : int
+        The y range is sampled uniformly at ``n2`` of points.
+        This keyword argument replaces ``nb_of_points_y``, which should be
+        considered deprecated.
+
+    Aesthetics:
+
+    surface_color : Function which returns a float
+        Specifies the color for the surface of the plot.
+        See :class:`~.Plot` for more details.
+
+    If there are multiple plots, then the same series arguments are applied to
+    all the plots. If you want to set these options separately, you can index
+    the returned ``Plot`` object and set it.
+
+    Arguments for ``Plot`` class:
+
+    title : str
+        Title of the plot.
+
+    size : (float, float), optional
+        A tuple in the form (width, height) in inches to specify the size of the
+        overall figure. The default value is set to ``None``, meaning the size will
+        be set by the default backend.
+
+    Examples
+    ========
+
+    .. plot::
+       :context: reset
+       :format: doctest
+       :include-source: True
+
+       >>> from sympy import symbols
+       >>> from sympy.plotting import plot3d
+       >>> x, y = symbols('x y')
+
+    Single plot
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+       >>> plot3d(x*y, (x, -5, 5), (y, -5, 5))
+       Plot object containing:
+       [0]: cartesian surface: x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0)
+
+
+    Multiple plots with same range
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+       >>> plot3d(x*y, -x*y, (x, -5, 5), (y, -5, 5))
+       Plot object containing:
+       [0]: cartesian surface: x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0)
+       [1]: cartesian surface: -x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0)
+
+
+    Multiple plots with different ranges.
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+       >>> plot3d((x**2 + y**2, (x, -5, 5), (y, -5, 5)),
+       ...     (x*y, (x, -3, 3), (y, -3, 3)))
+       Plot object containing:
+       [0]: cartesian surface: x**2 + y**2 for x over (-5.0, 5.0) and y over (-5.0, 5.0)
+       [1]: cartesian surface: x*y for x over (-3.0, 3.0) and y over (-3.0, 3.0)
+
+
+    See Also
+    ========
+
+    Plot, SurfaceOver2DRangeSeries
+
+    """
+    kwargs.setdefault("show", show)
+    return _plot3d_plot_contour_helper(
+        SurfaceOver2DRangeSeries, *args, **kwargs)
+
+
+def plot3d_parametric_surface(*args, show=True, **kwargs):
+    """
+    Plots a 3D parametric surface plot.
+
+    Explanation
+    ===========
+
+    Single plot.
+
+    ``plot3d_parametric_surface(expr_x, expr_y, expr_z, range_u, range_v, **kwargs)``
+
+    If the ranges is not specified, then a default range of (-10, 10) is used.
+
+    Multiple plots.
+
+    ``plot3d_parametric_surface((expr_x, expr_y, expr_z, range_u, range_v), ..., **kwargs)``
+
+    Ranges have to be specified for every expression.
+
+    Default range may change in the future if a more advanced default range
+    detection algorithm is implemented.
+
+    Arguments
+    =========
+
+    expr_x : Expression representing the function along ``x``.
+
+    expr_y : Expression representing the function along ``y``.
+
+    expr_z : Expression representing the function along ``z``.
+
+    range_u : (:class:`~.Symbol`, float, float)
+        A 3-tuple denoting the range of the u variable, e.g. (u, 0, 5).
+
+    range_v : (:class:`~.Symbol`, float, float)
+        A 3-tuple denoting the range of the v variable, e.g. (v, 0, 5).
+
+    Keyword Arguments
+    =================
+
+    Arguments for ``ParametricSurfaceSeries`` class:
+
+    n1 : int
+        The ``u`` range is sampled uniformly at ``n1`` of points.
+        This keyword argument replaces ``nb_of_points_u``, which should be
+        considered deprecated.
+
+    n2 : int
+        The ``v`` range is sampled uniformly at ``n2`` of points.
+        This keyword argument replaces ``nb_of_points_v``, which should be
+        considered deprecated.
+
+    Aesthetics:
+
+    surface_color : Function which returns a float
+        Specifies the color for the surface of the plot. See
+        :class:`~Plot` for more details.
+
+    If there are multiple plots, then the same series arguments are applied for
+    all the plots. If you want to set these options separately, you can index
+    the returned ``Plot`` object and set it.
+
+
+    Arguments for ``Plot`` class:
+
+    title : str
+        Title of the plot.
+
+    size : (float, float), optional
+        A tuple in the form (width, height) in inches to specify the size of the
+        overall figure. The default value is set to ``None``, meaning the size will
+        be set by the default backend.
+
+    Examples
+    ========
+
+    .. plot::
+       :context: reset
+       :format: doctest
+       :include-source: True
+
+       >>> from sympy import symbols, cos, sin
+       >>> from sympy.plotting import plot3d_parametric_surface
+       >>> u, v = symbols('u v')
+
+    Single plot.
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+       >>> plot3d_parametric_surface(cos(u + v), sin(u - v), u - v,
+       ...     (u, -5, 5), (v, -5, 5))
+       Plot object containing:
+       [0]: parametric cartesian surface: (cos(u + v), sin(u - v), u - v) for u over (-5.0, 5.0) and v over (-5.0, 5.0)
+
+
+    See Also
+    ========
+
+    Plot, ParametricSurfaceSeries
+
+    """
+
+    args = _plot_sympify(args)
+    plot_expr = _check_arguments(args, 3, 2, **kwargs)
+    kwargs.setdefault("xlabel", "x")
+    kwargs.setdefault("ylabel", "y")
+    kwargs.setdefault("zlabel", "z")
+
+    labels = kwargs.pop("label", [])
+    rendering_kw = kwargs.pop("rendering_kw", None)
+    series = _create_series(ParametricSurfaceSeries, plot_expr, **kwargs)
+    _set_labels(series, labels, rendering_kw)
+
+    plots = plot_factory(*series, **kwargs)
+    if show:
+        plots.show()
+    return plots
+
+def plot_contour(*args, show=True, **kwargs):
+    """
+    Draws contour plot of a function
+
+    Usage
+    =====
+
+    Single plot
+
+    ``plot_contour(expr, range_x, range_y, **kwargs)``
+
+    If the ranges are not specified, then a default range of (-10, 10) is used.
+
+    Multiple plot with the same range.
+
+    ``plot_contour(expr1, expr2, range_x, range_y, **kwargs)``
+
+    If the ranges are not specified, then a default range of (-10, 10) is used.
+
+    Multiple plots with different ranges.
+
+    ``plot_contour((expr1, range_x, range_y), (expr2, range_x, range_y), ..., **kwargs)``
+
+    Ranges have to be specified for every expression.
+
+    Default range may change in the future if a more advanced default range
+    detection algorithm is implemented.
+
+    Arguments
+    =========
+
+    expr : Expression representing the function along x.
+
+    range_x : (:class:`Symbol`, float, float)
+        A 3-tuple denoting the range of the x variable, e.g. (x, 0, 5).
+
+    range_y : (:class:`Symbol`, float, float)
+        A 3-tuple denoting the range of the y variable, e.g. (y, 0, 5).
+
+    Keyword Arguments
+    =================
+
+    Arguments for ``ContourSeries`` class:
+
+    n1 : int
+        The x range is sampled uniformly at ``n1`` of points.
+        This keyword argument replaces ``nb_of_points_x``, which should be
+        considered deprecated.
+
+    n2 : int
+        The y range is sampled uniformly at ``n2`` of points.
+        This keyword argument replaces ``nb_of_points_y``, which should be
+        considered deprecated.
+
+    Aesthetics:
+
+    surface_color : Function which returns a float
+        Specifies the color for the surface of the plot. See
+        :class:`sympy.plotting.Plot` for more details.
+
+    If there are multiple plots, then the same series arguments are applied to
+    all the plots. If you want to set these options separately, you can index
+    the returned ``Plot`` object and set it.
+
+    Arguments for ``Plot`` class:
+
+    title : str
+        Title of the plot.
+
+    size : (float, float), optional
+        A tuple in the form (width, height) in inches to specify the size of
+        the overall figure. The default value is set to ``None``, meaning
+        the size will be set by the default backend.
+
+    See Also
+    ========
+
+    Plot, ContourSeries
+
+    """
+    kwargs.setdefault("show", show)
+    return _plot3d_plot_contour_helper(ContourSeries, *args, **kwargs)
+
+
+def check_arguments(args, expr_len, nb_of_free_symbols):
+    """
+    Checks the arguments and converts into tuples of the
+    form (exprs, ranges).
+
+    Examples
+    ========
+
+    .. plot::
+       :context: reset
+       :format: doctest
+       :include-source: True
+
+       >>> from sympy import cos, sin, symbols
+       >>> from sympy.plotting.plot import check_arguments
+       >>> x = symbols('x')
+       >>> check_arguments([cos(x), sin(x)], 2, 1)
+           [(cos(x), sin(x), (x, -10, 10))]
+
+       >>> check_arguments([x, x**2], 1, 1)
+           [(x, (x, -10, 10)), (x**2, (x, -10, 10))]
+    """
+    if not args:
+        return []
+    if expr_len > 1 and isinstance(args[0], Expr):
+        # Multiple expressions same range.
+        # The arguments are tuples when the expression length is
+        # greater than 1.
+        if len(args) < expr_len:
+            raise ValueError("len(args) should not be less than expr_len")
+        for i in range(len(args)):
+            if isinstance(args[i], Tuple):
+                break
+        else:
+            i = len(args) + 1
+
+        exprs = Tuple(*args[:i])
+        free_symbols = list(set().union(*[e.free_symbols for e in exprs]))
+        if len(args) == expr_len + nb_of_free_symbols:
+            #Ranges given
+            plots = [exprs + Tuple(*args[expr_len:])]
+        else:
+            default_range = Tuple(-10, 10)
+            ranges = []
+            for symbol in free_symbols:
+                ranges.append(Tuple(symbol) + default_range)
+
+            for i in range(len(free_symbols) - nb_of_free_symbols):
+                ranges.append(Tuple(Dummy()) + default_range)
+            plots = [exprs + Tuple(*ranges)]
+        return plots
+
+    if isinstance(args[0], Expr) or (isinstance(args[0], Tuple) and
+                                     len(args[0]) == expr_len and
+                                     expr_len != 3):
+        # Cannot handle expressions with number of expression = 3. It is
+        # not possible to differentiate between expressions and ranges.
+        #Series of plots with same range
+        for i in range(len(args)):
+            if isinstance(args[i], Tuple) and len(args[i]) != expr_len:
+                break
+            if not isinstance(args[i], Tuple):
+                args[i] = Tuple(args[i])
+        else:
+            i = len(args) + 1
+
+        exprs = args[:i]
+        assert all(isinstance(e, Expr) for expr in exprs for e in expr)
+        free_symbols = list(set().union(*[e.free_symbols for expr in exprs
+                                        for e in expr]))
+
+        if len(free_symbols) > nb_of_free_symbols:
+            raise ValueError("The number of free_symbols in the expression "
+                             "is greater than %d" % nb_of_free_symbols)
+        if len(args) == i + nb_of_free_symbols and isinstance(args[i], Tuple):
+            ranges = Tuple(*list(args[
+                           i:i + nb_of_free_symbols]))
+            plots = [expr + ranges for expr in exprs]
+            return plots
+        else:
+            # Use default ranges.
+            default_range = Tuple(-10, 10)
+            ranges = []
+            for symbol in free_symbols:
+                ranges.append(Tuple(symbol) + default_range)
+
+            for i in range(nb_of_free_symbols - len(free_symbols)):
+                ranges.append(Tuple(Dummy()) + default_range)
+            ranges = Tuple(*ranges)
+            plots = [expr + ranges for expr in exprs]
+            return plots
+
+    elif isinstance(args[0], Tuple) and len(args[0]) == expr_len + nb_of_free_symbols:
+        # Multiple plots with different ranges.
+        for arg in args:
+            for i in range(expr_len):
+                if not isinstance(arg[i], Expr):
+                    raise ValueError("Expected an expression, given %s" %
+                                     str(arg[i]))
+            for i in range(nb_of_free_symbols):
+                if not len(arg[i + expr_len]) == 3:
+                    raise ValueError("The ranges should be a tuple of "
+                                     "length 3, got %s" % str(arg[i + expr_len]))
+        return args

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/plot_implicit.py

@@ -0,0 +1,233 @@
+"""Implicit plotting module for SymPy.
+
+Explanation
+===========
+
+The module implements a data series called ImplicitSeries which is used by
+``Plot`` class to plot implicit plots for different backends. The module,
+by default, implements plotting using interval arithmetic. It switches to a
+fall back algorithm if the expression cannot be plotted using interval arithmetic.
+It is also possible to specify to use the fall back algorithm for all plots.
+
+Boolean combinations of expressions cannot be plotted by the fall back
+algorithm.
+
+See Also
+========
+
+sympy.plotting.plot
+
+References
+==========
+
+.. [1] Jeffrey Allen Tupper. Reliable Two-Dimensional Graphing Methods for
+Mathematical Formulae with Two Free Variables.
+
+.. [2] Jeffrey Allen Tupper. Graphing Equations with Generalized Interval
+Arithmetic. Master's thesis. University of Toronto, 1996
+
+"""
+
+
+from sympy.core.containers import Tuple
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.polys.polyutils import _sort_gens
+from sympy.plotting.series import ImplicitSeries, _set_discretization_points
+from sympy.plotting.plot import plot_factory
+from sympy.utilities.decorator import doctest_depends_on
+from sympy.utilities.iterables import flatten
+
+
+__doctest_requires__ = {'plot_implicit': ['matplotlib']}
+
+
+@doctest_depends_on(modules=('matplotlib',))
+def plot_implicit(expr, x_var=None, y_var=None, adaptive=True, depth=0,
+                  n=300, line_color="blue", show=True, **kwargs):
+    """A plot function to plot implicit equations / inequalities.
+
+    Arguments
+    =========
+
+    - expr : The equation / inequality that is to be plotted.
+    - x_var (optional) : symbol to plot on x-axis or tuple giving symbol
+      and range as ``(symbol, xmin, xmax)``
+    - y_var (optional) : symbol to plot on y-axis or tuple giving symbol
+      and range as ``(symbol, ymin, ymax)``
+
+    If neither ``x_var`` nor ``y_var`` are given then the free symbols in the
+    expression will be assigned in the order they are sorted.
+
+    The following keyword arguments can also be used:
+
+    - ``adaptive`` Boolean. The default value is set to True. It has to be
+        set to False if you want to use a mesh grid.
+
+    - ``depth`` integer. The depth of recursion for adaptive mesh grid.
+        Default value is 0. Takes value in the range (0, 4).
+
+    - ``n`` integer. The number of points if adaptive mesh grid is not
+        used. Default value is 300. This keyword argument replaces ``points``,
+        which should be considered deprecated.
+
+    - ``show`` Boolean. Default value is True. If set to False, the plot will
+        not be shown. See ``Plot`` for further information.
+
+    - ``title`` string. The title for the plot.
+
+    - ``xlabel`` string. The label for the x-axis
+
+    - ``ylabel`` string. The label for the y-axis
+
+    Aesthetics options:
+
+    - ``line_color``: float or string. Specifies the color for the plot.
+        See ``Plot`` to see how to set color for the plots.
+        Default value is "Blue"
+
+    plot_implicit, by default, uses interval arithmetic to plot functions. If
+    the expression cannot be plotted using interval arithmetic, it defaults to
+    a generating a contour using a mesh grid of fixed number of points. By
+    setting adaptive to False, you can force plot_implicit to use the mesh
+    grid. The mesh grid method can be effective when adaptive plotting using
+    interval arithmetic, fails to plot with small line width.
+
+    Examples
+    ========
+
+    Plot expressions:
+
+    .. plot::
+        :context: reset
+        :format: doctest
+        :include-source: True
+
+        >>> from sympy import plot_implicit, symbols, Eq, And
+        >>> x, y = symbols('x y')
+
+    Without any ranges for the symbols in the expression:
+
+    .. plot::
+        :context: close-figs
+        :format: doctest
+        :include-source: True
+
+        >>> p1 = plot_implicit(Eq(x**2 + y**2, 5))
+
+    With the range for the symbols:
+
+    .. plot::
+        :context: close-figs
+        :format: doctest
+        :include-source: True
+
+        >>> p2 = plot_implicit(
+        ...     Eq(x**2 + y**2, 3), (x, -3, 3), (y, -3, 3))
+
+    With depth of recursion as argument:
+
+    .. plot::
+        :context: close-figs
+        :format: doctest
+        :include-source: True
+
+        >>> p3 = plot_implicit(
+        ...     Eq(x**2 + y**2, 5), (x, -4, 4), (y, -4, 4), depth = 2)
+
+    Using mesh grid and not using adaptive meshing:
+
+    .. plot::
+        :context: close-figs
+        :format: doctest
+        :include-source: True
+
+        >>> p4 = plot_implicit(
+        ...     Eq(x**2 + y**2, 5), (x, -5, 5), (y, -2, 2),
+        ...     adaptive=False)
+
+    Using mesh grid without using adaptive meshing with number of points
+    specified:
+
+    .. plot::
+        :context: close-figs
+        :format: doctest
+        :include-source: True
+
+        >>> p5 = plot_implicit(
+        ...     Eq(x**2 + y**2, 5), (x, -5, 5), (y, -2, 2),
+        ...     adaptive=False, n=400)
+
+    Plotting regions:
+
+    .. plot::
+        :context: close-figs
+        :format: doctest
+        :include-source: True
+
+        >>> p6 = plot_implicit(y > x**2)
+
+    Plotting Using boolean conjunctions:
+
+    .. plot::
+        :context: close-figs
+        :format: doctest
+        :include-source: True
+
+        >>> p7 = plot_implicit(And(y > x, y > -x))
+
+    When plotting an expression with a single variable (y - 1, for example),
+    specify the x or the y variable explicitly:
+
+    .. plot::
+        :context: close-figs
+        :format: doctest
+        :include-source: True
+
+        >>> p8 = plot_implicit(y - 1, y_var=y)
+        >>> p9 = plot_implicit(x - 1, x_var=x)
+    """
+
+    xyvar = [i for i in (x_var, y_var) if i is not None]
+    free_symbols = expr.free_symbols
+    range_symbols = Tuple(*flatten(xyvar)).free_symbols
+    undeclared = free_symbols - range_symbols
+    if len(free_symbols & range_symbols) > 2:
+        raise NotImplementedError("Implicit plotting is not implemented for "
+                                  "more than 2 variables")
+
+    #Create default ranges if the range is not provided.
+    default_range = Tuple(-5, 5)
+    def _range_tuple(s):
+        if isinstance(s, Symbol):
+            return Tuple(s) + default_range
+        if len(s) == 3:
+            return Tuple(*s)
+        raise ValueError('symbol or `(symbol, min, max)` expected but got %s' % s)
+
+    if len(xyvar) == 0:
+        xyvar = list(_sort_gens(free_symbols))
+    var_start_end_x = _range_tuple(xyvar[0])
+    x = var_start_end_x[0]
+    if len(xyvar) != 2:
+        if x in undeclared or not undeclared:
+            xyvar.append(Dummy('f(%s)' % x.name))
+        else:
+            xyvar.append(undeclared.pop())
+    var_start_end_y = _range_tuple(xyvar[1])
+
+    kwargs = _set_discretization_points(kwargs, ImplicitSeries)
+    series_argument = ImplicitSeries(
+        expr, var_start_end_x, var_start_end_y,
+        adaptive=adaptive, depth=depth,
+        n=n, line_color=line_color)
+
+    #set the x and y limits
+    kwargs['xlim'] = tuple(float(x) for x in var_start_end_x[1:])
+    kwargs['ylim'] = tuple(float(y) for y in var_start_end_y[1:])
+    # set the x and y labels
+    kwargs.setdefault('xlabel', var_start_end_x[0])
+    kwargs.setdefault('ylabel', var_start_end_y[0])
+    p = plot_factory(series_argument, **kwargs)
+    if show:
+        p.show()
+    return p

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/plotgrid.py

@@ -0,0 +1,188 @@
+
+from sympy.external import import_module
+import sympy.plotting.backends.base_backend as base_backend
+
+
+# N.B.
+# When changing the minimum module version for matplotlib, please change
+# the same in the `SymPyDocTestFinder`` in `sympy/testing/runtests.py`
+
+
+__doctest_requires__ = {
+    ("PlotGrid",): ["matplotlib"],
+}
+
+
+class PlotGrid:
+    """This class helps to plot subplots from already created SymPy plots
+    in a single figure.
+
+    Examples
+    ========
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+        >>> from sympy import symbols
+        >>> from sympy.plotting import plot, plot3d, PlotGrid
+        >>> x, y = symbols('x, y')
+        >>> p1 = plot(x, x**2, x**3, (x, -5, 5))
+        >>> p2 = plot((x**2, (x, -6, 6)), (x, (x, -5, 5)))
+        >>> p3 = plot(x**3, (x, -5, 5))
+        >>> p4 = plot3d(x*y, (x, -5, 5), (y, -5, 5))
+
+    Plotting vertically in a single line:
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+        >>> PlotGrid(2, 1, p1, p2)
+        PlotGrid object containing:
+        Plot[0]:Plot object containing:
+        [0]: cartesian line: x for x over (-5.0, 5.0)
+        [1]: cartesian line: x**2 for x over (-5.0, 5.0)
+        [2]: cartesian line: x**3 for x over (-5.0, 5.0)
+        Plot[1]:Plot object containing:
+        [0]: cartesian line: x**2 for x over (-6.0, 6.0)
+        [1]: cartesian line: x for x over (-5.0, 5.0)
+
+    Plotting horizontally in a single line:
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+        >>> PlotGrid(1, 3, p2, p3, p4)
+        PlotGrid object containing:
+        Plot[0]:Plot object containing:
+        [0]: cartesian line: x**2 for x over (-6.0, 6.0)
+        [1]: cartesian line: x for x over (-5.0, 5.0)
+        Plot[1]:Plot object containing:
+        [0]: cartesian line: x**3 for x over (-5.0, 5.0)
+        Plot[2]:Plot object containing:
+        [0]: cartesian surface: x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0)
+
+    Plotting in a grid form:
+
+    .. plot::
+       :context: close-figs
+       :format: doctest
+       :include-source: True
+
+        >>> PlotGrid(2, 2, p1, p2, p3, p4)
+        PlotGrid object containing:
+        Plot[0]:Plot object containing:
+        [0]: cartesian line: x for x over (-5.0, 5.0)
+        [1]: cartesian line: x**2 for x over (-5.0, 5.0)
+        [2]: cartesian line: x**3 for x over (-5.0, 5.0)
+        Plot[1]:Plot object containing:
+        [0]: cartesian line: x**2 for x over (-6.0, 6.0)
+        [1]: cartesian line: x for x over (-5.0, 5.0)
+        Plot[2]:Plot object containing:
+        [0]: cartesian line: x**3 for x over (-5.0, 5.0)
+        Plot[3]:Plot object containing:
+        [0]: cartesian surface: x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0)
+
+    """
+    def __init__(self, nrows, ncolumns, *args, show=True, size=None, **kwargs):
+        """
+        Parameters
+        ==========
+
+        nrows :
+            The number of rows that should be in the grid of the
+            required subplot.
+        ncolumns :
+            The number of columns that should be in the grid
+            of the required subplot.
+
+        nrows and ncolumns together define the required grid.
+
+        Arguments
+        =========
+
+        A list of predefined plot objects entered in a row-wise sequence
+        i.e. plot objects which are to be in the top row of the required
+        grid are written first, then the second row objects and so on
+
+        Keyword arguments
+        =================
+
+        show : Boolean
+            The default value is set to ``True``. Set show to ``False`` and
+            the function will not display the subplot. The returned instance
+            of the ``PlotGrid`` class can then be used to save or display the
+            plot by calling the ``save()`` and ``show()`` methods
+            respectively.
+        size : (float, float), optional
+            A tuple in the form (width, height) in inches to specify the size of
+            the overall figure. The default value is set to ``None``, meaning
+            the size will be set by the default backend.
+        """
+        self.matplotlib = import_module('matplotlib',
+            import_kwargs={'fromlist': ['pyplot', 'cm', 'collections']},
+            min_module_version='1.1.0', catch=(RuntimeError,))
+        self.nrows = nrows
+        self.ncolumns = ncolumns
+        self._series = []
+        self._fig = None
+        self.args = args
+        for arg in args:
+            self._series.append(arg._series)
+        self.size = size
+        if show and self.matplotlib:
+            self.show()
+
+    def _create_figure(self):
+        gs = self.matplotlib.gridspec.GridSpec(self.nrows, self.ncolumns)
+        mapping = {}
+        c = 0
+        for i in range(self.nrows):
+            for j in range(self.ncolumns):
+                if c < len(self.args):
+                    mapping[gs[i, j]] = self.args[c]
+                c += 1
+
+        kw = {} if not self.size else {"figsize": self.size}
+        self._fig = self.matplotlib.pyplot.figure(**kw)
+        for spec, p in mapping.items():
+            kw = ({"projection": "3d"} if (len(p._series) > 0 and
+                p._series[0].is_3D) else {})
+            cur_ax = self._fig.add_subplot(spec, **kw)
+            p._plotgrid_fig = self._fig
+            p._plotgrid_ax = cur_ax
+            p.process_series()
+
+    @property
+    def fig(self):
+        if not self._fig:
+            self._create_figure()
+        return self._fig
+
+    @property
+    def _backend(self):
+        return self
+
+    def close(self):
+        self.matplotlib.pyplot.close(self.fig)
+
+    def show(self):
+        if base_backend._show:
+            self.fig.tight_layout()
+            self.matplotlib.pyplot.show()
+        else:
+            self.close()
+
+    def save(self, path):
+        self.fig.savefig(path)
+
+    def __str__(self):
+        plot_strs = [('Plot[%d]:' % i) + str(plot)
+                      for i, plot in enumerate(self.args)]
+
+        return 'PlotGrid object containing:\n' + '\n'.join(plot_strs)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/pygletplot/__init__.py

@@ -0,0 +1,138 @@
+"""Plotting module that can plot 2D and 3D functions
+"""
+
+from sympy.utilities.decorator import doctest_depends_on
+
+@doctest_depends_on(modules=('pyglet',))
+def PygletPlot(*args, **kwargs):
+    """
+
+    Plot Examples
+    =============
+
+    See examples/advanced/pyglet_plotting.py for many more examples.
+
+    >>> from sympy.plotting.pygletplot import PygletPlot as Plot
+    >>> from sympy.abc import x, y, z
+
+    >>> Plot(x*y**3-y*x**3)
+    [0]: -x**3*y + x*y**3, 'mode=cartesian'
+
+    >>> p = Plot()
+    >>> p[1] = x*y
+    >>> p[1].color = z, (0.4,0.4,0.9), (0.9,0.4,0.4)
+
+    >>> p = Plot()
+    >>> p[1] =  x**2+y**2
+    >>> p[2] = -x**2-y**2
+
+
+    Variable Intervals
+    ==================
+
+    The basic format is [var, min, max, steps], but the
+    syntax is flexible and arguments left out are taken
+    from the defaults for the current coordinate mode:
+
+    >>> Plot(x**2) # implies [x,-5,5,100]
+    [0]: x**2, 'mode=cartesian'
+
+    >>> Plot(x**2, [], []) # [x,-1,1,40], [y,-1,1,40]
+    [0]: x**2, 'mode=cartesian'
+    >>> Plot(x**2-y**2, [100], [100]) # [x,-1,1,100], [y,-1,1,100]
+    [0]: x**2 - y**2, 'mode=cartesian'
+    >>> Plot(x**2, [x,-13,13,100])
+    [0]: x**2, 'mode=cartesian'
+    >>> Plot(x**2, [-13,13]) # [x,-13,13,100]
+    [0]: x**2, 'mode=cartesian'
+    >>> Plot(x**2, [x,-13,13]) # [x,-13,13,100]
+    [0]: x**2, 'mode=cartesian'
+    >>> Plot(1*x, [], [x], mode='cylindrical')
+    ... # [unbound_theta,0,2*Pi,40], [x,-1,1,20]
+    [0]: x, 'mode=cartesian'
+
+
+    Coordinate Modes
+    ================
+
+    Plot supports several curvilinear coordinate modes, and
+    they independent for each plotted function. You can specify
+    a coordinate mode explicitly with the 'mode' named argument,
+    but it can be automatically determined for Cartesian or
+    parametric plots, and therefore must only be specified for
+    polar, cylindrical, and spherical modes.
+
+    Specifically, Plot(function arguments) and Plot[n] =
+    (function arguments) will interpret your arguments as a
+    Cartesian plot if you provide one function and a parametric
+    plot if you provide two or three functions. Similarly, the
+    arguments will be interpreted as a curve if one variable is
+    used, and a surface if two are used.
+
+    Supported mode names by number of variables:
+
+    1: parametric, cartesian, polar
+    2: parametric, cartesian, cylindrical = polar, spherical
+
+    >>> Plot(1, mode='spherical')
+
+
+    Calculator-like Interface
+    =========================
+
+    >>> p = Plot(visible=False)
+    >>> f = x**2
+    >>> p[1] = f
+    >>> p[2] = f.diff(x)
+    >>> p[3] = f.diff(x).diff(x)
+    >>> p
+    [1]: x**2, 'mode=cartesian'
+    [2]: 2*x, 'mode=cartesian'
+    [3]: 2, 'mode=cartesian'
+    >>> p.show()
+    >>> p.clear()
+    >>> p
+    <blank plot>
+    >>> p[1] =  x**2+y**2
+    >>> p[1].style = 'solid'
+    >>> p[2] = -x**2-y**2
+    >>> p[2].style = 'wireframe'
+    >>> p[1].color = z, (0.4,0.4,0.9), (0.9,0.4,0.4)
+    >>> p[1].style = 'both'
+    >>> p[2].style = 'both'
+    >>> p.close()
+
+
+    Plot Window Keyboard Controls
+    =============================
+
+    Screen Rotation:
+        X,Y axis      Arrow Keys, A,S,D,W, Numpad 4,6,8,2
+        Z axis        Q,E, Numpad 7,9
+
+    Model Rotation:
+        Z axis        Z,C, Numpad 1,3
+
+    Zoom:             R,F, PgUp,PgDn, Numpad +,-
+
+    Reset Camera:     X, Numpad 5
+
+    Camera Presets:
+        XY            F1
+        XZ            F2
+        YZ            F3
+        Perspective   F4
+
+    Sensitivity Modifier: SHIFT
+
+    Axes Toggle:
+        Visible       F5
+        Colors        F6
+
+    Close Window:     ESCAPE
+
+    =============================
+    """
+
+    from sympy.plotting.pygletplot.plot import PygletPlot
+    return PygletPlot(*args, **kwargs)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/pygletplot/color_scheme.py

@@ -0,0 +1,336 @@
+from sympy.core.basic import Basic
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.utilities.lambdify import lambdify
+from .util import interpolate, rinterpolate, create_bounds, update_bounds
+from sympy.utilities.iterables import sift
+
+
+class ColorGradient:
+    colors = [0.4, 0.4, 0.4], [0.9, 0.9, 0.9]
+    intervals = 0.0, 1.0
+
+    def __init__(self, *args):
+        if len(args) == 2:
+            self.colors = list(args)
+            self.intervals = [0.0, 1.0]
+        elif len(args) > 0:
+            if len(args) % 2 != 0:
+                raise ValueError("len(args) should be even")
+            self.colors = [args[i] for i in range(1, len(args), 2)]
+            self.intervals = [args[i] for i in range(0, len(args), 2)]
+        assert len(self.colors) == len(self.intervals)
+
+    def copy(self):
+        c = ColorGradient()
+        c.colors = [e[::] for e in self.colors]
+        c.intervals = self.intervals[::]
+        return c
+
+    def _find_interval(self, v):
+        m = len(self.intervals)
+        i = 0
+        while i < m - 1 and self.intervals[i] <= v:
+            i += 1
+        return i
+
+    def _interpolate_axis(self, axis, v):
+        i = self._find_interval(v)
+        v = rinterpolate(self.intervals[i - 1], self.intervals[i], v)
+        return interpolate(self.colors[i - 1][axis], self.colors[i][axis], v)
+
+    def __call__(self, r, g, b):
+        c = self._interpolate_axis
+        return c(0, r), c(1, g), c(2, b)
+
+default_color_schemes = {}  # defined at the bottom of this file
+
+
+class ColorScheme:
+
+    def __init__(self, *args, **kwargs):
+        self.args = args
+        self.f, self.gradient = None, ColorGradient()
+
+        if len(args) == 1 and not isinstance(args[0], Basic) and callable(args[0]):
+            self.f = args[0]
+        elif len(args) == 1 and isinstance(args[0], str):
+            if args[0] in default_color_schemes:
+                cs = default_color_schemes[args[0]]
+                self.f, self.gradient = cs.f, cs.gradient.copy()
+            else:
+                self.f = lambdify('x,y,z,u,v', args[0])
+        else:
+            self.f, self.gradient = self._interpret_args(args)
+        self._test_color_function()
+        if not isinstance(self.gradient, ColorGradient):
+            raise ValueError("Color gradient not properly initialized. "
+                             "(Not a ColorGradient instance.)")
+
+    def _interpret_args(self, args):
+        f, gradient = None, self.gradient
+        atoms, lists = self._sort_args(args)
+        s = self._pop_symbol_list(lists)
+        s = self._fill_in_vars(s)
+
+        # prepare the error message for lambdification failure
+        f_str = ', '.join(str(fa) for fa in atoms)
+        s_str = (str(sa) for sa in s)
+        s_str = ', '.join(sa for sa in s_str if sa.find('unbound') < 0)
+        f_error = ValueError("Could not interpret arguments "
+                             "%s as functions of %s." % (f_str, s_str))
+
+        # try to lambdify args
+        if len(atoms) == 1:
+            fv = atoms[0]
+            try:
+                f = lambdify(s, [fv, fv, fv])
+            except TypeError:
+                raise f_error
+
+        elif len(atoms) == 3:
+            fr, fg, fb = atoms
+            try:
+                f = lambdify(s, [fr, fg, fb])
+            except TypeError:
+                raise f_error
+
+        else:
+            raise ValueError("A ColorScheme must provide 1 or 3 "
+                             "functions in x, y, z, u, and/or v.")
+
+        # try to intrepret any given color information
+        if len(lists) == 0:
+            gargs = []
+
+        elif len(lists) == 1:
+            gargs = lists[0]
+
+        elif len(lists) == 2:
+            try:
+                (r1, g1, b1), (r2, g2, b2) = lists
+            except TypeError:
+                raise ValueError("If two color arguments are given, "
+                                 "they must be given in the format "
+                                 "(r1, g1, b1), (r2, g2, b2).")
+            gargs = lists
+
+        elif len(lists) == 3:
+            try:
+                (r1, r2), (g1, g2), (b1, b2) = lists
+            except Exception:
+                raise ValueError("If three color arguments are given, "
+                                 "they must be given in the format "
+                                 "(r1, r2), (g1, g2), (b1, b2). To create "
+                                 "a multi-step gradient, use the syntax "
+                                 "[0, colorStart, step1, color1, ..., 1, "
+                                 "colorEnd].")
+            gargs = [[r1, g1, b1], [r2, g2, b2]]
+
+        else:
+            raise ValueError("Don't know what to do with collection "
+                             "arguments %s." % (', '.join(str(l) for l in lists)))
+
+        if gargs:
+            try:
+                gradient = ColorGradient(*gargs)
+            except Exception as ex:
+                raise ValueError(("Could not initialize a gradient "
+                                  "with arguments %s. Inner "
+                                  "exception: %s") % (gargs, str(ex)))
+
+        return f, gradient
+
+    def _pop_symbol_list(self, lists):
+        symbol_lists = []
+        for l in lists:
+            mark = True
+            for s in l:
+                if s is not None and not isinstance(s, Symbol):
+                    mark = False
+                    break
+            if mark:
+                lists.remove(l)
+                symbol_lists.append(l)
+        if len(symbol_lists) == 1:
+            return symbol_lists[0]
+        elif len(symbol_lists) == 0:
+            return []
+        else:
+            raise ValueError("Only one list of Symbols "
+                             "can be given for a color scheme.")
+
+    def _fill_in_vars(self, args):
+        defaults = symbols('x,y,z,u,v')
+        v_error = ValueError("Could not find what to plot.")
+        if len(args) == 0:
+            return defaults
+        if not isinstance(args, (tuple, list)):
+            raise v_error
+        if len(args) == 0:
+            return defaults
+        for s in args:
+            if s is not None and not isinstance(s, Symbol):
+                raise v_error
+        # when vars are given explicitly, any vars
+        # not given are marked 'unbound' as to not
+        # be accidentally used in an expression
+        vars = [Symbol('unbound%i' % (i)) for i in range(1, 6)]
+        # interpret as t
+        if len(args) == 1:
+            vars[3] = args[0]
+        # interpret as u,v
+        elif len(args) == 2:
+            if args[0] is not None:
+                vars[3] = args[0]
+            if args[1] is not None:
+                vars[4] = args[1]
+        # interpret as x,y,z
+        elif len(args) >= 3:
+            # allow some of x,y,z to be
+            # left unbound if not given
+            if args[0] is not None:
+                vars[0] = args[0]
+            if args[1] is not None:
+                vars[1] = args[1]
+            if args[2] is not None:
+                vars[2] = args[2]
+            # interpret the rest as t
+            if len(args) >= 4:
+                vars[3] = args[3]
+                # ...or u,v
+                if len(args) >= 5:
+                    vars[4] = args[4]
+        return vars
+
+    def _sort_args(self, args):
+        lists, atoms = sift(args,
+            lambda a: isinstance(a, (tuple, list)), binary=True)
+        return atoms, lists
+
+    def _test_color_function(self):
+        if not callable(self.f):
+            raise ValueError("Color function is not callable.")
+        try:
+            result = self.f(0, 0, 0, 0, 0)
+            if len(result) != 3:
+                raise ValueError("length should be equal to 3")
+        except TypeError:
+            raise ValueError("Color function needs to accept x,y,z,u,v, "
+                             "as arguments even if it doesn't use all of them.")
+        except AssertionError:
+            raise ValueError("Color function needs to return 3-tuple r,g,b.")
+        except Exception:
+            pass  # color function probably not valid at 0,0,0,0,0
+
+    def __call__(self, x, y, z, u, v):
+        try:
+            return self.f(x, y, z, u, v)
+        except Exception:
+            return None
+
+    def apply_to_curve(self, verts, u_set, set_len=None, inc_pos=None):
+        """
+        Apply this color scheme to a
+        set of vertices over a single
+        independent variable u.
+        """
+        bounds = create_bounds()
+        cverts = []
+        if callable(set_len):
+            set_len(len(u_set)*2)
+        # calculate f() = r,g,b for each vert
+        # and find the min and max for r,g,b
+        for _u in range(len(u_set)):
+            if verts[_u] is None:
+                cverts.append(None)
+            else:
+                x, y, z = verts[_u]
+                u, v = u_set[_u], None
+                c = self(x, y, z, u, v)
+                if c is not None:
+                    c = list(c)
+                    update_bounds(bounds, c)
+                cverts.append(c)
+            if callable(inc_pos):
+                inc_pos()
+        # scale and apply gradient
+        for _u in range(len(u_set)):
+            if cverts[_u] is not None:
+                for _c in range(3):
+                    # scale from [f_min, f_max] to [0,1]
+                    cverts[_u][_c] = rinterpolate(bounds[_c][0], bounds[_c][1],
+                                                  cverts[_u][_c])
+                # apply gradient
+                cverts[_u] = self.gradient(*cverts[_u])
+            if callable(inc_pos):
+                inc_pos()
+        return cverts
+
+    def apply_to_surface(self, verts, u_set, v_set, set_len=None, inc_pos=None):
+        """
+        Apply this color scheme to a
+        set of vertices over two
+        independent variables u and v.
+        """
+        bounds = create_bounds()
+        cverts = []
+        if callable(set_len):
+            set_len(len(u_set)*len(v_set)*2)
+        # calculate f() = r,g,b for each vert
+        # and find the min and max for r,g,b
+        for _u in range(len(u_set)):
+            column = []
+            for _v in range(len(v_set)):
+                if verts[_u][_v] is None:
+                    column.append(None)
+                else:
+                    x, y, z = verts[_u][_v]
+                    u, v = u_set[_u], v_set[_v]
+                    c = self(x, y, z, u, v)
+                    if c is not None:
+                        c = list(c)
+                        update_bounds(bounds, c)
+                    column.append(c)
+                if callable(inc_pos):
+                    inc_pos()
+            cverts.append(column)
+        # scale and apply gradient
+        for _u in range(len(u_set)):
+            for _v in range(len(v_set)):
+                if cverts[_u][_v] is not None:
+                    # scale from [f_min, f_max] to [0,1]
+                    for _c in range(3):
+                        cverts[_u][_v][_c] = rinterpolate(bounds[_c][0],
+                                             bounds[_c][1], cverts[_u][_v][_c])
+                    # apply gradient
+                    cverts[_u][_v] = self.gradient(*cverts[_u][_v])
+                if callable(inc_pos):
+                    inc_pos()
+        return cverts
+
+    def str_base(self):
+        return ", ".join(str(a) for a in self.args)
+
+    def __repr__(self):
+        return "%s" % (self.str_base())
+
+
+x, y, z, t, u, v = symbols('x,y,z,t,u,v')
+
+default_color_schemes['rainbow'] = ColorScheme(z, y, x)
+default_color_schemes['zfade'] = ColorScheme(z, (0.4, 0.4, 0.97),
+                                             (0.97, 0.4, 0.4), (None, None, z))
+default_color_schemes['zfade3'] = ColorScheme(z, (None, None, z),
+                                              [0.00, (0.2, 0.2, 1.0),
+                                               0.35, (0.2, 0.8, 0.4),
+                                               0.50, (0.3, 0.9, 0.3),
+                                               0.65, (0.4, 0.8, 0.2),
+                                               1.00, (1.0, 0.2, 0.2)])
+
+default_color_schemes['zfade4'] = ColorScheme(z, (None, None, z),
+                                              [0.0, (0.3, 0.3, 1.0),
+                                               0.30, (0.3, 1.0, 0.3),
+                                               0.55, (0.95, 1.0, 0.2),
+                                               0.65, (1.0, 0.95, 0.2),
+                                               0.85, (1.0, 0.7, 0.2),
+                                               1.0, (1.0, 0.3, 0.2)])

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/pygletplot/managed_window.py

@@ -0,0 +1,106 @@
+from pyglet.window import Window
+from pyglet.clock import Clock
+
+from threading import Thread, Lock
+
+gl_lock = Lock()
+
+
+class ManagedWindow(Window):
+    """
+    A pyglet window with an event loop which executes automatically
+    in a separate thread. Behavior is added by creating a subclass
+    which overrides setup, update, and/or draw.
+    """
+    fps_limit = 30
+    default_win_args = {"width": 600,
+                            "height": 500,
+                            "vsync": False,
+                            "resizable": True}
+
+    def __init__(self, **win_args):
+        """
+        It is best not to override this function in the child
+        class, unless you need to take additional arguments.
+        Do any OpenGL initialization calls in setup().
+        """
+
+        # check if this is run from the doctester
+        if win_args.get('runfromdoctester', False):
+            return
+
+        self.win_args = dict(self.default_win_args, **win_args)
+        self.Thread = Thread(target=self.__event_loop__)
+        self.Thread.start()
+
+    def __event_loop__(self, **win_args):
+        """
+        The event loop thread function. Do not override or call
+        directly (it is called by __init__).
+        """
+        gl_lock.acquire()
+        try:
+            try:
+                super().__init__(**self.win_args)
+                self.switch_to()
+                self.setup()
+            except Exception as e:
+                print("Window initialization failed: %s" % (str(e)))
+                self.has_exit = True
+        finally:
+            gl_lock.release()
+
+        clock = Clock()
+        clock.fps_limit = self.fps_limit
+        while not self.has_exit:
+            dt = clock.tick()
+            gl_lock.acquire()
+            try:
+                try:
+                    self.switch_to()
+                    self.dispatch_events()
+                    self.clear()
+                    self.update(dt)
+                    self.draw()
+                    self.flip()
+                except Exception as e:
+                    print("Uncaught exception in event loop: %s" % str(e))
+                    self.has_exit = True
+            finally:
+                gl_lock.release()
+        super().close()
+
+    def close(self):
+        """
+        Closes the window.
+        """
+        self.has_exit = True
+
+    def setup(self):
+        """
+        Called once before the event loop begins.
+        Override this method in a child class. This
+        is the best place to put things like OpenGL
+        initialization calls.
+        """
+        pass
+
+    def update(self, dt):
+        """
+        Called before draw during each iteration of
+        the event loop. dt is the elapsed time in
+        seconds since the last update. OpenGL rendering
+        calls are best put in draw() rather than here.
+        """
+        pass
+
+    def draw(self):
+        """
+        Called after update during each iteration of
+        the event loop. Put OpenGL rendering calls
+        here.
+        """
+        pass
+
+if __name__ == '__main__':
+    ManagedWindow()

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/pygletplot/plot.py

@@ -0,0 +1,464 @@
+from threading import RLock
+
+# it is sufficient to import "pyglet" here once
+try:
+    import pyglet.gl as pgl
+except ImportError:
+    raise ImportError("pyglet is required for plotting.\n "
+                      "visit https://pyglet.org/")
+
+from sympy.core.numbers import Integer
+from sympy.external.gmpy import SYMPY_INTS
+from sympy.geometry.entity import GeometryEntity
+from sympy.plotting.pygletplot.plot_axes import PlotAxes
+from sympy.plotting.pygletplot.plot_mode import PlotMode
+from sympy.plotting.pygletplot.plot_object import PlotObject
+from sympy.plotting.pygletplot.plot_window import PlotWindow
+from sympy.plotting.pygletplot.util import parse_option_string
+from sympy.utilities.decorator import doctest_depends_on
+from sympy.utilities.iterables import is_sequence
+
+from time import sleep
+from os import getcwd, listdir
+
+import ctypes
+
+@doctest_depends_on(modules=('pyglet',))
+class PygletPlot:
+    """
+    Plot Examples
+    =============
+
+    See examples/advanced/pyglet_plotting.py for many more examples.
+
+    >>> from sympy.plotting.pygletplot import PygletPlot as Plot
+    >>> from sympy.abc import x, y, z
+
+    >>> Plot(x*y**3-y*x**3)
+    [0]: -x**3*y + x*y**3, 'mode=cartesian'
+
+    >>> p = Plot()
+    >>> p[1] = x*y
+    >>> p[1].color = z, (0.4,0.4,0.9), (0.9,0.4,0.4)
+
+    >>> p = Plot()
+    >>> p[1] =  x**2+y**2
+    >>> p[2] = -x**2-y**2
+
+
+    Variable Intervals
+    ==================
+
+    The basic format is [var, min, max, steps], but the
+    syntax is flexible and arguments left out are taken
+    from the defaults for the current coordinate mode:
+
+    >>> Plot(x**2) # implies [x,-5,5,100]
+    [0]: x**2, 'mode=cartesian'
+    >>> Plot(x**2, [], []) # [x,-1,1,40], [y,-1,1,40]
+    [0]: x**2, 'mode=cartesian'
+    >>> Plot(x**2-y**2, [100], [100]) # [x,-1,1,100], [y,-1,1,100]
+    [0]: x**2 - y**2, 'mode=cartesian'
+    >>> Plot(x**2, [x,-13,13,100])
+    [0]: x**2, 'mode=cartesian'
+    >>> Plot(x**2, [-13,13]) # [x,-13,13,100]
+    [0]: x**2, 'mode=cartesian'
+    >>> Plot(x**2, [x,-13,13]) # [x,-13,13,10]
+    [0]: x**2, 'mode=cartesian'
+    >>> Plot(1*x, [], [x], mode='cylindrical')
+    ... # [unbound_theta,0,2*Pi,40], [x,-1,1,20]
+    [0]: x, 'mode=cartesian'
+
+
+    Coordinate Modes
+    ================
+
+    Plot supports several curvilinear coordinate modes, and
+    they independent for each plotted function. You can specify
+    a coordinate mode explicitly with the 'mode' named argument,
+    but it can be automatically determined for Cartesian or
+    parametric plots, and therefore must only be specified for
+    polar, cylindrical, and spherical modes.
+
+    Specifically, Plot(function arguments) and Plot[n] =
+    (function arguments) will interpret your arguments as a
+    Cartesian plot if you provide one function and a parametric
+    plot if you provide two or three functions. Similarly, the
+    arguments will be interpreted as a curve if one variable is
+    used, and a surface if two are used.
+
+    Supported mode names by number of variables:
+
+    1: parametric, cartesian, polar
+    2: parametric, cartesian, cylindrical = polar, spherical
+
+    >>> Plot(1, mode='spherical')
+
+
+    Calculator-like Interface
+    =========================
+
+    >>> p = Plot(visible=False)
+    >>> f = x**2
+    >>> p[1] = f
+    >>> p[2] = f.diff(x)
+    >>> p[3] = f.diff(x).diff(x)
+    >>> p
+    [1]: x**2, 'mode=cartesian'
+    [2]: 2*x, 'mode=cartesian'
+    [3]: 2, 'mode=cartesian'
+    >>> p.show()
+    >>> p.clear()
+    >>> p
+    <blank plot>
+    >>> p[1] =  x**2+y**2
+    >>> p[1].style = 'solid'
+    >>> p[2] = -x**2-y**2
+    >>> p[2].style = 'wireframe'
+    >>> p[1].color = z, (0.4,0.4,0.9), (0.9,0.4,0.4)
+    >>> p[1].style = 'both'
+    >>> p[2].style = 'both'
+    >>> p.close()
+
+
+    Plot Window Keyboard Controls
+    =============================
+
+    Screen Rotation:
+        X,Y axis      Arrow Keys, A,S,D,W, Numpad 4,6,8,2
+        Z axis        Q,E, Numpad 7,9
+
+    Model Rotation:
+        Z axis        Z,C, Numpad 1,3
+
+    Zoom:             R,F, PgUp,PgDn, Numpad +,-
+
+    Reset Camera:     X, Numpad 5
+
+    Camera Presets:
+        XY            F1
+        XZ            F2
+        YZ            F3
+        Perspective   F4
+
+    Sensitivity Modifier: SHIFT
+
+    Axes Toggle:
+        Visible       F5
+        Colors        F6
+
+    Close Window:     ESCAPE
+
+    =============================
+
+    """
+
+    @doctest_depends_on(modules=('pyglet',))
+    def __init__(self, *fargs, **win_args):
+        """
+        Positional Arguments
+        ====================
+
+        Any given positional arguments are used to
+        initialize a plot function at index 1. In
+        other words...
+
+        >>> from sympy.plotting.pygletplot import PygletPlot as Plot
+        >>> from sympy.abc import x
+        >>> p = Plot(x**2, visible=False)
+
+        ...is equivalent to...
+
+        >>> p = Plot(visible=False)
+        >>> p[1] = x**2
+
+        Note that in earlier versions of the plotting
+        module, you were able to specify multiple
+        functions in the initializer. This functionality
+        has been dropped in favor of better automatic
+        plot plot_mode detection.
+
+
+        Named Arguments
+        ===============
+
+        axes
+            An option string of the form
+            "key1=value1; key2 = value2" which
+            can use the following options:
+
+            style = ordinate
+                none OR frame OR box OR ordinate
+
+            stride = 0.25
+                val OR (val_x, val_y, val_z)
+
+            overlay = True (draw on top of plot)
+                True OR False
+
+            colored = False (False uses Black,
+                             True uses colors
+                             R,G,B = X,Y,Z)
+                True OR False
+
+            label_axes = False (display axis names
+                                at endpoints)
+                True OR False
+
+        visible = True (show immediately
+            True OR False
+
+
+        The following named arguments are passed as
+        arguments to window initialization:
+
+        antialiasing = True
+            True OR False
+
+        ortho = False
+            True OR False
+
+        invert_mouse_zoom = False
+            True OR False
+
+        """
+        # Register the plot modes
+        from . import plot_modes # noqa
+
+        self._win_args = win_args
+        self._window = None
+
+        self._render_lock = RLock()
+
+        self._functions = {}
+        self._pobjects = []
+        self._screenshot = ScreenShot(self)
+
+        axe_options = parse_option_string(win_args.pop('axes', ''))
+        self.axes = PlotAxes(**axe_options)
+        self._pobjects.append(self.axes)
+
+        self[0] = fargs
+        if win_args.get('visible', True):
+            self.show()
+
+    ## Window Interfaces
+
+    def show(self):
+        """
+        Creates and displays a plot window, or activates it
+        (gives it focus) if it has already been created.
+        """
+        if self._window and not self._window.has_exit:
+            self._window.activate()
+        else:
+            self._win_args['visible'] = True
+            self.axes.reset_resources()
+
+            #if hasattr(self, '_doctest_depends_on'):
+            #    self._win_args['runfromdoctester'] = True
+
+            self._window = PlotWindow(self, **self._win_args)
+
+    def close(self):
+        """
+        Closes the plot window.
+        """
+        if self._window:
+            self._window.close()
+
+    def saveimage(self, outfile=None, format='', size=(600, 500)):
+        """
+        Saves a screen capture of the plot window to an
+        image file.
+
+        If outfile is given, it can either be a path
+        or a file object. Otherwise a png image will
+        be saved to the current working directory.
+        If the format is omitted, it is determined from
+        the filename extension.
+        """
+        self._screenshot.save(outfile, format, size)
+
+    ## Function List Interfaces
+
+    def clear(self):
+        """
+        Clears the function list of this plot.
+        """
+        self._render_lock.acquire()
+        self._functions = {}
+        self.adjust_all_bounds()
+        self._render_lock.release()
+
+    def __getitem__(self, i):
+        """
+        Returns the function at position i in the
+        function list.
+        """
+        return self._functions[i]
+
+    def __setitem__(self, i, args):
+        """
+        Parses and adds a PlotMode to the function
+        list.
+        """
+        if not (isinstance(i, (SYMPY_INTS, Integer)) and i >= 0):
+            raise ValueError("Function index must "
+                             "be an integer >= 0.")
+
+        if isinstance(args, PlotObject):
+            f = args
+        else:
+            if (not is_sequence(args)) or isinstance(args, GeometryEntity):
+                args = [args]
+            if len(args) == 0:
+                return  # no arguments given
+            kwargs = {"bounds_callback": self.adjust_all_bounds}
+            f = PlotMode(*args, **kwargs)
+
+        if f:
+            self._render_lock.acquire()
+            self._functions[i] = f
+            self._render_lock.release()
+        else:
+            raise ValueError("Failed to parse '%s'."
+                    % ', '.join(str(a) for a in args))
+
+    def __delitem__(self, i):
+        """
+        Removes the function in the function list at
+        position i.
+        """
+        self._render_lock.acquire()
+        del self._functions[i]
+        self.adjust_all_bounds()
+        self._render_lock.release()
+
+    def firstavailableindex(self):
+        """
+        Returns the first unused index in the function list.
+        """
+        i = 0
+        self._render_lock.acquire()
+        while i in self._functions:
+            i += 1
+        self._render_lock.release()
+        return i
+
+    def append(self, *args):
+        """
+        Parses and adds a PlotMode to the function
+        list at the first available index.
+        """
+        self.__setitem__(self.firstavailableindex(), args)
+
+    def __len__(self):
+        """
+        Returns the number of functions in the function list.
+        """
+        return len(self._functions)
+
+    def __iter__(self):
+        """
+        Allows iteration of the function list.
+        """
+        return self._functions.itervalues()
+
+    def __repr__(self):
+        return str(self)
+
+    def __str__(self):
+        """
+        Returns a string containing a new-line separated
+        list of the functions in the function list.
+        """
+        s = ""
+        if len(self._functions) == 0:
+            s += "<blank plot>"
+        else:
+            self._render_lock.acquire()
+            s += "\n".join(["%s[%i]: %s" % ("", i, str(self._functions[i]))
+                            for i in self._functions])
+            self._render_lock.release()
+        return s
+
+    def adjust_all_bounds(self):
+        self._render_lock.acquire()
+        self.axes.reset_bounding_box()
+        for f in self._functions:
+            self.axes.adjust_bounds(self._functions[f].bounds)
+        self._render_lock.release()
+
+    def wait_for_calculations(self):
+        sleep(0)
+        self._render_lock.acquire()
+        for f in self._functions:
+            a = self._functions[f]._get_calculating_verts
+            b = self._functions[f]._get_calculating_cverts
+            while a() or b():
+                sleep(0)
+        self._render_lock.release()
+
+class ScreenShot:
+    def __init__(self, plot):
+        self._plot = plot
+        self.screenshot_requested = False
+        self.outfile = None
+        self.format = ''
+        self.invisibleMode = False
+        self.flag = 0
+
+    def __bool__(self):
+        return self.screenshot_requested
+
+    def _execute_saving(self):
+        if self.flag < 3:
+            self.flag += 1
+            return
+
+        size_x, size_y = self._plot._window.get_size()
+        size = size_x*size_y*4*ctypes.sizeof(ctypes.c_ubyte)
+        image = ctypes.create_string_buffer(size)
+        pgl.glReadPixels(0, 0, size_x, size_y, pgl.GL_RGBA, pgl.GL_UNSIGNED_BYTE, image)
+        from PIL import Image
+        im = Image.frombuffer('RGBA', (size_x, size_y),
+                              image.raw, 'raw', 'RGBA', 0, 1)
+        im.transpose(Image.FLIP_TOP_BOTTOM).save(self.outfile, self.format)
+
+        self.flag = 0
+        self.screenshot_requested = False
+        if self.invisibleMode:
+            self._plot._window.close()
+
+    def save(self, outfile=None, format='', size=(600, 500)):
+        self.outfile = outfile
+        self.format = format
+        self.size = size
+        self.screenshot_requested = True
+
+        if not self._plot._window or self._plot._window.has_exit:
+            self._plot._win_args['visible'] = False
+
+            self._plot._win_args['width'] = size[0]
+            self._plot._win_args['height'] = size[1]
+
+            self._plot.axes.reset_resources()
+            self._plot._window = PlotWindow(self._plot, **self._plot._win_args)
+            self.invisibleMode = True
+
+        if self.outfile is None:
+            self.outfile = self._create_unique_path()
+            print(self.outfile)
+
+    def _create_unique_path(self):
+        cwd = getcwd()
+        l = listdir(cwd)
+        path = ''
+        i = 0
+        while True:
+            if not 'plot_%s.png' % i in l:
+                path = cwd + '/plot_%s.png' % i
+                break
+            i += 1
+        return path

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/pygletplot/plot_axes.py

@@ -0,0 +1,251 @@
+import pyglet.gl as pgl
+from pyglet import font
+
+from sympy.core import S
+from sympy.plotting.pygletplot.plot_object import PlotObject
+from sympy.plotting.pygletplot.util import billboard_matrix, dot_product, \
+        get_direction_vectors, strided_range, vec_mag, vec_sub
+from sympy.utilities.iterables import is_sequence
+
+
+class PlotAxes(PlotObject):
+
+    def __init__(self, *args,
+            style='', none=None, frame=None, box=None, ordinate=None,
+            stride=0.25,
+            visible='', overlay='', colored='', label_axes='', label_ticks='',
+            tick_length=0.1,
+            font_face='Arial', font_size=28,
+            **kwargs):
+        # initialize style parameter
+        style = style.lower()
+
+        # allow alias kwargs to override style kwarg
+        if none is not None:
+            style = 'none'
+        if frame is not None:
+            style = 'frame'
+        if box is not None:
+            style = 'box'
+        if ordinate is not None:
+            style = 'ordinate'
+
+        if style in ['', 'ordinate']:
+            self._render_object = PlotAxesOrdinate(self)
+        elif style in ['frame', 'box']:
+            self._render_object = PlotAxesFrame(self)
+        elif style in ['none']:
+            self._render_object = None
+        else:
+            raise ValueError(("Unrecognized axes style %s.") % (style))
+
+        # initialize stride parameter
+        try:
+            stride = eval(stride)
+        except TypeError:
+            pass
+        if is_sequence(stride):
+            if len(stride) != 3:
+                raise ValueError("length should be equal to 3")
+            self._stride = stride
+        else:
+            self._stride = [stride, stride, stride]
+        self._tick_length = float(tick_length)
+
+        # setup bounding box and ticks
+        self._origin = [0, 0, 0]
+        self.reset_bounding_box()
+
+        def flexible_boolean(input, default):
+            if input in [True, False]:
+                return input
+            if input in ('f', 'F', 'false', 'False'):
+                return False
+            if input in ('t', 'T', 'true', 'True'):
+                return True
+            return default
+
+        # initialize remaining parameters
+        self.visible = flexible_boolean(kwargs, True)
+        self._overlay = flexible_boolean(overlay, True)
+        self._colored = flexible_boolean(colored, False)
+        self._label_axes = flexible_boolean(label_axes, False)
+        self._label_ticks = flexible_boolean(label_ticks, True)
+
+        # setup label font
+        self.font_face = font_face
+        self.font_size = font_size
+
+        # this is also used to reinit the
+        # font on window close/reopen
+        self.reset_resources()
+
+    def reset_resources(self):
+        self.label_font = None
+
+    def reset_bounding_box(self):
+        self._bounding_box = [[None, None], [None, None], [None, None]]
+        self._axis_ticks = [[], [], []]
+
+    def draw(self):
+        if self._render_object:
+            pgl.glPushAttrib(pgl.GL_ENABLE_BIT | pgl.GL_POLYGON_BIT | pgl.GL_DEPTH_BUFFER_BIT)
+            if self._overlay:
+                pgl.glDisable(pgl.GL_DEPTH_TEST)
+            self._render_object.draw()
+            pgl.glPopAttrib()
+
+    def adjust_bounds(self, child_bounds):
+        b = self._bounding_box
+        c = child_bounds
+        for i in range(3):
+            if abs(c[i][0]) is S.Infinity or abs(c[i][1]) is S.Infinity:
+                continue
+            b[i][0] = c[i][0] if b[i][0] is None else min([b[i][0], c[i][0]])
+            b[i][1] = c[i][1] if b[i][1] is None else max([b[i][1], c[i][1]])
+            self._bounding_box = b
+            self._recalculate_axis_ticks(i)
+
+    def _recalculate_axis_ticks(self, axis):
+        b = self._bounding_box
+        if b[axis][0] is None or b[axis][1] is None:
+            self._axis_ticks[axis] = []
+        else:
+            self._axis_ticks[axis] = strided_range(b[axis][0], b[axis][1],
+                                                   self._stride[axis])
+
+    def toggle_visible(self):
+        self.visible = not self.visible
+
+    def toggle_colors(self):
+        self._colored = not self._colored
+
+
+class PlotAxesBase(PlotObject):
+
+    def __init__(self, parent_axes):
+        self._p = parent_axes
+
+    def draw(self):
+        color = [([0.2, 0.1, 0.3], [0.2, 0.1, 0.3], [0.2, 0.1, 0.3]),
+                 ([0.9, 0.3, 0.5], [0.5, 1.0, 0.5], [0.3, 0.3, 0.9])][self._p._colored]
+        self.draw_background(color)
+        self.draw_axis(2, color[2])
+        self.draw_axis(1, color[1])
+        self.draw_axis(0, color[0])
+
+    def draw_background(self, color):
+        pass  # optional
+
+    def draw_axis(self, axis, color):
+        raise NotImplementedError()
+
+    def draw_text(self, text, position, color, scale=1.0):
+        if len(color) == 3:
+            color = (color[0], color[1], color[2], 1.0)
+
+        if self._p.label_font is None:
+            self._p.label_font = font.load(self._p.font_face,
+                                           self._p.font_size,
+                                           bold=True, italic=False)
+
+        label = font.Text(self._p.label_font, text,
+                          color=color,
+                          valign=font.Text.BASELINE,
+                          halign=font.Text.CENTER)
+
+        pgl.glPushMatrix()
+        pgl.glTranslatef(*position)
+        billboard_matrix()
+        scale_factor = 0.005 * scale
+        pgl.glScalef(scale_factor, scale_factor, scale_factor)
+        pgl.glColor4f(0, 0, 0, 0)
+        label.draw()
+        pgl.glPopMatrix()
+
+    def draw_line(self, v, color):
+        o = self._p._origin
+        pgl.glBegin(pgl.GL_LINES)
+        pgl.glColor3f(*color)
+        pgl.glVertex3f(v[0][0] + o[0], v[0][1] + o[1], v[0][2] + o[2])
+        pgl.glVertex3f(v[1][0] + o[0], v[1][1] + o[1], v[1][2] + o[2])
+        pgl.glEnd()
+
+
+class PlotAxesOrdinate(PlotAxesBase):
+
+    def __init__(self, parent_axes):
+        super().__init__(parent_axes)
+
+    def draw_axis(self, axis, color):
+        ticks = self._p._axis_ticks[axis]
+        radius = self._p._tick_length / 2.0
+        if len(ticks) < 2:
+            return
+
+        # calculate the vector for this axis
+        axis_lines = [[0, 0, 0], [0, 0, 0]]
+        axis_lines[0][axis], axis_lines[1][axis] = ticks[0], ticks[-1]
+        axis_vector = vec_sub(axis_lines[1], axis_lines[0])
+
+        # calculate angle to the z direction vector
+        pos_z = get_direction_vectors()[2]
+        d = abs(dot_product(axis_vector, pos_z))
+        d = d / vec_mag(axis_vector)
+
+        # don't draw labels if we're looking down the axis
+        labels_visible = abs(d - 1.0) > 0.02
+
+        # draw the ticks and labels
+        for tick in ticks:
+            self.draw_tick_line(axis, color, radius, tick, labels_visible)
+
+        # draw the axis line and labels
+        self.draw_axis_line(axis, color, ticks[0], ticks[-1], labels_visible)
+
+    def draw_axis_line(self, axis, color, a_min, a_max, labels_visible):
+        axis_line = [[0, 0, 0], [0, 0, 0]]
+        axis_line[0][axis], axis_line[1][axis] = a_min, a_max
+        self.draw_line(axis_line, color)
+        if labels_visible:
+            self.draw_axis_line_labels(axis, color, axis_line)
+
+    def draw_axis_line_labels(self, axis, color, axis_line):
+        if not self._p._label_axes:
+            return
+        axis_labels = [axis_line[0][::], axis_line[1][::]]
+        axis_labels[0][axis] -= 0.3
+        axis_labels[1][axis] += 0.3
+        a_str = ['X', 'Y', 'Z'][axis]
+        self.draw_text("-" + a_str, axis_labels[0], color)
+        self.draw_text("+" + a_str, axis_labels[1], color)
+
+    def draw_tick_line(self, axis, color, radius, tick, labels_visible):
+        tick_axis = {0: 1, 1: 0, 2: 1}[axis]
+        tick_line = [[0, 0, 0], [0, 0, 0]]
+        tick_line[0][axis] = tick_line[1][axis] = tick
+        tick_line[0][tick_axis], tick_line[1][tick_axis] = -radius, radius
+        self.draw_line(tick_line, color)
+        if labels_visible:
+            self.draw_tick_line_label(axis, color, radius, tick)
+
+    def draw_tick_line_label(self, axis, color, radius, tick):
+        if not self._p._label_axes:
+            return
+        tick_label_vector = [0, 0, 0]
+        tick_label_vector[axis] = tick
+        tick_label_vector[{0: 1, 1: 0, 2: 1}[axis]] = [-1, 1, 1][
+            axis] * radius * 3.5
+        self.draw_text(str(tick), tick_label_vector, color, scale=0.5)
+
+
+class PlotAxesFrame(PlotAxesBase):
+
+    def __init__(self, parent_axes):
+        super().__init__(parent_axes)
+
+    def draw_background(self, color):
+        pass
+
+    def draw_axis(self, axis, color):
+        raise NotImplementedError()

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/plotting/pygletplot/plot_camera.py

@@ -0,0 +1,124 @@
+import pyglet.gl as pgl
+from sympy.plotting.pygletplot.plot_rotation import get_spherical_rotatation
+from sympy.plotting.pygletplot.util import get_model_matrix, model_to_screen, \
+                                            screen_to_model, vec_subs
+
+
+class PlotCamera:
+
+    min_dist = 0.05
+    max_dist = 500.0
+
+    min_ortho_dist = 100.0
+    max_ortho_dist = 10000.0
+
+    _default_dist = 6.0
+    _default_ortho_dist = 600.0
+
+    rot_presets = {
+        'xy': (0, 0, 0),
+        'xz': (-90, 0, 0),
+        'yz': (0, 90, 0),
+        'perspective': (-45, 0, -45)
+    }
+
+    def __init__(self, window, ortho=False):
+        self.window = window
+        self.axes = self.window.plot.axes
+        self.ortho = ortho
+        self.reset()
+
+    def init_rot_matrix(self):
+        pgl.glPushMatrix()
+        pgl.glLoadIdentity()
+        self._rot = get_model_matrix()
+        pgl.glPopMatrix()
+
+    def set_rot_preset(self, preset_name):
+        self.init_rot_matrix()
+        if preset_name not in self.rot_presets:
+            raise ValueError(
+                "%s is not a valid rotation preset." % preset_name)
+        r = self.rot_presets[preset_name]
+        self.euler_rotate(r[0], 1, 0, 0)
+        self.euler_rotate(r[1], 0, 1, 0)
+        self.euler_rotate(r[2], 0, 0, 1)
+
+    def reset(self):
+        self._dist = 0.0
+        self._x, self._y = 0.0, 0.0
+        self._rot = None
+        if self.ortho:
+            self._dist = self._default_ortho_dist
+        else:
+            self._dist = self._default_dist
+        self.init_rot_matrix()
+
+    def mult_rot_matrix(self, rot):
+        pgl.glPushMatrix()
+        pgl.glLoadMatrixf(rot)
+        pgl.glMultMatrixf(self._rot)
+        self._rot = get_model_matrix()
+        pgl.glPopMatrix()
+
+    def setup_projection(self):
+        pgl.glMatrixMode(pgl.GL_PROJECTION)
+        pgl.glLoadIdentity()
+        if self.ortho:
+            # yep, this is pseudo ortho (don't tell anyone)
+            pgl.gluPerspective(
+                0.3, float(self.window.width)/float(self.window.height),
+                self.min_ortho_dist - 0.01, self.max_ortho_dist + 0.01)
+        else:
+            pgl.gluPerspective(
+                30.0, float(self.window.width)/float(self.window.height),
+                self.min_dist - 0.01, self.max_dist + 0.01)
+        pgl.glMatrixMode(pgl.GL_MODELVIEW)
+
+    def _get_scale(self):
+        return 1.0, 1.0, 1.0
+
+    def apply_transformation(self):
+        pgl.glLoadIdentity()
+        pgl.glTranslatef(self._x, self._y, -self._dist)
+        if self._rot is not None:
+            pgl.glMultMatrixf(self._rot)
+        pgl.glScalef(*self._get_scale())
+
+    def spherical_rotate(self, p1, p2, sensitivity=1.0):
+        mat = get_spherical_rotatation(p1, p2, self.window.width,
+                                       self.window.height, sensitivity)
+        if mat is not None:
+            self.mult_rot_matrix(mat)
+
+    def euler_rotate(self, angle, x, y, z):
+        pgl.glPushMatrix()
+        pgl.glLoadMatrixf(self._rot)
+        pgl.glRotatef(angle, x, y, z)
+        self._rot = get_model_matrix()
+        pgl.glPopMatrix()
+
+    def zoom_relative(self, clicks, sensitivity):
+
+        if self.ortho:
+            dist_d = clicks * sensitivity * 50.0
+            min_dist = self.min_ortho_dist
+            max_dist = self.max_ortho_dist
+        else:
+            dist_d = clicks * sensitivity
+            min_dist = self.min_dist
+            max_dist = self.max_dist
+
+        new_dist = (self._dist - dist_d)
+        if (clicks < 0 and new_dist < max_dist) or new_dist > min_dist:
+            self._dist = new_dist
+
+    def mouse_translate(self, x, y, dx, dy):
+        pgl.glPushMatrix()
+        pgl.glLoadIdentity()
+        pgl.glTranslatef(0, 0, -self._dist)
+        z = model_to_screen(0, 0, 0)[2]
+        d = vec_subs(screen_to_model(x, y, z), screen_to_model(x - dx, y - dy, z))
+        pgl.glPopMatrix()
+        self._x += d[0]
+        self._y += d[1]