Add files using upload-large-folder tool

ckpts/universal/global_step120/zero/11.mlp.dense_h_to_4h.weight/fp32.pt

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

ckpts/universal/global_step120/zero/12.attention.query_key_value.weight/fp32.pt

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

ckpts/universal/global_step80/mp_rank_00_model_states.pt

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

ckpts/universal/global_step80/mp_rank_01_model_states.pt

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

ckpts/universal/global_step80/mp_rank_02_model_states.pt

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

ckpts/universal/global_step80/mp_rank_03_model_states.pt

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

ckpts/universal/global_step80/mp_rank_04_model_states.pt

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

ckpts/universal/global_step80/mp_rank_05_model_states.pt

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

venv/lib/python3.10/site-packages/sympy/physics/continuum_mechanics/__init__.py

@@ -0,0 +1,5 @@
+__all__ = ['Beam',
+            'Truss']
+
+from .beam import Beam
+from .truss import Truss

venv/lib/python3.10/site-packages/sympy/physics/continuum_mechanics/tests/test_beam.py

@@ -0,0 +1,782 @@
+from sympy.core.function import expand
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.sets.sets import Interval
+from sympy.simplify.simplify import simplify
+from sympy.physics.continuum_mechanics.beam import Beam
+from sympy.functions import SingularityFunction, Piecewise, meijerg, Abs, log
+from sympy.testing.pytest import raises
+from sympy.physics.units import meter, newton, kilo, giga, milli
+from sympy.physics.continuum_mechanics.beam import Beam3D
+from sympy.geometry import Circle, Polygon, Point2D, Triangle
+from sympy.core.sympify import sympify
+
+x = Symbol('x')
+y = Symbol('y')
+R1, R2 = symbols('R1, R2')
+
+
+def test_Beam():
+    E = Symbol('E')
+    E_1 = Symbol('E_1')
+    I = Symbol('I')
+    I_1 = Symbol('I_1')
+    A = Symbol('A')
+
+    b = Beam(1, E, I)
+    assert b.length == 1
+    assert b.elastic_modulus == E
+    assert b.second_moment == I
+    assert b.variable == x
+
+    # Test the length setter
+    b.length = 4
+    assert b.length == 4
+
+    # Test the E setter
+    b.elastic_modulus = E_1
+    assert b.elastic_modulus == E_1
+
+    # Test the I setter
+    b.second_moment = I_1
+    assert b.second_moment is I_1
+
+    # Test the variable setter
+    b.variable = y
+    assert b.variable is y
+
+    # Test for all boundary conditions.
+    b.bc_deflection = [(0, 2)]
+    b.bc_slope = [(0, 1)]
+    assert b.boundary_conditions == {'deflection': [(0, 2)], 'slope': [(0, 1)]}
+
+    # Test for slope boundary condition method
+    b.bc_slope.extend([(4, 3), (5, 0)])
+    s_bcs = b.bc_slope
+    assert s_bcs == [(0, 1), (4, 3), (5, 0)]
+
+    # Test for deflection boundary condition method
+    b.bc_deflection.extend([(4, 3), (5, 0)])
+    d_bcs = b.bc_deflection
+    assert d_bcs == [(0, 2), (4, 3), (5, 0)]
+
+    # Test for updated boundary conditions
+    bcs_new = b.boundary_conditions
+    assert bcs_new == {
+        'deflection': [(0, 2), (4, 3), (5, 0)],
+        'slope': [(0, 1), (4, 3), (5, 0)]}
+
+    b1 = Beam(30, E, I)
+    b1.apply_load(-8, 0, -1)
+    b1.apply_load(R1, 10, -1)
+    b1.apply_load(R2, 30, -1)
+    b1.apply_load(120, 30, -2)
+    b1.bc_deflection = [(10, 0), (30, 0)]
+    b1.solve_for_reaction_loads(R1, R2)
+
+    # Test for finding reaction forces
+    p = b1.reaction_loads
+    q = {R1: 6, R2: 2}
+    assert p == q
+
+    # Test for load distribution function.
+    p = b1.load
+    q = -8*SingularityFunction(x, 0, -1) + 6*SingularityFunction(x, 10, -1) \
+    + 120*SingularityFunction(x, 30, -2) + 2*SingularityFunction(x, 30, -1)
+    assert p == q
+
+    # Test for shear force distribution function
+    p = b1.shear_force()
+    q = 8*SingularityFunction(x, 0, 0) - 6*SingularityFunction(x, 10, 0) \
+    - 120*SingularityFunction(x, 30, -1) - 2*SingularityFunction(x, 30, 0)
+    assert p == q
+
+    # Test for shear stress distribution function
+    p = b1.shear_stress()
+    q = (8*SingularityFunction(x, 0, 0) - 6*SingularityFunction(x, 10, 0) \
+    - 120*SingularityFunction(x, 30, -1) \
+    - 2*SingularityFunction(x, 30, 0))/A
+    assert p==q
+
+    # Test for bending moment distribution function
+    p = b1.bending_moment()
+    q = 8*SingularityFunction(x, 0, 1) - 6*SingularityFunction(x, 10, 1) \
+    - 120*SingularityFunction(x, 30, 0) - 2*SingularityFunction(x, 30, 1)
+    assert p == q
+
+    # Test for slope distribution function
+    p = b1.slope()
+    q = -4*SingularityFunction(x, 0, 2) + 3*SingularityFunction(x, 10, 2) \
+    + 120*SingularityFunction(x, 30, 1) + SingularityFunction(x, 30, 2) \
+    + Rational(4000, 3)
+    assert p == q/(E*I)
+
+    # Test for deflection distribution function
+    p = b1.deflection()
+    q = x*Rational(4000, 3) - 4*SingularityFunction(x, 0, 3)/3 \
+    + SingularityFunction(x, 10, 3) + 60*SingularityFunction(x, 30, 2) \
+    + SingularityFunction(x, 30, 3)/3 - 12000
+    assert p == q/(E*I)
+
+    # Test using symbols
+    l = Symbol('l')
+    w0 = Symbol('w0')
+    w2 = Symbol('w2')
+    a1 = Symbol('a1')
+    c = Symbol('c')
+    c1 = Symbol('c1')
+    d = Symbol('d')
+    e = Symbol('e')
+    f = Symbol('f')
+
+    b2 = Beam(l, E, I)
+
+    b2.apply_load(w0, a1, 1)
+    b2.apply_load(w2, c1, -1)
+
+    b2.bc_deflection = [(c, d)]
+    b2.bc_slope = [(e, f)]
+
+    # Test for load distribution function.
+    p = b2.load
+    q = w0*SingularityFunction(x, a1, 1) + w2*SingularityFunction(x, c1, -1)
+    assert p == q
+
+    # Test for shear force distribution function
+    p = b2.shear_force()
+    q = -w0*SingularityFunction(x, a1, 2)/2 \
+    - w2*SingularityFunction(x, c1, 0)
+    assert p == q
+
+    # Test for shear stress distribution function
+    p = b2.shear_stress()
+    q = (-w0*SingularityFunction(x, a1, 2)/2 \
+    - w2*SingularityFunction(x, c1, 0))/A
+    assert p == q
+
+    # Test for bending moment distribution function
+    p = b2.bending_moment()
+    q = -w0*SingularityFunction(x, a1, 3)/6 - w2*SingularityFunction(x, c1, 1)
+    assert p == q
+
+    # Test for slope distribution function
+    p = b2.slope()
+    q = (w0*SingularityFunction(x, a1, 4)/24 + w2*SingularityFunction(x, c1, 2)/2)/(E*I) + (E*I*f - w0*SingularityFunction(e, a1, 4)/24 - w2*SingularityFunction(e, c1, 2)/2)/(E*I)
+    assert expand(p) == expand(q)
+
+    # Test for deflection distribution function
+    p = b2.deflection()
+    q = x*(E*I*f - w0*SingularityFunction(e, a1, 4)/24 \
+    - w2*SingularityFunction(e, c1, 2)/2)/(E*I) \
+    + (w0*SingularityFunction(x, a1, 5)/120 \
+    + w2*SingularityFunction(x, c1, 3)/6)/(E*I) \
+    + (E*I*(-c*f + d) + c*w0*SingularityFunction(e, a1, 4)/24 \
+    + c*w2*SingularityFunction(e, c1, 2)/2 \
+    - w0*SingularityFunction(c, a1, 5)/120 \
+    - w2*SingularityFunction(c, c1, 3)/6)/(E*I)
+    assert simplify(p - q) == 0
+
+    b3 = Beam(9, E, I, 2)
+    b3.apply_load(value=-2, start=2, order=2, end=3)
+    b3.bc_slope.append((0, 2))
+    C3 = symbols('C3')
+    C4 = symbols('C4')
+
+    p = b3.load
+    q = -2*SingularityFunction(x, 2, 2) + 2*SingularityFunction(x, 3, 0) \
+    + 4*SingularityFunction(x, 3, 1) + 2*SingularityFunction(x, 3, 2)
+    assert p == q
+
+    p = b3.shear_force()
+    q = 2*SingularityFunction(x, 2, 3)/3 - 2*SingularityFunction(x, 3, 1) \
+    - 2*SingularityFunction(x, 3, 2) - 2*SingularityFunction(x, 3, 3)/3
+    assert p == q
+
+    p = b3.shear_stress()
+    q = SingularityFunction(x, 2, 3)/3 - 1*SingularityFunction(x, 3, 1) \
+    - 1*SingularityFunction(x, 3, 2) - 1*SingularityFunction(x, 3, 3)/3
+    assert p == q
+
+    p = b3.slope()
+    q = 2 - (SingularityFunction(x, 2, 5)/30 - SingularityFunction(x, 3, 3)/3 \
+    - SingularityFunction(x, 3, 4)/6 - SingularityFunction(x, 3, 5)/30)/(E*I)
+    assert p == q
+
+    p = b3.deflection()
+    q = 2*x - (SingularityFunction(x, 2, 6)/180 \
+    - SingularityFunction(x, 3, 4)/12 - SingularityFunction(x, 3, 5)/30 \
+    - SingularityFunction(x, 3, 6)/180)/(E*I)
+    assert p == q + C4
+
+    b4 = Beam(4, E, I, 3)
+    b4.apply_load(-3, 0, 0, end=3)
+
+    p = b4.load
+    q = -3*SingularityFunction(x, 0, 0) + 3*SingularityFunction(x, 3, 0)
+    assert p == q
+
+    p = b4.shear_force()
+    q = 3*SingularityFunction(x, 0, 1) \
+    - 3*SingularityFunction(x, 3, 1)
+    assert p == q
+
+    p = b4.shear_stress()
+    q = SingularityFunction(x, 0, 1) - SingularityFunction(x, 3, 1)
+    assert p == q
+
+    p = b4.slope()
+    q = -3*SingularityFunction(x, 0, 3)/6 + 3*SingularityFunction(x, 3, 3)/6
+    assert p == q/(E*I) + C3
+
+    p = b4.deflection()
+    q = -3*SingularityFunction(x, 0, 4)/24 + 3*SingularityFunction(x, 3, 4)/24
+    assert p == q/(E*I) + C3*x + C4
+
+    # can't use end with point loads
+    raises(ValueError, lambda: b4.apply_load(-3, 0, -1, end=3))
+    with raises(TypeError):
+        b4.variable = 1
+
+
+def test_insufficient_bconditions():
+    # Test cases when required number of boundary conditions
+    # are not provided to solve the integration constants.
+    L = symbols('L', positive=True)
+    E, I, P, a3, a4 = symbols('E I P a3 a4')
+
+    b = Beam(L, E, I, base_char='a')
+    b.apply_load(R2, L, -1)
+    b.apply_load(R1, 0, -1)
+    b.apply_load(-P, L/2, -1)
+    b.solve_for_reaction_loads(R1, R2)
+
+    p = b.slope()
+    q = P*SingularityFunction(x, 0, 2)/4 - P*SingularityFunction(x, L/2, 2)/2 + P*SingularityFunction(x, L, 2)/4
+    assert p == q/(E*I) + a3
+
+    p = b.deflection()
+    q = P*SingularityFunction(x, 0, 3)/12 - P*SingularityFunction(x, L/2, 3)/6 + P*SingularityFunction(x, L, 3)/12
+    assert p == q/(E*I) + a3*x + a4
+
+    b.bc_deflection = [(0, 0)]
+    p = b.deflection()
+    q = a3*x + P*SingularityFunction(x, 0, 3)/12 - P*SingularityFunction(x, L/2, 3)/6 + P*SingularityFunction(x, L, 3)/12
+    assert p == q/(E*I)
+
+    b.bc_deflection = [(0, 0), (L, 0)]
+    p = b.deflection()
+    q = -L**2*P*x/16 + P*SingularityFunction(x, 0, 3)/12 - P*SingularityFunction(x, L/2, 3)/6 + P*SingularityFunction(x, L, 3)/12
+    assert p == q/(E*I)
+
+
+def test_statically_indeterminate():
+    E = Symbol('E')
+    I = Symbol('I')
+    M1, M2 = symbols('M1, M2')
+    F = Symbol('F')
+    l = Symbol('l', positive=True)
+
+    b5 = Beam(l, E, I)
+    b5.bc_deflection = [(0, 0),(l, 0)]
+    b5.bc_slope = [(0, 0),(l, 0)]
+
+    b5.apply_load(R1, 0, -1)
+    b5.apply_load(M1, 0, -2)
+    b5.apply_load(R2, l, -1)
+    b5.apply_load(M2, l, -2)
+    b5.apply_load(-F, l/2, -1)
+
+    b5.solve_for_reaction_loads(R1, R2, M1, M2)
+    p = b5.reaction_loads
+    q = {R1: F/2, R2: F/2, M1: -F*l/8, M2: F*l/8}
+    assert p == q
+
+
+def test_beam_units():
+    E = Symbol('E')
+    I = Symbol('I')
+    R1, R2 = symbols('R1, R2')
+
+    kN = kilo*newton
+    gN = giga*newton
+
+    b = Beam(8*meter, 200*gN/meter**2, 400*1000000*(milli*meter)**4)
+    b.apply_load(5*kN, 2*meter, -1)
+    b.apply_load(R1, 0*meter, -1)
+    b.apply_load(R2, 8*meter, -1)
+    b.apply_load(10*kN/meter, 4*meter, 0, end=8*meter)
+    b.bc_deflection = [(0*meter, 0*meter), (8*meter, 0*meter)]
+    b.solve_for_reaction_loads(R1, R2)
+    assert b.reaction_loads == {R1: -13750*newton, R2: -31250*newton}
+
+    b = Beam(3*meter, E*newton/meter**2, I*meter**4)
+    b.apply_load(8*kN, 1*meter, -1)
+    b.apply_load(R1, 0*meter, -1)
+    b.apply_load(R2, 3*meter, -1)
+    b.apply_load(12*kN*meter, 2*meter, -2)
+    b.bc_deflection = [(0*meter, 0*meter), (3*meter, 0*meter)]
+    b.solve_for_reaction_loads(R1, R2)
+    assert b.reaction_loads == {R1: newton*Rational(-28000, 3), R2: newton*Rational(4000, 3)}
+    assert b.deflection().subs(x, 1*meter) == 62000*meter/(9*E*I)
+
+
+def test_variable_moment():
+    E = Symbol('E')
+    I = Symbol('I')
+
+    b = Beam(4, E, 2*(4 - x))
+    b.apply_load(20, 4, -1)
+    R, M = symbols('R, M')
+    b.apply_load(R, 0, -1)
+    b.apply_load(M, 0, -2)
+    b.bc_deflection = [(0, 0)]
+    b.bc_slope = [(0, 0)]
+    b.solve_for_reaction_loads(R, M)
+    assert b.slope().expand() == ((10*x*SingularityFunction(x, 0, 0)
+        - 10*(x - 4)*SingularityFunction(x, 4, 0))/E).expand()
+    assert b.deflection().expand() == ((5*x**2*SingularityFunction(x, 0, 0)
+        - 10*Piecewise((0, Abs(x)/4 < 1), (16*meijerg(((3, 1), ()), ((), (2, 0)), x/4), True))
+        + 40*SingularityFunction(x, 4, 1))/E).expand()
+
+    b = Beam(4, E - x, I)
+    b.apply_load(20, 4, -1)
+    R, M = symbols('R, M')
+    b.apply_load(R, 0, -1)
+    b.apply_load(M, 0, -2)
+    b.bc_deflection = [(0, 0)]
+    b.bc_slope = [(0, 0)]
+    b.solve_for_reaction_loads(R, M)
+    assert b.slope().expand() == ((-80*(-log(-E) + log(-E + x))*SingularityFunction(x, 0, 0)
+        + 80*(-log(-E + 4) + log(-E + x))*SingularityFunction(x, 4, 0) + 20*(-E*log(-E)
+        + E*log(-E + x) + x)*SingularityFunction(x, 0, 0) - 20*(-E*log(-E + 4) + E*log(-E + x)
+        + x - 4)*SingularityFunction(x, 4, 0))/I).expand()
+
+
+def test_composite_beam():
+    E = Symbol('E')
+    I = Symbol('I')
+    b1 = Beam(2, E, 1.5*I)
+    b2 = Beam(2, E, I)
+    b = b1.join(b2, "fixed")
+    b.apply_load(-20, 0, -1)
+    b.apply_load(80, 0, -2)
+    b.apply_load(20, 4, -1)
+    b.bc_slope = [(0, 0)]
+    b.bc_deflection = [(0, 0)]
+    assert b.length == 4
+    assert b.second_moment == Piecewise((1.5*I, x <= 2), (I, x <= 4))
+    assert b.slope().subs(x, 4) == 120.0/(E*I)
+    assert b.slope().subs(x, 2) == 80.0/(E*I)
+    assert int(b.deflection().subs(x, 4).args[0]) == -302  # Coefficient of 1/(E*I)
+
+    l = symbols('l', positive=True)
+    R1, M1, R2, R3, P = symbols('R1 M1 R2 R3 P')
+    b1 = Beam(2*l, E, I)
+    b2 = Beam(2*l, E, I)
+    b = b1.join(b2,"hinge")
+    b.apply_load(M1, 0, -2)
+    b.apply_load(R1, 0, -1)
+    b.apply_load(R2, l, -1)
+    b.apply_load(R3, 4*l, -1)
+    b.apply_load(P, 3*l, -1)
+    b.bc_slope = [(0, 0)]
+    b.bc_deflection = [(0, 0), (l, 0), (4*l, 0)]
+    b.solve_for_reaction_loads(M1, R1, R2, R3)
+    assert b.reaction_loads == {R3: -P/2, R2: P*Rational(-5, 4), M1: -P*l/4, R1: P*Rational(3, 4)}
+    assert b.slope().subs(x, 3*l) == -7*P*l**2/(48*E*I)
+    assert b.deflection().subs(x, 2*l) == 7*P*l**3/(24*E*I)
+    assert b.deflection().subs(x, 3*l) == 5*P*l**3/(16*E*I)
+
+    # When beams having same second moment are joined.
+    b1 = Beam(2, 500, 10)
+    b2 = Beam(2, 500, 10)
+    b = b1.join(b2, "fixed")
+    b.apply_load(M1, 0, -2)
+    b.apply_load(R1, 0, -1)
+    b.apply_load(R2, 1, -1)
+    b.apply_load(R3, 4, -1)
+    b.apply_load(10, 3, -1)
+    b.bc_slope = [(0, 0)]
+    b.bc_deflection = [(0, 0), (1, 0), (4, 0)]
+    b.solve_for_reaction_loads(M1, R1, R2, R3)
+    assert b.slope() == -2*SingularityFunction(x, 0, 1)/5625 + SingularityFunction(x, 0, 2)/1875\
+                - 133*SingularityFunction(x, 1, 2)/135000 + SingularityFunction(x, 3, 2)/1000\
+                - 37*SingularityFunction(x, 4, 2)/67500
+    assert b.deflection() == -SingularityFunction(x, 0, 2)/5625 + SingularityFunction(x, 0, 3)/5625\
+                    - 133*SingularityFunction(x, 1, 3)/405000 + SingularityFunction(x, 3, 3)/3000\
+                    - 37*SingularityFunction(x, 4, 3)/202500
+
+
+def test_point_cflexure():
+    E = Symbol('E')
+    I = Symbol('I')
+    b = Beam(10, E, I)
+    b.apply_load(-4, 0, -1)
+    b.apply_load(-46, 6, -1)
+    b.apply_load(10, 2, -1)
+    b.apply_load(20, 4, -1)
+    b.apply_load(3, 6, 0)
+    assert b.point_cflexure() == [Rational(10, 3)]
+
+
+def test_remove_load():
+    E = Symbol('E')
+    I = Symbol('I')
+    b = Beam(4, E, I)
+
+    try:
+        b.remove_load(2, 1, -1)
+    # As no load is applied on beam, ValueError should be returned.
+    except ValueError:
+        assert True
+    else:
+        assert False
+
+    b.apply_load(-3, 0, -2)
+    b.apply_load(4, 2, -1)
+    b.apply_load(-2, 2, 2, end = 3)
+    b.remove_load(-2, 2, 2, end = 3)
+    assert b.load == -3*SingularityFunction(x, 0, -2) + 4*SingularityFunction(x, 2, -1)
+    assert b.applied_loads == [(-3, 0, -2, None), (4, 2, -1, None)]
+
+    try:
+        b.remove_load(1, 2, -1)
+    # As load of this magnitude was never applied at
+    # this position, method should return a ValueError.
+    except ValueError:
+        assert True
+    else:
+        assert False
+
+    b.remove_load(-3, 0, -2)
+    b.remove_load(4, 2, -1)
+    assert b.load == 0
+    assert b.applied_loads == []
+
+
+def test_apply_support():
+    E = Symbol('E')
+    I = Symbol('I')
+
+    b = Beam(4, E, I)
+    b.apply_support(0, "cantilever")
+    b.apply_load(20, 4, -1)
+    M_0, R_0 = symbols('M_0, R_0')
+    b.solve_for_reaction_loads(R_0, M_0)
+    assert simplify(b.slope()) == simplify((80*SingularityFunction(x, 0, 1) - 10*SingularityFunction(x, 0, 2)
+                + 10*SingularityFunction(x, 4, 2))/(E*I))
+    assert simplify(b.deflection()) == simplify((40*SingularityFunction(x, 0, 2) - 10*SingularityFunction(x, 0, 3)/3
+                + 10*SingularityFunction(x, 4, 3)/3)/(E*I))
+
+    b = Beam(30, E, I)
+    b.apply_support(10, "pin")
+    b.apply_support(30, "roller")
+    b.apply_load(-8, 0, -1)
+    b.apply_load(120, 30, -2)
+    R_10, R_30 = symbols('R_10, R_30')
+    b.solve_for_reaction_loads(R_10, R_30)
+    assert b.slope() == (-4*SingularityFunction(x, 0, 2) + 3*SingularityFunction(x, 10, 2)
+            + 120*SingularityFunction(x, 30, 1) + SingularityFunction(x, 30, 2) + Rational(4000, 3))/(E*I)
+    assert b.deflection() == (x*Rational(4000, 3) - 4*SingularityFunction(x, 0, 3)/3 + SingularityFunction(x, 10, 3)
+            + 60*SingularityFunction(x, 30, 2) + SingularityFunction(x, 30, 3)/3 - 12000)/(E*I)
+
+    P = Symbol('P', positive=True)
+    L = Symbol('L', positive=True)
+    b = Beam(L, E, I)
+    b.apply_support(0, type='fixed')
+    b.apply_support(L, type='fixed')
+    b.apply_load(-P, L/2, -1)
+    R_0, R_L, M_0, M_L = symbols('R_0, R_L, M_0, M_L')
+    b.solve_for_reaction_loads(R_0, R_L, M_0, M_L)
+    assert b.reaction_loads == {R_0: P/2, R_L: P/2, M_0: -L*P/8, M_L: L*P/8}
+
+
+def test_max_shear_force():
+    E = Symbol('E')
+    I = Symbol('I')
+
+    b = Beam(3, E, I)
+    R, M = symbols('R, M')
+    b.apply_load(R, 0, -1)
+    b.apply_load(M, 0, -2)
+    b.apply_load(2, 3, -1)
+    b.apply_load(4, 2, -1)
+    b.apply_load(2, 2, 0, end=3)
+    b.solve_for_reaction_loads(R, M)
+    assert b.max_shear_force() == (Interval(0, 2), 8)
+
+    l = symbols('l', positive=True)
+    P = Symbol('P')
+    b = Beam(l, E, I)
+    R1, R2 = symbols('R1, R2')
+    b.apply_load(R1, 0, -1)
+    b.apply_load(R2, l, -1)
+    b.apply_load(P, 0, 0, end=l)
+    b.solve_for_reaction_loads(R1, R2)
+    assert b.max_shear_force() == (0, l*Abs(P)/2)
+
+
+def test_max_bmoment():
+    E = Symbol('E')
+    I = Symbol('I')
+    l, P = symbols('l, P', positive=True)
+
+    b = Beam(l, E, I)
+    R1, R2 = symbols('R1, R2')
+    b.apply_load(R1, 0, -1)
+    b.apply_load(R2, l, -1)
+    b.apply_load(P, l/2, -1)
+    b.solve_for_reaction_loads(R1, R2)
+    b.reaction_loads
+    assert b.max_bmoment() == (l/2, P*l/4)
+
+    b = Beam(l, E, I)
+    R1, R2 = symbols('R1, R2')
+    b.apply_load(R1, 0, -1)
+    b.apply_load(R2, l, -1)
+    b.apply_load(P, 0, 0, end=l)
+    b.solve_for_reaction_loads(R1, R2)
+    assert b.max_bmoment() == (l/2, P*l**2/8)
+
+
+def test_max_deflection():
+    E, I, l, F = symbols('E, I, l, F', positive=True)
+    b = Beam(l, E, I)
+    b.bc_deflection = [(0, 0),(l, 0)]
+    b.bc_slope = [(0, 0),(l, 0)]
+    b.apply_load(F/2, 0, -1)
+    b.apply_load(-F*l/8, 0, -2)
+    b.apply_load(F/2, l, -1)
+    b.apply_load(F*l/8, l, -2)
+    b.apply_load(-F, l/2, -1)
+    assert b.max_deflection() == (l/2, F*l**3/(192*E*I))
+
+
+def test_Beam3D():
+    l, E, G, I, A = symbols('l, E, G, I, A')
+    R1, R2, R3, R4 = symbols('R1, R2, R3, R4')
+
+    b = Beam3D(l, E, G, I, A)
+    m, q = symbols('m, q')
+    b.apply_load(q, 0, 0, dir="y")
+    b.apply_moment_load(m, 0, 0, dir="z")
+    b.bc_slope = [(0, [0, 0, 0]), (l, [0, 0, 0])]
+    b.bc_deflection = [(0, [0, 0, 0]), (l, [0, 0, 0])]
+    b.solve_slope_deflection()
+
+    assert b.polar_moment() == 2*I
+    assert b.shear_force() == [0, -q*x, 0]
+    assert b.shear_stress() == [0, -q*x/A, 0]
+    assert b.axial_stress() == 0
+    assert b.bending_moment() == [0, 0, -m*x + q*x**2/2]
+    expected_deflection = (x*(A*G*q*x**3/4 + A*G*x**2*(-l*(A*G*l*(l*q - 2*m) +
+        12*E*I*q)/(A*G*l**2 + 12*E*I)/2 - m) + 3*E*I*l*(A*G*l*(l*q - 2*m) +
+        12*E*I*q)/(A*G*l**2 + 12*E*I) + x*(-A*G*l**2*q/2 +
+        3*A*G*l**2*(A*G*l*(l*q - 2*m) + 12*E*I*q)/(A*G*l**2 + 12*E*I)/4 +
+        A*G*l*m*Rational(3, 2) - 3*E*I*q))/(6*A*E*G*I))
+    dx, dy, dz = b.deflection()
+    assert dx == dz == 0
+    assert simplify(dy - expected_deflection) == 0
+
+    b2 = Beam3D(30, E, G, I, A, x)
+    b2.apply_load(50, start=0, order=0, dir="y")
+    b2.bc_deflection = [(0, [0, 0, 0]), (30, [0, 0, 0])]
+    b2.apply_load(R1, start=0, order=-1, dir="y")
+    b2.apply_load(R2, start=30, order=-1, dir="y")
+    b2.solve_for_reaction_loads(R1, R2)
+    assert b2.reaction_loads == {R1: -750, R2: -750}
+
+    b2.solve_slope_deflection()
+    assert b2.slope() == [0, 0, 25*x**3/(3*E*I) - 375*x**2/(E*I) + 3750*x/(E*I)]
+    expected_deflection = 25*x**4/(12*E*I) - 125*x**3/(E*I) + 1875*x**2/(E*I) - \
+        25*x**2/(A*G) + 750*x/(A*G)
+    dx, dy, dz = b2.deflection()
+    assert dx == dz == 0
+    assert dy == expected_deflection
+
+    # Test for solve_for_reaction_loads
+    b3 = Beam3D(30, E, G, I, A, x)
+    b3.apply_load(8, start=0, order=0, dir="y")
+    b3.apply_load(9*x, start=0, order=0, dir="z")
+    b3.apply_load(R1, start=0, order=-1, dir="y")
+    b3.apply_load(R2, start=30, order=-1, dir="y")
+    b3.apply_load(R3, start=0, order=-1, dir="z")
+    b3.apply_load(R4, start=30, order=-1, dir="z")
+    b3.solve_for_reaction_loads(R1, R2, R3, R4)
+    assert b3.reaction_loads == {R1: -120, R2: -120, R3: -1350, R4: -2700}
+
+
+def test_polar_moment_Beam3D():
+    l, E, G, A, I1, I2 = symbols('l, E, G, A, I1, I2')
+    I = [I1, I2]
+
+    b = Beam3D(l, E, G, I, A)
+    assert b.polar_moment() == I1 + I2
+
+
+def test_parabolic_loads():
+
+    E, I, L = symbols('E, I, L', positive=True, real=True)
+    R, M, P = symbols('R, M, P', real=True)
+
+    # cantilever beam fixed at x=0 and parabolic distributed loading across
+    # length of beam
+    beam = Beam(L, E, I)
+
+    beam.bc_deflection.append((0, 0))
+    beam.bc_slope.append((0, 0))
+    beam.apply_load(R, 0, -1)
+    beam.apply_load(M, 0, -2)
+
+    # parabolic load
+    beam.apply_load(1, 0, 2)
+
+    beam.solve_for_reaction_loads(R, M)
+
+    assert beam.reaction_loads[R] == -L**3/3
+
+    # cantilever beam fixed at x=0 and parabolic distributed loading across
+    # first half of beam
+    beam = Beam(2*L, E, I)
+
+    beam.bc_deflection.append((0, 0))
+    beam.bc_slope.append((0, 0))
+    beam.apply_load(R, 0, -1)
+    beam.apply_load(M, 0, -2)
+
+    # parabolic load from x=0 to x=L
+    beam.apply_load(1, 0, 2, end=L)
+
+    beam.solve_for_reaction_loads(R, M)
+
+    # result should be the same as the prior example
+    assert beam.reaction_loads[R] == -L**3/3
+
+    # check constant load
+    beam = Beam(2*L, E, I)
+    beam.apply_load(P, 0, 0, end=L)
+    loading = beam.load.xreplace({L: 10, E: 20, I: 30, P: 40})
+    assert loading.xreplace({x: 5}) == 40
+    assert loading.xreplace({x: 15}) == 0
+
+    # check ramp load
+    beam = Beam(2*L, E, I)
+    beam.apply_load(P, 0, 1, end=L)
+    assert beam.load == (P*SingularityFunction(x, 0, 1) -
+                         P*SingularityFunction(x, L, 1) -
+                         P*L*SingularityFunction(x, L, 0))
+
+    # check higher order load: x**8 load from x=0 to x=L
+    beam = Beam(2*L, E, I)
+    beam.apply_load(P, 0, 8, end=L)
+    loading = beam.load.xreplace({L: 10, E: 20, I: 30, P: 40})
+    assert loading.xreplace({x: 5}) == 40*5**8
+    assert loading.xreplace({x: 15}) == 0
+
+
+def test_cross_section():
+    I = Symbol('I')
+    l = Symbol('l')
+    E = Symbol('E')
+    C3, C4 = symbols('C3, C4')
+    a, c, g, h, r, n = symbols('a, c, g, h, r, n')
+
+    # test for second_moment and cross_section setter
+    b0 = Beam(l, E, I)
+    assert b0.second_moment == I
+    assert b0.cross_section == None
+    b0.cross_section = Circle((0, 0), 5)
+    assert b0.second_moment == pi*Rational(625, 4)
+    assert b0.cross_section == Circle((0, 0), 5)
+    b0.second_moment = 2*n - 6
+    assert b0.second_moment == 2*n-6
+    assert b0.cross_section == None
+    with raises(ValueError):
+        b0.second_moment = Circle((0, 0), 5)
+
+    # beam with a circular cross-section
+    b1 = Beam(50, E, Circle((0, 0), r))
+    assert b1.cross_section == Circle((0, 0), r)
+    assert b1.second_moment == pi*r*Abs(r)**3/4
+
+    b1.apply_load(-10, 0, -1)
+    b1.apply_load(R1, 5, -1)
+    b1.apply_load(R2, 50, -1)
+    b1.apply_load(90, 45, -2)
+    b1.solve_for_reaction_loads(R1, R2)
+    assert b1.load == (-10*SingularityFunction(x, 0, -1) + 82*SingularityFunction(x, 5, -1)/S(9)
+                         + 90*SingularityFunction(x, 45, -2) + 8*SingularityFunction(x, 50, -1)/9)
+    assert b1.bending_moment() == (10*SingularityFunction(x, 0, 1) - 82*SingularityFunction(x, 5, 1)/9
+                                     - 90*SingularityFunction(x, 45, 0) - 8*SingularityFunction(x, 50, 1)/9)
+    q = (-5*SingularityFunction(x, 0, 2) + 41*SingularityFunction(x, 5, 2)/S(9)
+           + 90*SingularityFunction(x, 45, 1) + 4*SingularityFunction(x, 50, 2)/S(9))/(pi*E*r*Abs(r)**3)
+    assert b1.slope() == C3 + 4*q
+    q = (-5*SingularityFunction(x, 0, 3)/3 + 41*SingularityFunction(x, 5, 3)/27 + 45*SingularityFunction(x, 45, 2)
+           + 4*SingularityFunction(x, 50, 3)/27)/(pi*E*r*Abs(r)**3)
+    assert b1.deflection() == C3*x + C4 + 4*q
+
+    # beam with a recatangular cross-section
+    b2 = Beam(20, E, Polygon((0, 0), (a, 0), (a, c), (0, c)))
+    assert b2.cross_section == Polygon((0, 0), (a, 0), (a, c), (0, c))
+    assert b2.second_moment == a*c**3/12
+    # beam with a triangular cross-section
+    b3 = Beam(15, E, Triangle((0, 0), (g, 0), (g/2, h)))
+    assert b3.cross_section == Triangle(Point2D(0, 0), Point2D(g, 0), Point2D(g/2, h))
+    assert b3.second_moment == g*h**3/36
+
+    # composite beam
+    b = b2.join(b3, "fixed")
+    b.apply_load(-30, 0, -1)
+    b.apply_load(65, 0, -2)
+    b.apply_load(40, 0, -1)
+    b.bc_slope = [(0, 0)]
+    b.bc_deflection = [(0, 0)]
+
+    assert b.second_moment == Piecewise((a*c**3/12, x <= 20), (g*h**3/36, x <= 35))
+    assert b.cross_section == None
+    assert b.length == 35
+    assert b.slope().subs(x, 7) == 8400/(E*a*c**3)
+    assert b.slope().subs(x, 25) == 52200/(E*g*h**3) + 39600/(E*a*c**3)
+    assert b.deflection().subs(x, 30) == -537000/(E*g*h**3) - 712000/(E*a*c**3)
+
+def test_max_shear_force_Beam3D():
+    x = symbols('x')
+    b = Beam3D(20, 40, 21, 100, 25)
+    b.apply_load(15, start=0, order=0, dir="z")
+    b.apply_load(12*x, start=0, order=0, dir="y")
+    b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])]
+    assert b.max_shear_force() == [(0, 0), (20, 2400), (20, 300)]
+
+def test_max_bending_moment_Beam3D():
+    x = symbols('x')
+    b = Beam3D(20, 40, 21, 100, 25)
+    b.apply_load(15, start=0, order=0, dir="z")
+    b.apply_load(12*x, start=0, order=0, dir="y")
+    b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])]
+    assert b.max_bmoment() == [(0, 0), (20, 3000), (20, 16000)]
+
+def test_max_deflection_Beam3D():
+    x = symbols('x')
+    b = Beam3D(20, 40, 21, 100, 25)
+    b.apply_load(15, start=0, order=0, dir="z")
+    b.apply_load(12*x, start=0, order=0, dir="y")
+    b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])]
+    b.solve_slope_deflection()
+    c = sympify("495/14")
+    p = sympify("-10 + 10*sqrt(10793)/43")
+    q = sympify("(10 - 10*sqrt(10793)/43)**3/160 - 20/7 + (10 - 10*sqrt(10793)/43)**4/6400 + 20*sqrt(10793)/301 + 27*(10 - 10*sqrt(10793)/43)**2/560")
+    assert b.max_deflection() == [(0, 0), (10, c), (p, q)]
+
+def test_torsion_Beam3D():
+    x = symbols('x')
+    b = Beam3D(20, 40, 21, 100, 25)
+    b.apply_moment_load(15, 5, -2, dir='x')
+    b.apply_moment_load(25, 10, -2, dir='x')
+    b.apply_moment_load(-5, 20, -2, dir='x')
+    b.solve_for_torsion()
+    assert b.angular_deflection().subs(x, 3) == sympify("1/40")
+    assert b.angular_deflection().subs(x, 9) == sympify("17/280")
+    assert b.angular_deflection().subs(x, 12) == sympify("53/840")
+    assert b.angular_deflection().subs(x, 17) == sympify("2/35")
+    assert b.angular_deflection().subs(x, 20) == sympify("3/56")

venv/lib/python3.10/site-packages/sympy/physics/continuum_mechanics/tests/test_truss.py

@@ -0,0 +1,108 @@
+from sympy.core.symbol import Symbol, symbols
+from sympy.physics.continuum_mechanics.truss import Truss
+from sympy import sqrt
+
+
+def test_truss():
+    A = Symbol('A')
+    B = Symbol('B')
+    C = Symbol('C')
+    AB, BC, AC = symbols('AB, BC, AC')
+    P = Symbol('P')
+
+    t = Truss()
+    assert t.nodes == []
+    assert t.node_labels == []
+    assert t.node_positions == []
+    assert t.members == {}
+    assert t.loads == {}
+    assert t.supports == {}
+    assert t.reaction_loads == {}
+    assert t.internal_forces == {}
+
+    # testing the add_node method
+    t.add_node(A, 0, 0)
+    t.add_node(B, 2, 2)
+    t.add_node(C, 3, 0)
+    assert t.nodes == [(A, 0, 0), (B, 2, 2), (C, 3, 0)]
+    assert t.node_labels == [A, B, C]
+    assert t.node_positions == [(0, 0), (2, 2), (3, 0)]
+    assert t.loads == {}
+    assert t.supports == {}
+    assert t.reaction_loads == {}
+
+    # testing the remove_node method
+    t.remove_node(C)
+    assert t.nodes == [(A, 0, 0), (B, 2, 2)]
+    assert t.node_labels == [A, B]
+    assert t.node_positions == [(0, 0), (2, 2)]
+    assert t.loads == {}
+    assert t.supports == {}
+
+    t.add_node(C, 3, 0)
+
+    # testing the add_member method
+    t.add_member(AB, A, B)
+    t.add_member(BC, B, C)
+    t.add_member(AC, A, C)
+    assert t.members == {AB: [A, B], BC: [B, C], AC: [A, C]}
+    assert t.internal_forces == {AB: 0, BC: 0, AC: 0}
+
+    # testing the remove_member method
+    t.remove_member(BC)
+    assert t.members == {AB: [A, B], AC: [A, C]}
+    assert t.internal_forces == {AB: 0, AC: 0}
+
+    t.add_member(BC, B, C)
+
+    D, CD = symbols('D, CD')
+
+    # testing the change_label methods
+    t.change_node_label(B, D)
+    assert t.nodes == [(A, 0, 0), (D, 2, 2), (C, 3, 0)]
+    assert t.node_labels == [A, D, C]
+    assert t.loads == {}
+    assert t.supports == {}
+    assert t.members == {AB: [A, D], BC: [D, C], AC: [A, C]}
+
+    t.change_member_label(BC, CD)
+    assert t.members == {AB: [A, D], CD: [D, C], AC: [A, C]}
+    assert t.internal_forces == {AB: 0, CD: 0, AC: 0}
+
+
+    # testing the apply_load method
+    t.apply_load(A, P, 90)
+    t.apply_load(A, P/4, 90)
+    t.apply_load(A, 2*P,45)
+    t.apply_load(D, P/2, 90)
+    assert t.loads == {A: [[P, 90], [P/4, 90], [2*P, 45]], D: [[P/2, 90]]}
+    assert t.loads[A] == [[P, 90], [P/4, 90], [2*P, 45]]
+
+    # testing the remove_load method
+    t.remove_load(A, P/4, 90)
+    assert t.loads == {A: [[P, 90], [2*P, 45]], D: [[P/2, 90]]}
+    assert t.loads[A] == [[P, 90], [2*P, 45]]
+
+    # testing the apply_support method
+    t.apply_support(A, "pinned")
+    t.apply_support(D, "roller")
+    assert t.supports == {A: 'pinned', D: 'roller'}
+    assert t.reaction_loads == {}
+    assert t.loads == {A: [[P, 90], [2*P, 45], [Symbol('R_A_x'), 0], [Symbol('R_A_y'), 90]],  D: [[P/2, 90], [Symbol('R_D_y'), 90]]}
+
+    # testing the remove_support method
+    t.remove_support(A)
+    assert t.supports == {D: 'roller'}
+    assert t.reaction_loads == {}
+    assert t.loads == {A: [[P, 90], [2*P, 45]], D: [[P/2, 90], [Symbol('R_D_y'), 90]]}
+
+    t.apply_support(A, "pinned")
+
+    # testing the solve method
+    t.solve()
+    assert t.reaction_loads['R_A_x'] == -sqrt(2)*P
+    assert t.reaction_loads['R_A_y'] == -sqrt(2)*P - P
+    assert t.reaction_loads['R_D_y'] == -P/2
+    assert t.internal_forces[AB]/P == 0
+    assert t.internal_forces[CD] == 0
+    assert t.internal_forces[AC] == 0

venv/lib/python3.10/site-packages/sympy/physics/continuum_mechanics/truss.py

@@ -0,0 +1,735 @@
+"""
+This module can be used to solve problems related
+to 2D Trusses.
+"""
+
+from cmath import inf
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy import Matrix, pi
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.matrices.dense import zeros
+from sympy import sin, cos
+
+
+
+class Truss:
+    """
+    A Truss is an assembly of members such as beams,
+    connected by nodes, that create a rigid structure.
+    In engineering, a truss is a structure that
+    consists of two-force members only.
+
+    Trusses are extremely important in engineering applications
+    and can be seen in numerous real-world applications like bridges.
+
+    Examples
+    ========
+
+    There is a Truss consisting of four nodes and five
+    members connecting the nodes. A force P acts
+    downward on the node D and there also exist pinned
+    and roller joints on the nodes A and B respectively.
+
+    .. image:: truss_example.png
+
+    >>> from sympy.physics.continuum_mechanics.truss import Truss
+    >>> t = Truss()
+    >>> t.add_node("node_1", 0, 0)
+    >>> t.add_node("node_2", 6, 0)
+    >>> t.add_node("node_3", 2, 2)
+    >>> t.add_node("node_4", 2, 0)
+    >>> t.add_member("member_1", "node_1", "node_4")
+    >>> t.add_member("member_2", "node_2", "node_4")
+    >>> t.add_member("member_3", "node_1", "node_3")
+    >>> t.add_member("member_4", "node_2", "node_3")
+    >>> t.add_member("member_5", "node_3", "node_4")
+    >>> t.apply_load("node_4", magnitude=10, direction=270)
+    >>> t.apply_support("node_1", type="fixed")
+    >>> t.apply_support("node_2", type="roller")
+    """
+
+    def __init__(self):
+        """
+        Initializes the class
+        """
+        self._nodes = []
+        self._members = {}
+        self._loads = {}
+        self._supports = {}
+        self._node_labels = []
+        self._node_positions = []
+        self._node_position_x = []
+        self._node_position_y = []
+        self._nodes_occupied = {}
+        self._reaction_loads = {}
+        self._internal_forces = {}
+        self._node_coordinates = {}
+
+    @property
+    def nodes(self):
+        """
+        Returns the nodes of the truss along with their positions.
+        """
+        return self._nodes
+
+    @property
+    def node_labels(self):
+        """
+        Returns the node labels of the truss.
+        """
+        return self._node_labels
+
+    @property
+    def node_positions(self):
+        """
+        Returns the positions of the nodes of the truss.
+        """
+        return self._node_positions
+
+    @property
+    def members(self):
+        """
+        Returns the members of the truss along with the start and end points.
+        """
+        return self._members
+
+    @property
+    def member_labels(self):
+        """
+        Returns the members of the truss along with the start and end points.
+        """
+        return self._member_labels
+
+    @property
+    def supports(self):
+        """
+        Returns the nodes with provided supports along with the kind of support provided i.e.
+        pinned or roller.
+        """
+        return self._supports
+
+    @property
+    def loads(self):
+        """
+        Returns the loads acting on the truss.
+        """
+        return self._loads
+
+    @property
+    def reaction_loads(self):
+        """
+        Returns the reaction forces for all supports which are all initialized to 0.
+        """
+        return self._reaction_loads
+
+    @property
+    def internal_forces(self):
+        """
+        Returns the internal forces for all members which are all initialized to 0.
+        """
+        return self._internal_forces
+
+    def add_node(self, label, x, y):
+        """
+        This method adds a node to the truss along with its name/label and its location.
+
+        Parameters
+        ==========
+        label:  String or a Symbol
+            The label for a node. It is the only way to identify a particular node.
+
+        x: Sympifyable
+            The x-coordinate of the position of the node.
+
+        y: Sympifyable
+            The y-coordinate of the position of the node.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.nodes
+        [('A', 0, 0)]
+        >>> t.add_node('B', 3, 0)
+        >>> t.nodes
+        [('A', 0, 0), ('B', 3, 0)]
+        """
+        x = sympify(x)
+        y = sympify(y)
+
+        if label in self._node_labels:
+            raise ValueError("Node needs to have a unique label")
+
+        elif x in self._node_position_x and y in self._node_position_y and self._node_position_x.index(x)==self._node_position_y.index(y):
+            raise ValueError("A node already exists at the given position")
+
+        else :
+            self._nodes.append((label, x, y))
+            self._node_labels.append(label)
+            self._node_positions.append((x, y))
+            self._node_position_x.append(x)
+            self._node_position_y.append(y)
+            self._node_coordinates[label] = [x, y]
+
+    def remove_node(self, label):
+        """
+        This method removes a node from the truss.
+
+        Parameters
+        ==========
+        label:  String or Symbol
+            The label of the node to be removed.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.nodes
+        [('A', 0, 0)]
+        >>> t.add_node('B', 3, 0)
+        >>> t.nodes
+        [('A', 0, 0), ('B', 3, 0)]
+        >>> t.remove_node('A')
+        >>> t.nodes
+        [('B', 3, 0)]
+        """
+        for i in range(len(self.nodes)):
+            if self._node_labels[i] == label:
+                x = self._node_position_x[i]
+                y = self._node_position_y[i]
+
+        if label not in self._node_labels:
+            raise ValueError("No such node exists in the truss")
+
+        else:
+            members_duplicate = self._members.copy()
+            for member in members_duplicate:
+                if label == self._members[member][0] or label == self._members[member][1]:
+                    raise ValueError("The node given has members already attached to it")
+            self._nodes.remove((label, x, y))
+            self._node_labels.remove(label)
+            self._node_positions.remove((x, y))
+            self._node_position_x.remove(x)
+            self._node_position_y.remove(y)
+            if label in list(self._loads):
+                self._loads.pop(label)
+            if label in list(self._supports):
+                self._supports.pop(label)
+            self._node_coordinates.pop(label)
+
+    def add_member(self, label, start, end):
+        """
+        This method adds a member between any two nodes in the given truss.
+
+        Parameters
+        ==========
+        label: String or Symbol
+            The label for a member. It is the only way to identify a particular member.
+
+        start: String or Symbol
+            The label of the starting point/node of the member.
+
+        end: String or Symbol
+            The label of the ending point/node of the member.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.add_node('B', 3, 0)
+        >>> t.add_node('C', 2, 2)
+        >>> t.add_member('AB', 'A', 'B')
+        >>> t.members
+        {'AB': ['A', 'B']}
+        """
+
+        if start not in self._node_labels or end not in self._node_labels or start==end:
+            raise ValueError("The start and end points of the member must be unique nodes")
+
+        elif label in list(self._members):
+            raise ValueError("A member with the same label already exists for the truss")
+
+        elif self._nodes_occupied.get((start, end)):
+            raise ValueError("A member already exists between the two nodes")
+
+        else:
+            self._members[label] = [start, end]
+            self._nodes_occupied[start, end] = True
+            self._nodes_occupied[end, start] = True
+            self._internal_forces[label] = 0
+
+    def remove_member(self, label):
+        """
+        This method removes a member from the given truss.
+
+        Parameters
+        ==========
+        label: String or Symbol
+            The label for the member to be removed.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.add_node('B', 3, 0)
+        >>> t.add_node('C', 2, 2)
+        >>> t.add_member('AB', 'A', 'B')
+        >>> t.add_member('AC', 'A', 'C')
+        >>> t.add_member('BC', 'B', 'C')
+        >>> t.members
+        {'AB': ['A', 'B'], 'AC': ['A', 'C'], 'BC': ['B', 'C']}
+        >>> t.remove_member('AC')
+        >>> t.members
+        {'AB': ['A', 'B'], 'BC': ['B', 'C']}
+        """
+        if label not in list(self._members):
+            raise ValueError("No such member exists in the Truss")
+
+        else:
+            self._nodes_occupied.pop((self._members[label][0], self._members[label][1]))
+            self._nodes_occupied.pop((self._members[label][1], self._members[label][0]))
+            self._members.pop(label)
+            self._internal_forces.pop(label)
+
+    def change_node_label(self, label, new_label):
+        """
+        This method changes the label of a node.
+
+        Parameters
+        ==========
+        label: String or Symbol
+            The label of the node for which the label has
+            to be changed.
+
+        new_label: String or Symbol
+            The new label of the node.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.add_node('B', 3, 0)
+        >>> t.nodes
+        [('A', 0, 0), ('B', 3, 0)]
+        >>> t.change_node_label('A', 'C')
+        >>> t.nodes
+        [('C', 0, 0), ('B', 3, 0)]
+        """
+        if label not in self._node_labels:
+            raise ValueError("No such node exists for the Truss")
+        elif new_label in self._node_labels:
+            raise ValueError("A node with the given label already exists")
+        else:
+            for node in self._nodes:
+                if node[0] == label:
+                    self._nodes[self._nodes.index((label, node[1], node[2]))] = (new_label, node[1], node[2])
+                    self._node_labels[self._node_labels.index(node[0])] = new_label
+                    self._node_coordinates[new_label] = self._node_coordinates[label]
+                    self._node_coordinates.pop(label)
+                    if node[0] in list(self._supports):
+                        self._supports[new_label] = self._supports[node[0]]
+                        self._supports.pop(node[0])
+                    if new_label in list(self._supports):
+                        if self._supports[new_label] == 'pinned':
+                            if 'R_'+str(label)+'_x' in list(self._reaction_loads) and 'R_'+str(label)+'_y' in list(self._reaction_loads):
+                                self._reaction_loads['R_'+str(new_label)+'_x'] = self._reaction_loads['R_'+str(label)+'_x']
+                                self._reaction_loads['R_'+str(new_label)+'_y'] = self._reaction_loads['R_'+str(label)+'_y']
+                                self._reaction_loads.pop('R_'+str(label)+'_x')
+                                self._reaction_loads.pop('R_'+str(label)+'_y')
+                            self._loads[new_label] = self._loads[label]
+                            for load in self._loads[new_label]:
+                                if load[1] == 90:
+                                    load[0] -= Symbol('R_'+str(label)+'_y')
+                                    if load[0] == 0:
+                                        self._loads[label].remove(load)
+                                    break
+                            for load in self._loads[new_label]:
+                                if load[1] == 0:
+                                    load[0] -= Symbol('R_'+str(label)+'_x')
+                                    if load[0] == 0:
+                                        self._loads[label].remove(load)
+                                    break
+                            self.apply_load(new_label, Symbol('R_'+str(new_label)+'_x'), 0)
+                            self.apply_load(new_label, Symbol('R_'+str(new_label)+'_y'), 90)
+                            self._loads.pop(label)
+                        elif self._supports[new_label] == 'roller':
+                            self._loads[new_label] = self._loads[label]
+                            for load in self._loads[label]:
+                                if load[1] == 90:
+                                    load[0] -= Symbol('R_'+str(label)+'_y')
+                                    if load[0] == 0:
+                                        self._loads[label].remove(load)
+                                    break
+                            self.apply_load(new_label, Symbol('R_'+str(new_label)+'_y'), 90)
+                            self._loads.pop(label)
+                    else:
+                        if label in list(self._loads):
+                            self._loads[new_label] = self._loads[label]
+                            self._loads.pop(label)
+                    for member in list(self._members):
+                        if self._members[member][0] == node[0]:
+                            self._members[member][0] = new_label
+                            self._nodes_occupied[(new_label, self._members[member][1])] = True
+                            self._nodes_occupied[(self._members[member][1], new_label)] = True
+                            self._nodes_occupied.pop((label, self._members[member][1]))
+                            self._nodes_occupied.pop((self._members[member][1], label))
+                        elif self._members[member][1] == node[0]:
+                            self._members[member][1] = new_label
+                            self._nodes_occupied[(self._members[member][0], new_label)] = True
+                            self._nodes_occupied[(new_label, self._members[member][0])] = True
+                            self._nodes_occupied.pop((self._members[member][0], label))
+                            self._nodes_occupied.pop((label, self._members[member][0]))
+
+    def change_member_label(self, label, new_label):
+        """
+        This method changes the label of a member.
+
+        Parameters
+        ==========
+        label: String or Symbol
+            The label of the member for which the label has
+            to be changed.
+
+        new_label: String or Symbol
+            The new label of the member.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.add_node('B', 3, 0)
+        >>> t.nodes
+        [('A', 0, 0), ('B', 3, 0)]
+        >>> t.change_node_label('A', 'C')
+        >>> t.nodes
+        [('C', 0, 0), ('B', 3, 0)]
+        >>> t.add_member('BC', 'B', 'C')
+        >>> t.members
+        {'BC': ['B', 'C']}
+        >>> t.change_member_label('BC', 'BC_new')
+        >>> t.members
+        {'BC_new': ['B', 'C']}
+        """
+        if label not in list(self._members):
+            raise ValueError("No such member exists for the Truss")
+
+        else:
+            members_duplicate = list(self._members).copy()
+            for member in members_duplicate:
+                if member == label:
+                    self._members[new_label] = [self._members[member][0], self._members[member][1]]
+                    self._members.pop(label)
+                    self._internal_forces[new_label] = self._internal_forces[label]
+                    self._internal_forces.pop(label)
+
+    def apply_load(self, location, magnitude, direction):
+        """
+        This method applies an external load at a particular node
+
+        Parameters
+        ==========
+        location: String or Symbol
+            Label of the Node at which load is applied.
+
+        magnitude: Sympifyable
+            Magnitude of the load applied. It must always be positive and any changes in
+            the direction of the load are not reflected here.
+
+        direction: Sympifyable
+            The angle, in degrees, that the load vector makes with the horizontal
+            in the counter-clockwise direction. It takes the values 0 to 360,
+            inclusive.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> from sympy import symbols
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.add_node('B', 3, 0)
+        >>> P = symbols('P')
+        >>> t.apply_load('A', P, 90)
+        >>> t.apply_load('A', P/2, 45)
+        >>> t.apply_load('A', P/4, 90)
+        >>> t.loads
+        {'A': [[P, 90], [P/2, 45], [P/4, 90]]}
+        """
+        magnitude = sympify(magnitude)
+        direction = sympify(direction)
+
+        if location not in self.node_labels:
+            raise ValueError("Load must be applied at a known node")
+
+        else:
+            if location in list(self._loads):
+                self._loads[location].append([magnitude, direction])
+            else:
+                self._loads[location] = [[magnitude, direction]]
+
+    def remove_load(self, location, magnitude, direction):
+        """
+        This method removes an already
+        present external load at a particular node
+
+        Parameters
+        ==========
+        location: String or Symbol
+            Label of the Node at which load is applied and is to be removed.
+
+        magnitude: Sympifyable
+            Magnitude of the load applied.
+
+        direction: Sympifyable
+            The angle, in degrees, that the load vector makes with the horizontal
+            in the counter-clockwise direction. It takes the values 0 to 360,
+            inclusive.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> from sympy import symbols
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.add_node('B', 3, 0)
+        >>> P = symbols('P')
+        >>> t.apply_load('A', P, 90)
+        >>> t.apply_load('A', P/2, 45)
+        >>> t.apply_load('A', P/4, 90)
+        >>> t.loads
+        {'A': [[P, 90], [P/2, 45], [P/4, 90]]}
+        >>> t.remove_load('A', P/4, 90)
+        >>> t.loads
+        {'A': [[P, 90], [P/2, 45]]}
+        """
+        magnitude = sympify(magnitude)
+        direction = sympify(direction)
+
+        if location not in self.node_labels:
+            raise ValueError("Load must be removed from a known node")
+
+        else:
+            if [magnitude, direction] not in self._loads[location]:
+                raise ValueError("No load of this magnitude and direction has been applied at this node")
+            else:
+                self._loads[location].remove([magnitude, direction])
+        if self._loads[location] == []:
+            self._loads.pop(location)
+
+    def apply_support(self, location, type):
+        """
+        This method adds a pinned or roller support at a particular node
+
+        Parameters
+        ==========
+
+        location: String or Symbol
+            Label of the Node at which support is added.
+
+        type: String
+            Type of the support being provided at the node.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.add_node('B', 3, 0)
+        >>> t.apply_support('A', 'pinned')
+        >>> t.supports
+        {'A': 'pinned'}
+        """
+        if location not in self._node_labels:
+            raise ValueError("Support must be added on a known node")
+
+        else:
+            if location not in list(self._supports):
+                if type == 'pinned':
+                    self.apply_load(location, Symbol('R_'+str(location)+'_x'), 0)
+                    self.apply_load(location, Symbol('R_'+str(location)+'_y'), 90)
+                elif type == 'roller':
+                    self.apply_load(location, Symbol('R_'+str(location)+'_y'), 90)
+            elif self._supports[location] == 'pinned':
+                if type == 'roller':
+                    self.remove_load(location, Symbol('R_'+str(location)+'_x'), 0)
+            elif self._supports[location] == 'roller':
+                if type == 'pinned':
+                    self.apply_load(location, Symbol('R_'+str(location)+'_x'), 0)
+            self._supports[location] = type
+
+    def remove_support(self, location):
+        """
+        This method removes support from a particular node
+
+        Parameters
+        ==========
+
+        location: String or Symbol
+            Label of the Node at which support is to be removed.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> t = Truss()
+        >>> t.add_node('A', 0, 0)
+        >>> t.add_node('B', 3, 0)
+        >>> t.apply_support('A', 'pinned')
+        >>> t.supports
+        {'A': 'pinned'}
+        >>> t.remove_support('A')
+        >>> t.supports
+        {}
+        """
+        if location not in self._node_labels:
+            raise ValueError("No such node exists in the Truss")
+
+        elif location not in list(self._supports):
+            raise ValueError("No support has been added to the given node")
+
+        else:
+            if self._supports[location] == 'pinned':
+                self.remove_load(location, Symbol('R_'+str(location)+'_x'), 0)
+                self.remove_load(location, Symbol('R_'+str(location)+'_y'), 90)
+            elif self._supports[location] == 'roller':
+                self.remove_load(location, Symbol('R_'+str(location)+'_y'), 90)
+            self._supports.pop(location)
+
+    def solve(self):
+        """
+        This method solves for all reaction forces of all supports and all internal forces
+        of all the members in the truss, provided the Truss is solvable.
+
+        A Truss is solvable if the following condition is met,
+
+        2n >= r + m
+
+        Where n is the number of nodes, r is the number of reaction forces, where each pinned
+        support has 2 reaction forces and each roller has 1, and m is the number of members.
+
+        The given condition is derived from the fact that a system of equations is solvable
+        only when the number of variables is lesser than or equal to the number of equations.
+        Equilibrium Equations in x and y directions give two equations per node giving 2n number
+        equations. However, the truss needs to be stable as well and may be unstable if 2n > r + m.
+        The number of variables is simply the sum of the number of reaction forces and member
+        forces.
+
+        .. note::
+           The sign convention for the internal forces present in a member revolves around whether each
+           force is compressive or tensile. While forming equations for each node, internal force due
+           to a member on the node is assumed to be away from the node i.e. each force is assumed to
+           be compressive by default. Hence, a positive value for an internal force implies the
+           presence of compressive force in the member and a negative value implies a tensile force.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.continuum_mechanics.truss import Truss
+        >>> t = Truss()
+        >>> t.add_node("node_1", 0, 0)
+        >>> t.add_node("node_2", 6, 0)
+        >>> t.add_node("node_3", 2, 2)
+        >>> t.add_node("node_4", 2, 0)
+        >>> t.add_member("member_1", "node_1", "node_4")
+        >>> t.add_member("member_2", "node_2", "node_4")
+        >>> t.add_member("member_3", "node_1", "node_3")
+        >>> t.add_member("member_4", "node_2", "node_3")
+        >>> t.add_member("member_5", "node_3", "node_4")
+        >>> t.apply_load("node_4", magnitude=10, direction=270)
+        >>> t.apply_support("node_1", type="pinned")
+        >>> t.apply_support("node_2", type="roller")
+        >>> t.solve()
+        >>> t.reaction_loads
+        {'R_node_1_x': 0, 'R_node_1_y': 20/3, 'R_node_2_y': 10/3}
+        >>> t.internal_forces
+        {'member_1': 20/3, 'member_2': 20/3, 'member_3': -20*sqrt(2)/3, 'member_4': -10*sqrt(5)/3, 'member_5': 10}
+        """
+        count_reaction_loads = 0
+        for node in self._nodes:
+            if node[0] in list(self._supports):
+                if self._supports[node[0]]=='pinned':
+                    count_reaction_loads += 2
+                elif self._supports[node[0]]=='roller':
+                    count_reaction_loads += 1
+        if 2*len(self._nodes) != len(self._members) + count_reaction_loads:
+            raise ValueError("The given truss cannot be solved")
+        coefficients_matrix = [[0 for i in range(2*len(self._nodes))] for j in range(2*len(self._nodes))]
+        load_matrix = zeros(2*len(self.nodes), 1)
+        load_matrix_row = 0
+        for node in self._nodes:
+            if node[0] in list(self._loads):
+                for load in self._loads[node[0]]:
+                    if load[0]!=Symbol('R_'+str(node[0])+'_x') and load[0]!=Symbol('R_'+str(node[0])+'_y'):
+                        load_matrix[load_matrix_row] -= load[0]*cos(pi*load[1]/180)
+                        load_matrix[load_matrix_row + 1] -= load[0]*sin(pi*load[1]/180)
+            load_matrix_row += 2
+        cols = 0
+        row = 0
+        for node in self._nodes:
+            if node[0] in list(self._supports):
+                if self._supports[node[0]]=='pinned':
+                    coefficients_matrix[row][cols] += 1
+                    coefficients_matrix[row+1][cols+1] += 1
+                    cols += 2
+                elif self._supports[node[0]]=='roller':
+                    coefficients_matrix[row+1][cols] += 1
+                    cols += 1
+            row += 2
+        for member in list(self._members):
+            start = self._members[member][0]
+            end = self._members[member][1]
+            length = sqrt((self._node_coordinates[start][0]-self._node_coordinates[end][0])**2 + (self._node_coordinates[start][1]-self._node_coordinates[end][1])**2)
+            start_index = self._node_labels.index(start)
+            end_index = self._node_labels.index(end)
+            horizontal_component_start = (self._node_coordinates[end][0]-self._node_coordinates[start][0])/length
+            vertical_component_start = (self._node_coordinates[end][1]-self._node_coordinates[start][1])/length
+            horizontal_component_end = (self._node_coordinates[start][0]-self._node_coordinates[end][0])/length
+            vertical_component_end = (self._node_coordinates[start][1]-self._node_coordinates[end][1])/length
+            coefficients_matrix[start_index*2][cols] += horizontal_component_start
+            coefficients_matrix[start_index*2+1][cols] += vertical_component_start
+            coefficients_matrix[end_index*2][cols] += horizontal_component_end
+            coefficients_matrix[end_index*2+1][cols] += vertical_component_end
+            cols += 1
+        forces_matrix = (Matrix(coefficients_matrix)**-1)*load_matrix
+        self._reaction_loads = {}
+        i = 0
+        min_load = inf
+        for node in self._nodes:
+            if node[0] in list(self._loads):
+                for load in self._loads[node[0]]:
+                    if type(load[0]) not in [Symbol, Mul, Add]:
+                        min_load = min(min_load, load[0])
+        for j in range(len(forces_matrix)):
+            if type(forces_matrix[j]) not in [Symbol, Mul, Add]:
+                if abs(forces_matrix[j]/min_load) <1E-10:
+                    forces_matrix[j] = 0
+        for node in self._nodes:
+            if node[0] in list(self._supports):
+                if self._supports[node[0]]=='pinned':
+                    self._reaction_loads['R_'+str(node[0])+'_x'] = forces_matrix[i]
+                    self._reaction_loads['R_'+str(node[0])+'_y'] = forces_matrix[i+1]
+                    i += 2
+                elif self._supports[node[0]]=='roller':
+                    self._reaction_loads['R_'+str(node[0])+'_y'] = forces_matrix[i]
+                    i += 1
+        for member in list(self._members):
+            self._internal_forces[member] = forces_matrix[i]
+            i += 1
+        return

venv/lib/python3.10/site-packages/sympy/physics/control/__init__.py

@@ -0,0 +1,15 @@
+from .lti import (TransferFunction, Series, MIMOSeries, Parallel, MIMOParallel,
+    Feedback, MIMOFeedback, TransferFunctionMatrix, bilinear, backward_diff)
+from .control_plots import (pole_zero_numerical_data, pole_zero_plot, step_response_numerical_data,
+    step_response_plot, impulse_response_numerical_data, impulse_response_plot, ramp_response_numerical_data,
+    ramp_response_plot, bode_magnitude_numerical_data, bode_phase_numerical_data, bode_magnitude_plot,
+    bode_phase_plot, bode_plot)
+
+__all__ = ['TransferFunction', 'Series', 'MIMOSeries', 'Parallel',
+    'MIMOParallel', 'Feedback', 'MIMOFeedback', 'TransferFunctionMatrix','bilinear',
+    'backward_diff', 'pole_zero_numerical_data',
+    'pole_zero_plot', 'step_response_numerical_data', 'step_response_plot',
+    'impulse_response_numerical_data', 'impulse_response_plot',
+    'ramp_response_numerical_data', 'ramp_response_plot',
+    'bode_magnitude_numerical_data', 'bode_phase_numerical_data',
+    'bode_magnitude_plot', 'bode_phase_plot', 'bode_plot']

venv/lib/python3.10/site-packages/sympy/physics/control/control_plots.py

@@ -0,0 +1,961 @@
+from sympy.core.numbers import I, pi
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.polys.partfrac import apart
+from sympy.core.symbol import Dummy
+from sympy.external import import_module
+from sympy.functions import arg, Abs
+from sympy.integrals.laplace import _fast_inverse_laplace
+from sympy.physics.control.lti import SISOLinearTimeInvariant
+from sympy.plotting.plot import LineOver1DRangeSeries
+from sympy.polys.polytools import Poly
+from sympy.printing.latex import latex
+
+__all__ = ['pole_zero_numerical_data', 'pole_zero_plot',
+    'step_response_numerical_data', 'step_response_plot',
+    'impulse_response_numerical_data', 'impulse_response_plot',
+    'ramp_response_numerical_data', 'ramp_response_plot',
+    'bode_magnitude_numerical_data', 'bode_phase_numerical_data',
+    'bode_magnitude_plot', 'bode_phase_plot', 'bode_plot']
+
+matplotlib = import_module(
+        'matplotlib', import_kwargs={'fromlist': ['pyplot']},
+        catch=(RuntimeError,))
+
+numpy = import_module('numpy')
+
+if matplotlib:
+    plt = matplotlib.pyplot
+
+if numpy:
+    np = numpy  # Matplotlib already has numpy as a compulsory dependency. No need to install it separately.
+
+
+def _check_system(system):
+    """Function to check whether the dynamical system passed for plots is
+    compatible or not."""
+    if not isinstance(system, SISOLinearTimeInvariant):
+        raise NotImplementedError("Only SISO LTI systems are currently supported.")
+    sys = system.to_expr()
+    len_free_symbols = len(sys.free_symbols)
+    if len_free_symbols > 1:
+        raise ValueError("Extra degree of freedom found. Make sure"
+            " that there are no free symbols in the dynamical system other"
+            " than the variable of Laplace transform.")
+    if sys.has(exp):
+        # Should test that exp is not part of a constant, in which case
+        # no exception is required, compare exp(s) with s*exp(1)
+        raise NotImplementedError("Time delay terms are not supported.")
+
+
+def pole_zero_numerical_data(system):
+    """
+    Returns the numerical data of poles and zeros of the system.
+    It is internally used by ``pole_zero_plot`` to get the data
+    for plotting poles and zeros. Users can use this data to further
+    analyse the dynamics of the system or plot using a different
+    backend/plotting-module.
+
+    Parameters
+    ==========
+
+    system : SISOLinearTimeInvariant
+        The system for which the pole-zero data is to be computed.
+
+    Returns
+    =======
+
+    tuple : (zeros, poles)
+        zeros = Zeros of the system. NumPy array of complex numbers.
+        poles = Poles of the system. NumPy array of complex numbers.
+
+    Raises
+    ======
+
+    NotImplementedError
+        When a SISO LTI system is not passed.
+
+        When time delay terms are present in the system.
+
+    ValueError
+        When more than one free symbol is present in the system.
+        The only variable in the transfer function should be
+        the variable of the Laplace transform.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import s
+    >>> from sympy.physics.control.lti import TransferFunction
+    >>> from sympy.physics.control.control_plots import pole_zero_numerical_data
+    >>> tf1 = TransferFunction(s**2 + 1, s**4 + 4*s**3 + 6*s**2 + 5*s + 2, s)
+    >>> pole_zero_numerical_data(tf1)   # doctest: +SKIP
+    ([-0.+1.j  0.-1.j], [-2. +0.j        -0.5+0.8660254j -0.5-0.8660254j -1. +0.j       ])
+
+    See Also
+    ========
+
+    pole_zero_plot
+
+    """
+    _check_system(system)
+    system = system.doit()  # Get the equivalent TransferFunction object.
+
+    num_poly = Poly(system.num, system.var).all_coeffs()
+    den_poly = Poly(system.den, system.var).all_coeffs()
+
+    num_poly = np.array(num_poly, dtype=np.complex128)
+    den_poly = np.array(den_poly, dtype=np.complex128)
+
+    zeros = np.roots(num_poly)
+    poles = np.roots(den_poly)
+
+    return zeros, poles
+
+
+def pole_zero_plot(system, pole_color='blue', pole_markersize=10,
+    zero_color='orange', zero_markersize=7, grid=True, show_axes=True,
+    show=True, **kwargs):
+    r"""
+    Returns the Pole-Zero plot (also known as PZ Plot or PZ Map) of a system.
+
+    A Pole-Zero plot is a graphical representation of a system's poles and
+    zeros. It is plotted on a complex plane, with circular markers representing
+    the system's zeros and 'x' shaped markers representing the system's poles.
+
+    Parameters
+    ==========
+
+    system : SISOLinearTimeInvariant type systems
+        The system for which the pole-zero plot is to be computed.
+    pole_color : str, tuple, optional
+        The color of the pole points on the plot. Default color
+        is blue. The color can be provided as a matplotlib color string,
+        or a 3-tuple of floats each in the 0-1 range.
+    pole_markersize : Number, optional
+        The size of the markers used to mark the poles in the plot.
+        Default pole markersize is 10.
+    zero_color : str, tuple, optional
+        The color of the zero points on the plot. Default color
+        is orange. The color can be provided as a matplotlib color string,
+        or a 3-tuple of floats each in the 0-1 range.
+    zero_markersize : Number, optional
+        The size of the markers used to mark the zeros in the plot.
+        Default zero markersize is 7.
+    grid : boolean, optional
+        If ``True``, the plot will have a grid. Defaults to True.
+    show_axes : boolean, optional
+        If ``True``, the coordinate axes will be shown. Defaults to False.
+    show : boolean, optional
+        If ``True``, the plot will be displayed otherwise
+        the equivalent matplotlib ``plot`` object will be returned.
+        Defaults to True.
+
+    Examples
+    ========
+
+    .. plot::
+        :context: close-figs
+        :format: doctest
+        :include-source: True
+
+        >>> from sympy.abc import s
+        >>> from sympy.physics.control.lti import TransferFunction
+        >>> from sympy.physics.control.control_plots import pole_zero_plot
+        >>> tf1 = TransferFunction(s**2 + 1, s**4 + 4*s**3 + 6*s**2 + 5*s + 2, s)
+        >>> pole_zero_plot(tf1)   # doctest: +SKIP
+
+    See Also
+    ========
+
+    pole_zero_numerical_data
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Pole%E2%80%93zero_plot
+
+    """
+    zeros, poles = pole_zero_numerical_data(system)
+
+    zero_real = np.real(zeros)
+    zero_imag = np.imag(zeros)
+
+    pole_real = np.real(poles)
+    pole_imag = np.imag(poles)
+
+    plt.plot(pole_real, pole_imag, 'x', mfc='none',
+        markersize=pole_markersize, color=pole_color)
+    plt.plot(zero_real, zero_imag, 'o', markersize=zero_markersize,
+        color=zero_color)
+    plt.xlabel('Real Axis')
+    plt.ylabel('Imaginary Axis')
+    plt.title(f'Poles and Zeros of ${latex(system)}$', pad=20)
+
+    if grid:
+        plt.grid()
+    if show_axes:
+        plt.axhline(0, color='black')
+        plt.axvline(0, color='black')
+    if show:
+        plt.show()
+        return
+
+    return plt
+
+
+def step_response_numerical_data(system, prec=8, lower_limit=0,
+    upper_limit=10, **kwargs):
+    """
+    Returns the numerical values of the points in the step response plot
+    of a SISO continuous-time system. By default, adaptive sampling
+    is used. If the user wants to instead get an uniformly
+    sampled response, then ``adaptive`` kwarg should be passed ``False``
+    and ``nb_of_points`` must be passed as additional kwargs.
+    Refer to the parameters of class :class:`sympy.plotting.plot.LineOver1DRangeSeries`
+    for more details.
+
+    Parameters
+    ==========
+
+    system : SISOLinearTimeInvariant
+        The system for which the unit step response data is to be computed.
+    prec : int, optional
+        The decimal point precision for the point coordinate values.
+        Defaults to 8.
+    lower_limit : Number, optional
+        The lower limit of the plot range. Defaults to 0.
+    upper_limit : Number, optional
+        The upper limit of the plot range. Defaults to 10.
+    kwargs :
+        Additional keyword arguments are passed to the underlying
+        :class:`sympy.plotting.plot.LineOver1DRangeSeries` class.
+
+    Returns
+    =======
+
+    tuple : (x, y)
+        x = Time-axis values of the points in the step response. NumPy array.
+        y = Amplitude-axis values of the points in the step response. NumPy array.
+
+    Raises
+    ======
+
+    NotImplementedError
+        When a SISO LTI system is not passed.
+
+        When time delay terms are present in the system.
+
+    ValueError
+        When more than one free symbol is present in the system.
+        The only variable in the transfer function should be
+        the variable of the Laplace transform.
+
+        When ``lower_limit`` parameter is less than 0.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import s
+    >>> from sympy.physics.control.lti import TransferFunction
+    >>> from sympy.physics.control.control_plots import step_response_numerical_data
+    >>> tf1 = TransferFunction(s, s**2 + 5*s + 8, s)
+    >>> step_response_numerical_data(tf1)   # doctest: +SKIP
+    ([0.0, 0.025413462339411542, 0.0484508722725343, ... , 9.670250533855183, 9.844291913708725, 10.0],
+    [0.0, 0.023844582399907256, 0.042894276802320226, ..., 6.828770759094287e-12, 6.456457160755703e-12])
+
+    See Also
+    ========
+
+    step_response_plot
+
+    """
+    if lower_limit < 0:
+        raise ValueError("Lower limit of time must be greater "
+            "than or equal to zero.")
+    _check_system(system)
+    _x = Dummy("x")
+    expr = system.to_expr()/(system.var)
+    expr = apart(expr, system.var, full=True)
+    _y = _fast_inverse_laplace(expr, system.var, _x).evalf(prec)
+    return LineOver1DRangeSeries(_y, (_x, lower_limit, upper_limit),
+        **kwargs).get_points()
+
+
+def step_response_plot(system, color='b', prec=8, lower_limit=0,
+    upper_limit=10, show_axes=False, grid=True, show=True, **kwargs):
+    r"""
+    Returns the unit step response of a continuous-time system. It is
+    the response of the system when the input signal is a step function.
+
+    Parameters
+    ==========
+
+    system : SISOLinearTimeInvariant type
+        The LTI SISO system for which the Step Response is to be computed.
+    color : str, tuple, optional
+        The color of the line. Default is Blue.
+    show : boolean, optional
+        If ``True``, the plot will be displayed otherwise
+        the equivalent matplotlib ``plot`` object will be returned.
+        Defaults to True.
+    lower_limit : Number, optional
+        The lower limit of the plot range. Defaults to 0.
+    upper_limit : Number, optional
+        The upper limit of the plot range. Defaults to 10.
+    prec : int, optional
+        The decimal point precision for the point coordinate values.
+        Defaults to 8.
+    show_axes : boolean, optional
+        If ``True``, the coordinate axes will be shown. Defaults to False.
+    grid : boolean, optional
+        If ``True``, the plot will have a grid. Defaults to True.
+
+    Examples
+    ========
+
+    .. plot::
+        :context: close-figs
+        :format: doctest
+        :include-source: True
+
+        >>> from sympy.abc import s
+        >>> from sympy.physics.control.lti import TransferFunction
+        >>> from sympy.physics.control.control_plots import step_response_plot
+        >>> tf1 = TransferFunction(8*s**2 + 18*s + 32, s**3 + 6*s**2 + 14*s + 24, s)
+        >>> step_response_plot(tf1)   # doctest: +SKIP
+
+    See Also
+    ========
+
+    impulse_response_plot, ramp_response_plot
+
+    References
+    ==========
+
+    .. [1] https://www.mathworks.com/help/control/ref/lti.step.html
+
+    """
+    x, y = step_response_numerical_data(system, prec=prec,
+        lower_limit=lower_limit, upper_limit=upper_limit, **kwargs)
+    plt.plot(x, y, color=color)
+    plt.xlabel('Time (s)')
+    plt.ylabel('Amplitude')
+    plt.title(f'Unit Step Response of ${latex(system)}$', pad=20)
+
+    if grid:
+        plt.grid()
+    if show_axes:
+        plt.axhline(0, color='black')
+        plt.axvline(0, color='black')
+    if show:
+        plt.show()
+        return
+
+    return plt
+
+
+def impulse_response_numerical_data(system, prec=8, lower_limit=0,
+    upper_limit=10, **kwargs):
+    """
+    Returns the numerical values of the points in the impulse response plot
+    of a SISO continuous-time system. By default, adaptive sampling
+    is used. If the user wants to instead get an uniformly
+    sampled response, then ``adaptive`` kwarg should be passed ``False``
+    and ``nb_of_points`` must be passed as additional kwargs.
+    Refer to the parameters of class :class:`sympy.plotting.plot.LineOver1DRangeSeries`
+    for more details.
+
+    Parameters
+    ==========
+
+    system : SISOLinearTimeInvariant
+        The system for which the impulse response data is to be computed.
+    prec : int, optional
+        The decimal point precision for the point coordinate values.
+        Defaults to 8.
+    lower_limit : Number, optional
+        The lower limit of the plot range. Defaults to 0.
+    upper_limit : Number, optional
+        The upper limit of the plot range. Defaults to 10.
+    kwargs :
+        Additional keyword arguments are passed to the underlying
+        :class:`sympy.plotting.plot.LineOver1DRangeSeries` class.
+
+    Returns
+    =======
+
+    tuple : (x, y)
+        x = Time-axis values of the points in the impulse response. NumPy array.
+        y = Amplitude-axis values of the points in the impulse response. NumPy array.
+
+    Raises
+    ======
+
+    NotImplementedError
+        When a SISO LTI system is not passed.
+
+        When time delay terms are present in the system.
+
+    ValueError
+        When more than one free symbol is present in the system.
+        The only variable in the transfer function should be
+        the variable of the Laplace transform.
+
+        When ``lower_limit`` parameter is less than 0.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import s
+    >>> from sympy.physics.control.lti import TransferFunction
+    >>> from sympy.physics.control.control_plots import impulse_response_numerical_data
+    >>> tf1 = TransferFunction(s, s**2 + 5*s + 8, s)
+    >>> impulse_response_numerical_data(tf1)   # doctest: +SKIP
+    ([0.0, 0.06616480200395854,... , 9.854500743565858, 10.0],
+    [0.9999999799999999, 0.7042848373025861,...,7.170748906965121e-13, -5.1901263495547205e-12])
+
+    See Also
+    ========
+
+    impulse_response_plot
+
+    """
+    if lower_limit < 0:
+        raise ValueError("Lower limit of time must be greater "
+            "than or equal to zero.")
+    _check_system(system)
+    _x = Dummy("x")
+    expr = system.to_expr()
+    expr = apart(expr, system.var, full=True)
+    _y = _fast_inverse_laplace(expr, system.var, _x).evalf(prec)
+    return LineOver1DRangeSeries(_y, (_x, lower_limit, upper_limit),
+        **kwargs).get_points()
+
+
+def impulse_response_plot(system, color='b', prec=8, lower_limit=0,
+    upper_limit=10, show_axes=False, grid=True, show=True, **kwargs):
+    r"""
+    Returns the unit impulse response (Input is the Dirac-Delta Function) of a
+    continuous-time system.
+
+    Parameters
+    ==========
+
+    system : SISOLinearTimeInvariant type
+        The LTI SISO system for which the Impulse Response is to be computed.
+    color : str, tuple, optional
+        The color of the line. Default is Blue.
+    show : boolean, optional
+        If ``True``, the plot will be displayed otherwise
+        the equivalent matplotlib ``plot`` object will be returned.
+        Defaults to True.
+    lower_limit : Number, optional
+        The lower limit of the plot range. Defaults to 0.
+    upper_limit : Number, optional
+        The upper limit of the plot range. Defaults to 10.
+    prec : int, optional
+        The decimal point precision for the point coordinate values.
+        Defaults to 8.
+    show_axes : boolean, optional
+        If ``True``, the coordinate axes will be shown. Defaults to False.
+    grid : boolean, optional
+        If ``True``, the plot will have a grid. Defaults to True.
+
+    Examples
+    ========
+
+    .. plot::
+        :context: close-figs
+        :format: doctest
+        :include-source: True
+
+        >>> from sympy.abc import s
+        >>> from sympy.physics.control.lti import TransferFunction
+        >>> from sympy.physics.control.control_plots import impulse_response_plot
+        >>> tf1 = TransferFunction(8*s**2 + 18*s + 32, s**3 + 6*s**2 + 14*s + 24, s)
+        >>> impulse_response_plot(tf1)   # doctest: +SKIP
+
+    See Also
+    ========
+
+    step_response_plot, ramp_response_plot
+
+    References
+    ==========
+
+    .. [1] https://www.mathworks.com/help/control/ref/lti.impulse.html
+
+    """
+    x, y = impulse_response_numerical_data(system, prec=prec,
+        lower_limit=lower_limit, upper_limit=upper_limit, **kwargs)
+    plt.plot(x, y, color=color)
+    plt.xlabel('Time (s)')
+    plt.ylabel('Amplitude')
+    plt.title(f'Impulse Response of ${latex(system)}$', pad=20)
+
+    if grid:
+        plt.grid()
+    if show_axes:
+        plt.axhline(0, color='black')
+        plt.axvline(0, color='black')
+    if show:
+        plt.show()
+        return
+
+    return plt
+
+
+def ramp_response_numerical_data(system, slope=1, prec=8,
+    lower_limit=0, upper_limit=10, **kwargs):
+    """
+    Returns the numerical values of the points in the ramp response plot
+    of a SISO continuous-time system. By default, adaptive sampling
+    is used. If the user wants to instead get an uniformly
+    sampled response, then ``adaptive`` kwarg should be passed ``False``
+    and ``nb_of_points`` must be passed as additional kwargs.
+    Refer to the parameters of class :class:`sympy.plotting.plot.LineOver1DRangeSeries`
+    for more details.
+
+    Parameters
+    ==========
+
+    system : SISOLinearTimeInvariant
+        The system for which the ramp response data is to be computed.
+    slope : Number, optional
+        The slope of the input ramp function. Defaults to 1.
+    prec : int, optional
+        The decimal point precision for the point coordinate values.
+        Defaults to 8.
+    lower_limit : Number, optional
+        The lower limit of the plot range. Defaults to 0.
+    upper_limit : Number, optional
+        The upper limit of the plot range. Defaults to 10.
+    kwargs :
+        Additional keyword arguments are passed to the underlying
+        :class:`sympy.plotting.plot.LineOver1DRangeSeries` class.
+
+    Returns
+    =======
+
+    tuple : (x, y)
+        x = Time-axis values of the points in the ramp response plot. NumPy array.
+        y = Amplitude-axis values of the points in the ramp response plot. NumPy array.
+
+    Raises
+    ======
+
+    NotImplementedError
+        When a SISO LTI system is not passed.
+
+        When time delay terms are present in the system.
+
+    ValueError
+        When more than one free symbol is present in the system.
+        The only variable in the transfer function should be
+        the variable of the Laplace transform.
+
+        When ``lower_limit`` parameter is less than 0.
+
+        When ``slope`` is negative.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import s
+    >>> from sympy.physics.control.lti import TransferFunction
+    >>> from sympy.physics.control.control_plots import ramp_response_numerical_data
+    >>> tf1 = TransferFunction(s, s**2 + 5*s + 8, s)
+    >>> ramp_response_numerical_data(tf1)   # doctest: +SKIP
+    (([0.0, 0.12166980856813935,..., 9.861246379582118, 10.0],
+    [1.4504508011325967e-09, 0.006046440489058766,..., 0.12499999999568202, 0.12499999999661349]))
+
+    See Also
+    ========
+
+    ramp_response_plot
+
+    """
+    if slope < 0:
+        raise ValueError("Slope must be greater than or equal"
+            " to zero.")
+    if lower_limit < 0:
+        raise ValueError("Lower limit of time must be greater "
+            "than or equal to zero.")
+    _check_system(system)
+    _x = Dummy("x")
+    expr = (slope*system.to_expr())/((system.var)**2)
+    expr = apart(expr, system.var, full=True)
+    _y = _fast_inverse_laplace(expr, system.var, _x).evalf(prec)
+    return LineOver1DRangeSeries(_y, (_x, lower_limit, upper_limit),
+        **kwargs).get_points()
+
+
+def ramp_response_plot(system, slope=1, color='b', prec=8, lower_limit=0,
+    upper_limit=10, show_axes=False, grid=True, show=True, **kwargs):
+    r"""
+    Returns the ramp response of a continuous-time system.
+
+    Ramp function is defined as the straight line
+    passing through origin ($f(x) = mx$). The slope of
+    the ramp function can be varied by the user and
+    the default value is 1.
+
+    Parameters
+    ==========
+
+    system : SISOLinearTimeInvariant type
+        The LTI SISO system for which the Ramp Response is to be computed.
+    slope : Number, optional
+        The slope of the input ramp function. Defaults to 1.
+    color : str, tuple, optional
+        The color of the line. Default is Blue.
+    show : boolean, optional
+        If ``True``, the plot will be displayed otherwise
+        the equivalent matplotlib ``plot`` object will be returned.
+        Defaults to True.
+    lower_limit : Number, optional
+        The lower limit of the plot range. Defaults to 0.
+    upper_limit : Number, optional
+        The upper limit of the plot range. Defaults to 10.
+    prec : int, optional
+        The decimal point precision for the point coordinate values.
+        Defaults to 8.
+    show_axes : boolean, optional
+        If ``True``, the coordinate axes will be shown. Defaults to False.
+    grid : boolean, optional
+        If ``True``, the plot will have a grid. Defaults to True.
+
+    Examples
+    ========
+
+    .. plot::
+        :context: close-figs
+        :format: doctest
+        :include-source: True
+
+        >>> from sympy.abc import s
+        >>> from sympy.physics.control.lti import TransferFunction
+        >>> from sympy.physics.control.control_plots import ramp_response_plot
+        >>> tf1 = TransferFunction(s, (s+4)*(s+8), s)
+        >>> ramp_response_plot(tf1, upper_limit=2)   # doctest: +SKIP
+
+    See Also
+    ========
+
+    step_response_plot, ramp_response_plot
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Ramp_function
+
+    """
+    x, y = ramp_response_numerical_data(system, slope=slope, prec=prec,
+        lower_limit=lower_limit, upper_limit=upper_limit, **kwargs)
+    plt.plot(x, y, color=color)
+    plt.xlabel('Time (s)')
+    plt.ylabel('Amplitude')
+    plt.title(f'Ramp Response of ${latex(system)}$ [Slope = {slope}]', pad=20)
+
+    if grid:
+        plt.grid()
+    if show_axes:
+        plt.axhline(0, color='black')
+        plt.axvline(0, color='black')
+    if show:
+        plt.show()
+        return
+
+    return plt
+
+
+def bode_magnitude_numerical_data(system, initial_exp=-5, final_exp=5, freq_unit='rad/sec', **kwargs):
+    """
+    Returns the numerical data of the Bode magnitude plot of the system.
+    It is internally used by ``bode_magnitude_plot`` to get the data
+    for plotting Bode magnitude plot. Users can use this data to further
+    analyse the dynamics of the system or plot using a different
+    backend/plotting-module.
+
+    Parameters
+    ==========
+
+    system : SISOLinearTimeInvariant
+        The system for which the data is to be computed.
+    initial_exp : Number, optional
+        The initial exponent of 10 of the semilog plot. Defaults to -5.
+    final_exp : Number, optional
+        The final exponent of 10 of the semilog plot. Defaults to 5.
+    freq_unit : string, optional
+        User can choose between ``'rad/sec'`` (radians/second) and ``'Hz'`` (Hertz) as frequency units.
+
+    Returns
+    =======
+
+    tuple : (x, y)
+        x = x-axis values of the Bode magnitude plot.
+        y = y-axis values of the Bode magnitude plot.
+
+    Raises
+    ======
+
+    NotImplementedError
+        When a SISO LTI system is not passed.
+
+        When time delay terms are present in the system.
+
+    ValueError
+        When more than one free symbol is present in the system.
+        The only variable in the transfer function should be
+        the variable of the Laplace transform.
+
+        When incorrect frequency units are given as input.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import s
+    >>> from sympy.physics.control.lti import TransferFunction
+    >>> from sympy.physics.control.control_plots import bode_magnitude_numerical_data
+    >>> tf1 = TransferFunction(s**2 + 1, s**4 + 4*s**3 + 6*s**2 + 5*s + 2, s)
+    >>> bode_magnitude_numerical_data(tf1)   # doctest: +SKIP
+    ([1e-05, 1.5148378120533502e-05,..., 68437.36188804005, 100000.0],
+    [-6.020599914256786, -6.0205999155219505,..., -193.4117304087953, -200.00000000260573])
+
+    See Also
+    ========
+
+    bode_magnitude_plot, bode_phase_numerical_data
+
+    """
+    _check_system(system)
+    expr = system.to_expr()
+    freq_units = ('rad/sec', 'Hz')
+    if freq_unit not in freq_units:
+        raise ValueError('Only "rad/sec" and "Hz" are accepted frequency units.')
+
+    _w = Dummy("w", real=True)
+    if freq_unit == 'Hz':
+        repl = I*_w*2*pi
+    else:
+        repl = I*_w
+    w_expr = expr.subs({system.var: repl})
+
+    mag = 20*log(Abs(w_expr), 10)
+
+    x, y = LineOver1DRangeSeries(mag,
+        (_w, 10**initial_exp, 10**final_exp), xscale='log', **kwargs).get_points()
+
+    return x, y
+
+
+def bode_magnitude_plot(system, initial_exp=-5, final_exp=5,
+    color='b', show_axes=False, grid=True, show=True, freq_unit='rad/sec', **kwargs):
+    r"""
+    Returns the Bode magnitude plot of a continuous-time system.
+
+    See ``bode_plot`` for all the parameters.
+    """
+    x, y = bode_magnitude_numerical_data(system, initial_exp=initial_exp,
+        final_exp=final_exp, freq_unit=freq_unit)
+    plt.plot(x, y, color=color, **kwargs)
+    plt.xscale('log')
+
+
+    plt.xlabel('Frequency (%s) [Log Scale]' % freq_unit)
+    plt.ylabel('Magnitude (dB)')
+    plt.title(f'Bode Plot (Magnitude) of ${latex(system)}$', pad=20)
+
+    if grid:
+        plt.grid(True)
+    if show_axes:
+        plt.axhline(0, color='black')
+        plt.axvline(0, color='black')
+    if show:
+        plt.show()
+        return
+
+    return plt
+
+
+def bode_phase_numerical_data(system, initial_exp=-5, final_exp=5, freq_unit='rad/sec', phase_unit='rad', **kwargs):
+    """
+    Returns the numerical data of the Bode phase plot of the system.
+    It is internally used by ``bode_phase_plot`` to get the data
+    for plotting Bode phase plot. Users can use this data to further
+    analyse the dynamics of the system or plot using a different
+    backend/plotting-module.
+
+    Parameters
+    ==========
+
+    system : SISOLinearTimeInvariant
+        The system for which the Bode phase plot data is to be computed.
+    initial_exp : Number, optional
+        The initial exponent of 10 of the semilog plot. Defaults to -5.
+    final_exp : Number, optional
+        The final exponent of 10 of the semilog plot. Defaults to 5.
+    freq_unit : string, optional
+        User can choose between ``'rad/sec'`` (radians/second) and '``'Hz'`` (Hertz) as frequency units.
+    phase_unit : string, optional
+        User can choose between ``'rad'`` (radians) and ``'deg'`` (degree) as phase units.
+
+    Returns
+    =======
+
+    tuple : (x, y)
+        x = x-axis values of the Bode phase plot.
+        y = y-axis values of the Bode phase plot.
+
+    Raises
+    ======
+
+    NotImplementedError
+        When a SISO LTI system is not passed.
+
+        When time delay terms are present in the system.
+
+    ValueError
+        When more than one free symbol is present in the system.
+        The only variable in the transfer function should be
+        the variable of the Laplace transform.
+
+        When incorrect frequency or phase units are given as input.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import s
+    >>> from sympy.physics.control.lti import TransferFunction
+    >>> from sympy.physics.control.control_plots import bode_phase_numerical_data
+    >>> tf1 = TransferFunction(s**2 + 1, s**4 + 4*s**3 + 6*s**2 + 5*s + 2, s)
+    >>> bode_phase_numerical_data(tf1)   # doctest: +SKIP
+    ([1e-05, 1.4472354033813751e-05, 2.035581932165858e-05,..., 47577.3248186011, 67884.09326036123, 100000.0],
+    [-2.5000000000291665e-05, -3.6180885085e-05, -5.08895483066e-05,...,-3.1415085799262523, -3.14155265358979])
+
+    See Also
+    ========
+
+    bode_magnitude_plot, bode_phase_numerical_data
+
+    """
+    _check_system(system)
+    expr = system.to_expr()
+    freq_units = ('rad/sec', 'Hz')
+    phase_units = ('rad', 'deg')
+    if freq_unit not in freq_units:
+        raise ValueError('Only "rad/sec" and "Hz" are accepted frequency units.')
+    if phase_unit not in phase_units:
+        raise ValueError('Only "rad" and "deg" are accepted phase units.')
+
+    _w = Dummy("w", real=True)
+    if freq_unit == 'Hz':
+        repl = I*_w*2*pi
+    else:
+        repl = I*_w
+    w_expr = expr.subs({system.var: repl})
+
+    if phase_unit == 'deg':
+        phase = arg(w_expr)*180/pi
+    else:
+        phase = arg(w_expr)
+
+    x, y = LineOver1DRangeSeries(phase,
+        (_w, 10**initial_exp, 10**final_exp), xscale='log', **kwargs).get_points()
+
+    return x, y
+
+
+def bode_phase_plot(system, initial_exp=-5, final_exp=5,
+    color='b', show_axes=False, grid=True, show=True, freq_unit='rad/sec', phase_unit='rad', **kwargs):
+    r"""
+    Returns the Bode phase plot of a continuous-time system.
+
+    See ``bode_plot`` for all the parameters.
+    """
+    x, y = bode_phase_numerical_data(system, initial_exp=initial_exp,
+        final_exp=final_exp, freq_unit=freq_unit, phase_unit=phase_unit)
+    plt.plot(x, y, color=color, **kwargs)
+    plt.xscale('log')
+
+    plt.xlabel('Frequency (%s) [Log Scale]' % freq_unit)
+    plt.ylabel('Phase (%s)' % phase_unit)
+    plt.title(f'Bode Plot (Phase) of ${latex(system)}$', pad=20)
+
+    if grid:
+        plt.grid(True)
+    if show_axes:
+        plt.axhline(0, color='black')
+        plt.axvline(0, color='black')
+    if show:
+        plt.show()
+        return
+
+    return plt
+
+
+def bode_plot(system, initial_exp=-5, final_exp=5,
+    grid=True, show_axes=False, show=True, freq_unit='rad/sec', phase_unit='rad', **kwargs):
+    r"""
+    Returns the Bode phase and magnitude plots of a continuous-time system.
+
+    Parameters
+    ==========
+
+    system : SISOLinearTimeInvariant type
+        The LTI SISO system for which the Bode Plot is to be computed.
+    initial_exp : Number, optional
+        The initial exponent of 10 of the semilog plot. Defaults to -5.
+    final_exp : Number, optional
+        The final exponent of 10 of the semilog plot. Defaults to 5.
+    show : boolean, optional
+        If ``True``, the plot will be displayed otherwise
+        the equivalent matplotlib ``plot`` object will be returned.
+        Defaults to True.
+    prec : int, optional
+        The decimal point precision for the point coordinate values.
+        Defaults to 8.
+    grid : boolean, optional
+        If ``True``, the plot will have a grid. Defaults to True.
+    show_axes : boolean, optional
+        If ``True``, the coordinate axes will be shown. Defaults to False.
+    freq_unit : string, optional
+        User can choose between ``'rad/sec'`` (radians/second) and ``'Hz'`` (Hertz) as frequency units.
+    phase_unit : string, optional
+        User can choose between ``'rad'`` (radians) and ``'deg'`` (degree) as phase units.
+
+    Examples
+    ========
+
+    .. plot::
+        :context: close-figs
+        :format: doctest
+        :include-source: True
+
+        >>> from sympy.abc import s
+        >>> from sympy.physics.control.lti import TransferFunction
+        >>> from sympy.physics.control.control_plots import bode_plot
+        >>> tf1 = TransferFunction(1*s**2 + 0.1*s + 7.5, 1*s**4 + 0.12*s**3 + 9*s**2, s)
+        >>> bode_plot(tf1, initial_exp=0.2, final_exp=0.7)   # doctest: +SKIP
+
+    See Also
+    ========
+
+    bode_magnitude_plot, bode_phase_plot
+
+    """
+    plt.subplot(211)
+    mag = bode_magnitude_plot(system, initial_exp=initial_exp, final_exp=final_exp,
+        show=False, grid=grid, show_axes=show_axes,
+        freq_unit=freq_unit, **kwargs)
+    mag.title(f'Bode Plot of ${latex(system)}$', pad=20)
+    mag.xlabel(None)
+    plt.subplot(212)
+    bode_phase_plot(system, initial_exp=initial_exp, final_exp=final_exp,
+        show=False, grid=grid, show_axes=show_axes, freq_unit=freq_unit, phase_unit=phase_unit, **kwargs).title(None)
+
+    if show:
+        plt.show()
+        return
+
+    return plt

venv/lib/python3.10/site-packages/sympy/physics/control/tests/test_control_plots.py

@@ -0,0 +1,300 @@
+from math import isclose
+from sympy.core.numbers import I
+from sympy.core.symbol import Dummy
+from sympy.functions.elementary.complexes import (Abs, arg)
+from sympy.functions.elementary.exponential import log
+from sympy.abc import s, p, a
+from sympy.external import import_module
+from sympy.physics.control.control_plots import \
+    (pole_zero_numerical_data, pole_zero_plot, step_response_numerical_data,
+    step_response_plot, impulse_response_numerical_data,
+    impulse_response_plot, ramp_response_numerical_data,
+    ramp_response_plot, bode_magnitude_numerical_data,
+    bode_phase_numerical_data, bode_plot)
+from sympy.physics.control.lti import (TransferFunction,
+    Series, Parallel, TransferFunctionMatrix)
+from sympy.testing.pytest import raises, skip
+
+matplotlib = import_module(
+        'matplotlib', import_kwargs={'fromlist': ['pyplot']},
+        catch=(RuntimeError,))
+
+numpy = import_module('numpy')
+
+tf1 = TransferFunction(1, p**2 + 0.5*p + 2, p)
+tf2 = TransferFunction(p, 6*p**2 + 3*p + 1, p)
+tf3 = TransferFunction(p, p**3 - 1, p)
+tf4 = TransferFunction(10, p**3, p)
+tf5 = TransferFunction(5, s**2 + 2*s + 10, s)
+tf6 = TransferFunction(1, 1, s)
+tf7 = TransferFunction(4*s*3 + 9*s**2 + 0.1*s + 11, 8*s**6 + 9*s**4 + 11, s)
+tf8 = TransferFunction(5, s**2 + (2+I)*s + 10, s)
+
+ser1 = Series(tf4, TransferFunction(1, p - 5, p))
+ser2 = Series(tf3, TransferFunction(p, p + 2, p))
+
+par1 = Parallel(tf1, tf2)
+par2 = Parallel(tf1, tf2, tf3)
+
+
+def _to_tuple(a, b):
+    return tuple(a), tuple(b)
+
+def _trim_tuple(a, b):
+    a, b = _to_tuple(a, b)
+    return tuple(a[0: 2] + a[len(a)//2 : len(a)//2 + 1] + a[-2:]), \
+        tuple(b[0: 2] + b[len(b)//2 : len(b)//2 + 1] + b[-2:])
+
+def y_coordinate_equality(plot_data_func, evalf_func, system):
+    """Checks whether the y-coordinate value of the plotted
+    data point is equal to the value of the function at a
+    particular x."""
+    x, y = plot_data_func(system)
+    x, y = _trim_tuple(x, y)
+    y_exp = tuple(evalf_func(system, x_i) for x_i in x)
+    return all(Abs(y_exp_i - y_i) < 1e-8 for y_exp_i, y_i in zip(y_exp, y))
+
+
+def test_errors():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    # Invalid `system` check
+    tfm = TransferFunctionMatrix([[tf6, tf5], [tf5, tf6]])
+    expr = 1/(s**2 - 1)
+    raises(NotImplementedError, lambda: pole_zero_plot(tfm))
+    raises(NotImplementedError, lambda: pole_zero_numerical_data(expr))
+    raises(NotImplementedError, lambda: impulse_response_plot(expr))
+    raises(NotImplementedError, lambda: impulse_response_numerical_data(tfm))
+    raises(NotImplementedError, lambda: step_response_plot(tfm))
+    raises(NotImplementedError, lambda: step_response_numerical_data(expr))
+    raises(NotImplementedError, lambda: ramp_response_plot(expr))
+    raises(NotImplementedError, lambda: ramp_response_numerical_data(tfm))
+    raises(NotImplementedError, lambda: bode_plot(tfm))
+
+    # More than 1 variables
+    tf_a = TransferFunction(a, s + 1, s)
+    raises(ValueError, lambda: pole_zero_plot(tf_a))
+    raises(ValueError, lambda: pole_zero_numerical_data(tf_a))
+    raises(ValueError, lambda: impulse_response_plot(tf_a))
+    raises(ValueError, lambda: impulse_response_numerical_data(tf_a))
+    raises(ValueError, lambda: step_response_plot(tf_a))
+    raises(ValueError, lambda: step_response_numerical_data(tf_a))
+    raises(ValueError, lambda: ramp_response_plot(tf_a))
+    raises(ValueError, lambda: ramp_response_numerical_data(tf_a))
+    raises(ValueError, lambda: bode_plot(tf_a))
+
+    # lower_limit > 0 for response plots
+    raises(ValueError, lambda: impulse_response_plot(tf1, lower_limit=-1))
+    raises(ValueError, lambda: step_response_plot(tf1, lower_limit=-0.1))
+    raises(ValueError, lambda: ramp_response_plot(tf1, lower_limit=-4/3))
+
+    # slope in ramp_response_plot() is negative
+    raises(ValueError, lambda: ramp_response_plot(tf1, slope=-0.1))
+
+    # incorrect frequency or phase unit
+    raises(ValueError, lambda: bode_plot(tf1,freq_unit = 'hz'))
+    raises(ValueError, lambda: bode_plot(tf1,phase_unit = 'degree'))
+
+
+def test_pole_zero():
+    if not numpy:
+        skip("NumPy is required for this test")
+
+    def pz_tester(sys, expected_value):
+        z, p = pole_zero_numerical_data(sys)
+        z_check = numpy.allclose(z, expected_value[0])
+        p_check = numpy.allclose(p, expected_value[1])
+        return p_check and z_check
+
+    exp1 = [[], [-0.24999999999999994+1.3919410907075054j, -0.24999999999999994-1.3919410907075054j]]
+    exp2 = [[0.0], [-0.25+0.3227486121839514j, -0.25-0.3227486121839514j]]
+    exp3 = [[0.0], [-0.5000000000000004+0.8660254037844395j,
+        -0.5000000000000004-0.8660254037844395j, 0.9999999999999998+0j]]
+    exp4 = [[], [5.0, 0.0, 0.0, 0.0]]
+    exp5 = [[-5.645751311064592, -0.5000000000000008, -0.3542486889354093],
+        [-0.24999999999999986+1.3919410907075052j,
+        -0.24999999999999986-1.3919410907075052j, -0.2499999999999998+0.32274861218395134j,
+        -0.2499999999999998-0.32274861218395134j]]
+    exp6 = [[], [-1.1641600331447917-3.545808351896439j,
+          -0.8358399668552097+2.5458083518964383j]]
+
+    assert pz_tester(tf1, exp1)
+    assert pz_tester(tf2, exp2)
+    assert pz_tester(tf3, exp3)
+    assert pz_tester(ser1, exp4)
+    assert pz_tester(par1, exp5)
+    assert pz_tester(tf8, exp6)
+
+
+def test_bode():
+    if not numpy:
+        skip("NumPy is required for this test")
+
+    def bode_phase_evalf(system, point):
+        expr = system.to_expr()
+        _w = Dummy("w", real=True)
+        w_expr = expr.subs({system.var: I*_w})
+        return arg(w_expr).subs({_w: point}).evalf()
+
+    def bode_mag_evalf(system, point):
+        expr = system.to_expr()
+        _w = Dummy("w", real=True)
+        w_expr = expr.subs({system.var: I*_w})
+        return 20*log(Abs(w_expr), 10).subs({_w: point}).evalf()
+
+    def test_bode_data(sys):
+        return y_coordinate_equality(bode_magnitude_numerical_data, bode_mag_evalf, sys) \
+            and y_coordinate_equality(bode_phase_numerical_data, bode_phase_evalf, sys)
+
+    assert test_bode_data(tf1)
+    assert test_bode_data(tf2)
+    assert test_bode_data(tf3)
+    assert test_bode_data(tf4)
+    assert test_bode_data(tf5)
+
+
+def check_point_accuracy(a, b):
+    return all(isclose(a_i, b_i, rel_tol=10e-12) for \
+        a_i, b_i in zip(a, b))
+
+
+def test_impulse_response():
+    if not numpy:
+        skip("NumPy is required for this test")
+
+    def impulse_res_tester(sys, expected_value):
+        x, y = _to_tuple(*impulse_response_numerical_data(sys,
+            adaptive=False, nb_of_points=10))
+        x_check = check_point_accuracy(x, expected_value[0])
+        y_check = check_point_accuracy(y, expected_value[1])
+        return x_check and y_check
+
+    exp1 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445,
+        5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0),
+        (0.0, 0.544019738507865, 0.01993849743234938, -0.31140243360893216, -0.022852779906491996, 0.1778306498155759,
+        0.01962941084328499, -0.1013115194573652, -0.014975541213105696, 0.0575789724730714))
+    exp2 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445, 5.555555555555555,
+        6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0), (0.1666666675, 0.08389223412935855,
+        0.02338051973475047, -0.014966807776379383, -0.034645954223054234, -0.040560075735512804,
+        -0.037658628907103885, -0.030149507719590022, -0.021162090730736834, -0.012721292737437523))
+    exp3 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445, 5.555555555555555,
+        6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0), (4.369893391586999e-09, 1.1750333000630964,
+        3.2922404058312473, 9.432290008148343, 28.37098083007151, 86.18577464367974, 261.90356653762115,
+        795.6538758627842, 2416.9920942096983, 7342.159505206647))
+    exp4 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445, 5.555555555555555,
+        6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0), (0.0, 6.17283950617284, 24.69135802469136,
+        55.555555555555564, 98.76543209876544, 154.320987654321, 222.22222222222226, 302.46913580246917,
+        395.0617283950618, 500.0))
+    exp5 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445, 5.555555555555555,
+        6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0), (0.0, -0.10455606138085417,
+        0.06757671513476461, -0.03234567568833768, 0.013582514927757873, -0.005273419510705473,
+        0.0019364083003354075, -0.000680070134067832, 0.00022969845960406913, -7.476094359583917e-05))
+    exp6 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445,
+        5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0),
+        (-6.016699583000218e-09, 0.35039802056107394, 3.3728423827689884, 12.119846079276684,
+        25.86101014293389, 29.352480635282088, -30.49475907497664, -273.8717189554019, -863.2381702029659,
+        -1747.0262164682233))
+    exp7 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335,
+        4.444444444444445, 5.555555555555555, 6.666666666666667, 7.777777777777779,
+        8.88888888888889, 10.0), (0.0, 18.934638095560974, 5346.93244680907, 1384609.8718249386,
+        358161126.65801865, 92645770015.70108, 23964739753087.42, 6198974342083139.0, 1.603492601616059e+18,
+        4.147764422869658e+20))
+
+    assert impulse_res_tester(tf1, exp1)
+    assert impulse_res_tester(tf2, exp2)
+    assert impulse_res_tester(tf3, exp3)
+    assert impulse_res_tester(tf4, exp4)
+    assert impulse_res_tester(tf5, exp5)
+    assert impulse_res_tester(tf7, exp6)
+    assert impulse_res_tester(ser1, exp7)
+
+
+def test_step_response():
+    if not numpy:
+        skip("NumPy is required for this test")
+
+    def step_res_tester(sys, expected_value):
+        x, y = _to_tuple(*step_response_numerical_data(sys,
+            adaptive=False, nb_of_points=10))
+        x_check = check_point_accuracy(x, expected_value[0])
+        y_check = check_point_accuracy(y, expected_value[1])
+        return x_check and y_check
+
+    exp1 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445,
+        5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0),
+        (-1.9193285738516863e-08, 0.42283495488246126, 0.7840485977945262, 0.5546841805655717,
+        0.33903033806932087, 0.4627251747410237, 0.5909907598988051, 0.5247213989553071,
+        0.4486997874319281, 0.4839358435839171))
+    exp2 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445,
+        5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0),
+        (0.0, 0.13728409095645816, 0.19474559355325086, 0.1974909129243011, 0.16841657696573073,
+        0.12559777736159378, 0.08153828016664713, 0.04360471317348958, 0.015072994568868221,
+        -0.003636420058445484))
+    exp3 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445,
+        5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0),
+        (0.0, 0.6314542141914303, 2.9356520038101035, 9.37731009663807, 28.452300356688376,
+        86.25721933273988, 261.9236645044672, 795.6435410577224, 2416.9786984578764, 7342.154119725917))
+    exp4 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445,
+        5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0),
+        (0.0, 2.286236899862826, 18.28989519890261, 61.72839629629631, 146.31916159122088, 285.7796124828532,
+        493.8271703703705, 784.1792566529494, 1170.553292729767, 1666.6667))
+    exp5 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445,
+        5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0),
+        (-3.999999997894577e-09, 0.6720357068882895, 0.4429938256137113, 0.5182010838004518,
+        0.4944139147159695, 0.5016379853883338, 0.4995466896527733, 0.5001154784851325,
+        0.49997448824584123, 0.5000039745919259))
+    exp6 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445,
+        5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0),
+        (-1.5433688493882158e-09, 0.3428705539937336, 1.1253619102202777, 3.1849962651016517,
+        9.47532757182671, 28.727231099148135, 87.29426924860557, 265.2138681048606, 805.6636260007757,
+        2447.387582370878))
+
+    assert step_res_tester(tf1, exp1)
+    assert step_res_tester(tf2, exp2)
+    assert step_res_tester(tf3, exp3)
+    assert step_res_tester(tf4, exp4)
+    assert step_res_tester(tf5, exp5)
+    assert step_res_tester(ser2, exp6)
+
+
+def test_ramp_response():
+    if not numpy:
+        skip("NumPy is required for this test")
+
+    def ramp_res_tester(sys, num_points, expected_value, slope=1):
+        x, y = _to_tuple(*ramp_response_numerical_data(sys,
+            slope=slope, adaptive=False, nb_of_points=num_points))
+        x_check = check_point_accuracy(x, expected_value[0])
+        y_check = check_point_accuracy(y, expected_value[1])
+        return x_check and y_check
+
+    exp1 = ((0.0, 2.0, 4.0, 6.0, 8.0, 10.0), (0.0, 0.7324667795033895, 1.9909720978650398,
+        2.7956587704217783, 3.9224897567931514, 4.85022655284895))
+    exp2 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445,
+        5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0),
+        (2.4360213402019326e-08, 0.10175320182493253, 0.33057612497658406, 0.5967937263298935,
+        0.8431511866718248, 1.0398805391471613, 1.1776043125035738, 1.2600994825747305, 1.2981042689274653,
+        1.304684417610106))
+    exp3 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445, 5.555555555555555,
+        6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0), (-3.9329040468771836e-08,
+        0.34686634635794555, 2.9998828170537903, 12.33303690737476, 40.993913948137795, 127.84145222317912,
+        391.41713691996, 1192.0006858708389, 3623.9808672503405, 11011.728034546572))
+    exp4 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445, 5.555555555555555,
+        6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0), (0.0, 1.9051973784484078, 30.483158055174524,
+        154.32098765432104, 487.7305288827924, 1190.7483615302544, 2469.1358024691367, 4574.3789056546275,
+        7803.688462124678, 12500.0))
+    exp5 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445, 5.555555555555555,
+        6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0), (0.0, 3.8844361856975635, 9.141792069209865,
+        14.096349157657231, 19.09783068994694, 24.10179770390321, 29.09907319114121, 34.10040420185154,
+        39.09983919254265, 44.10006013058409))
+    exp6 = ((0.0, 1.1111111111111112, 2.2222222222222223, 3.3333333333333335, 4.444444444444445, 5.555555555555555,
+        6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0), (0.0, 1.1111111111111112, 2.2222222222222223,
+        3.3333333333333335, 4.444444444444445, 5.555555555555555, 6.666666666666667, 7.777777777777779, 8.88888888888889, 10.0))
+
+    assert ramp_res_tester(tf1, 6, exp1)
+    assert ramp_res_tester(tf2, 10, exp2, 1.2)
+    assert ramp_res_tester(tf3, 10, exp3, 1.5)
+    assert ramp_res_tester(tf4, 10, exp4, 3)
+    assert ramp_res_tester(tf5, 10, exp5, 9)
+    assert ramp_res_tester(tf6, 10, exp6)

venv/lib/python3.10/site-packages/sympy/physics/control/tests/test_lti.py

@@ -0,0 +1,1245 @@
+from sympy.core.add import Add
+from sympy.core.function import Function
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational, oo)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.matrices.dense import eye
+from sympy.polys.polytools import factor
+from sympy.polys.rootoftools import CRootOf
+from sympy.simplify.simplify import simplify
+from sympy.core.containers import Tuple
+from sympy.matrices import ImmutableMatrix, Matrix
+from sympy.physics.control import (TransferFunction, Series, Parallel,
+    Feedback, TransferFunctionMatrix, MIMOSeries, MIMOParallel, MIMOFeedback,
+    bilinear, backward_diff)
+from sympy.testing.pytest import raises
+
+a, x, b, s, g, d, p, k, a0, a1, a2, b0, b1, b2, tau, zeta, wn, T = symbols('a, x, b, s, g, d, p, k,\
+    a0:3, b0:3, tau, zeta, wn, T')
+TF1 = TransferFunction(1, s**2 + 2*zeta*wn*s + wn**2, s)
+TF2 = TransferFunction(k, 1, s)
+TF3 = TransferFunction(a2*p - s, a2*s + p, s)
+
+
+def test_TransferFunction_construction():
+    tf = TransferFunction(s + 1, s**2 + s + 1, s)
+    assert tf.num == (s + 1)
+    assert tf.den == (s**2 + s + 1)
+    assert tf.args == (s + 1, s**2 + s + 1, s)
+
+    tf1 = TransferFunction(s + 4, s - 5, s)
+    assert tf1.num == (s + 4)
+    assert tf1.den == (s - 5)
+    assert tf1.args == (s + 4, s - 5, s)
+
+    # using different polynomial variables.
+    tf2 = TransferFunction(p + 3, p**2 - 9, p)
+    assert tf2.num == (p + 3)
+    assert tf2.den == (p**2 - 9)
+    assert tf2.args == (p + 3, p**2 - 9, p)
+
+    tf3 = TransferFunction(p**3 + 5*p**2 + 4, p**4 + 3*p + 1, p)
+    assert tf3.args == (p**3 + 5*p**2 + 4, p**4 + 3*p + 1, p)
+
+    # no pole-zero cancellation on its own.
+    tf4 = TransferFunction((s + 3)*(s - 1), (s - 1)*(s + 5), s)
+    assert tf4.den == (s - 1)*(s + 5)
+    assert tf4.args == ((s + 3)*(s - 1), (s - 1)*(s + 5), s)
+
+    tf4_ = TransferFunction(p + 2, p + 2, p)
+    assert tf4_.args == (p + 2, p + 2, p)
+
+    tf5 = TransferFunction(s - 1, 4 - p, s)
+    assert tf5.args == (s - 1, 4 - p, s)
+
+    tf5_ = TransferFunction(s - 1, s - 1, s)
+    assert tf5_.args == (s - 1, s - 1, s)
+
+    tf6 = TransferFunction(5, 6, s)
+    assert tf6.num == 5
+    assert tf6.den == 6
+    assert tf6.args == (5, 6, s)
+
+    tf6_ = TransferFunction(1/2, 4, s)
+    assert tf6_.num == 0.5
+    assert tf6_.den == 4
+    assert tf6_.args == (0.500000000000000, 4, s)
+
+    tf7 = TransferFunction(3*s**2 + 2*p + 4*s, 8*p**2 + 7*s, s)
+    tf8 = TransferFunction(3*s**2 + 2*p + 4*s, 8*p**2 + 7*s, p)
+    assert not tf7 == tf8
+
+    tf7_ = TransferFunction(a0*s + a1*s**2 + a2*s**3, b0*p - b1*s, s)
+    tf8_ = TransferFunction(a0*s + a1*s**2 + a2*s**3, b0*p - b1*s, s)
+    assert tf7_ == tf8_
+    assert -(-tf7_) == tf7_ == -(-(-(-tf7_)))
+
+    tf9 = TransferFunction(a*s**3 + b*s**2 + g*s + d, d*p + g*p**2 + g*s, s)
+    assert tf9.args == (a*s**3 + b*s**2 + d + g*s, d*p + g*p**2 + g*s, s)
+
+    tf10 = TransferFunction(p**3 + d, g*s**2 + d*s + a, p)
+    tf10_ = TransferFunction(p**3 + d, g*s**2 + d*s + a, p)
+    assert tf10.args == (d + p**3, a + d*s + g*s**2, p)
+    assert tf10_ == tf10
+
+    tf11 = TransferFunction(a1*s + a0, b2*s**2 + b1*s + b0, s)
+    assert tf11.num == (a0 + a1*s)
+    assert tf11.den == (b0 + b1*s + b2*s**2)
+    assert tf11.args == (a0 + a1*s, b0 + b1*s + b2*s**2, s)
+
+    # when just the numerator is 0, leave the denominator alone.
+    tf12 = TransferFunction(0, p**2 - p + 1, p)
+    assert tf12.args == (0, p**2 - p + 1, p)
+
+    tf13 = TransferFunction(0, 1, s)
+    assert tf13.args == (0, 1, s)
+
+    # float exponents
+    tf14 = TransferFunction(a0*s**0.5 + a2*s**0.6 - a1, a1*p**(-8.7), s)
+    assert tf14.args == (a0*s**0.5 - a1 + a2*s**0.6, a1*p**(-8.7), s)
+
+    tf15 = TransferFunction(a2**2*p**(1/4) + a1*s**(-4/5), a0*s - p, p)
+    assert tf15.args == (a1*s**(-0.8) + a2**2*p**0.25, a0*s - p, p)
+
+    omega_o, k_p, k_o, k_i = symbols('omega_o, k_p, k_o, k_i')
+    tf18 = TransferFunction((k_p + k_o*s + k_i/s), s**2 + 2*omega_o*s + omega_o**2, s)
+    assert tf18.num == k_i/s + k_o*s + k_p
+    assert tf18.args == (k_i/s + k_o*s + k_p, omega_o**2 + 2*omega_o*s + s**2, s)
+
+    # ValueError when denominator is zero.
+    raises(ValueError, lambda: TransferFunction(4, 0, s))
+    raises(ValueError, lambda: TransferFunction(s, 0, s))
+    raises(ValueError, lambda: TransferFunction(0, 0, s))
+
+    raises(TypeError, lambda: TransferFunction(Matrix([1, 2, 3]), s, s))
+
+    raises(TypeError, lambda: TransferFunction(s**2 + 2*s - 1, s + 3, 3))
+    raises(TypeError, lambda: TransferFunction(p + 1, 5 - p, 4))
+    raises(TypeError, lambda: TransferFunction(3, 4, 8))
+
+
+def test_TransferFunction_functions():
+    # classmethod from_rational_expression
+    expr_1 = Mul(0, Pow(s, -1, evaluate=False), evaluate=False)
+    expr_2 = s/0
+    expr_3 = (p*s**2 + 5*s)/(s + 1)**3
+    expr_4 = 6
+    expr_5 = ((2 + 3*s)*(5 + 2*s))/((9 + 3*s)*(5 + 2*s**2))
+    expr_6 = (9*s**4 + 4*s**2 + 8)/((s + 1)*(s + 9))
+    tf = TransferFunction(s + 1, s**2 + 2, s)
+    delay = exp(-s/tau)
+    expr_7 = delay*tf.to_expr()
+    H1 = TransferFunction.from_rational_expression(expr_7, s)
+    H2 = TransferFunction(s + 1, (s**2 + 2)*exp(s/tau), s)
+    expr_8 = Add(2,  3*s/(s**2 + 1), evaluate=False)
+
+    assert TransferFunction.from_rational_expression(expr_1) == TransferFunction(0, s, s)
+    raises(ZeroDivisionError, lambda: TransferFunction.from_rational_expression(expr_2))
+    raises(ValueError, lambda: TransferFunction.from_rational_expression(expr_3))
+    assert TransferFunction.from_rational_expression(expr_3, s) == TransferFunction((p*s**2 + 5*s), (s + 1)**3, s)
+    assert TransferFunction.from_rational_expression(expr_3, p) == TransferFunction((p*s**2 + 5*s), (s + 1)**3, p)
+    raises(ValueError, lambda: TransferFunction.from_rational_expression(expr_4))
+    assert TransferFunction.from_rational_expression(expr_4, s) == TransferFunction(6, 1, s)
+    assert TransferFunction.from_rational_expression(expr_5, s) == \
+        TransferFunction((2 + 3*s)*(5 + 2*s), (9 + 3*s)*(5 + 2*s**2), s)
+    assert TransferFunction.from_rational_expression(expr_6, s) == \
+        TransferFunction((9*s**4 + 4*s**2 + 8), (s + 1)*(s + 9), s)
+    assert H1 == H2
+    assert TransferFunction.from_rational_expression(expr_8, s) == \
+        TransferFunction(2*s**2 + 3*s + 2, s**2 + 1, s)
+
+    # explicitly cancel poles and zeros.
+    tf0 = TransferFunction(s**5 + s**3 + s, s - s**2, s)
+    a = TransferFunction(-(s**4 + s**2 + 1), s - 1, s)
+    assert tf0.simplify() == simplify(tf0) == a
+
+    tf1 = TransferFunction((p + 3)*(p - 1), (p - 1)*(p + 5), p)
+    b = TransferFunction(p + 3, p + 5, p)
+    assert tf1.simplify() == simplify(tf1) == b
+
+    # expand the numerator and the denominator.
+    G1 = TransferFunction((1 - s)**2, (s**2 + 1)**2, s)
+    G2 = TransferFunction(1, -3, p)
+    c = (a2*s**p + a1*s**s + a0*p**p)*(p**s + s**p)
+    d = (b0*s**s + b1*p**s)*(b2*s*p + p**p)
+    e = a0*p**p*p**s + a0*p**p*s**p + a1*p**s*s**s + a1*s**p*s**s + a2*p**s*s**p + a2*s**(2*p)
+    f = b0*b2*p*s*s**s + b0*p**p*s**s + b1*b2*p*p**s*s + b1*p**p*p**s
+    g = a1*a2*s*s**p + a1*p*s + a2*b1*p*s*s**p + b1*p**2*s
+    G3 = TransferFunction(c, d, s)
+    G4 = TransferFunction(a0*s**s - b0*p**p, (a1*s + b1*s*p)*(a2*s**p + p), p)
+
+    assert G1.expand() == TransferFunction(s**2 - 2*s + 1, s**4 + 2*s**2 + 1, s)
+    assert tf1.expand() == TransferFunction(p**2 + 2*p - 3, p**2 + 4*p - 5, p)
+    assert G2.expand() == G2
+    assert G3.expand() == TransferFunction(e, f, s)
+    assert G4.expand() == TransferFunction(a0*s**s - b0*p**p, g, p)
+
+    # purely symbolic polynomials.
+    p1 = a1*s + a0
+    p2 = b2*s**2 + b1*s + b0
+    SP1 = TransferFunction(p1, p2, s)
+    expect1 = TransferFunction(2.0*s + 1.0, 5.0*s**2 + 4.0*s + 3.0, s)
+    expect1_ = TransferFunction(2*s + 1, 5*s**2 + 4*s + 3, s)
+    assert SP1.subs({a0: 1, a1: 2, b0: 3, b1: 4, b2: 5}) == expect1_
+    assert SP1.subs({a0: 1, a1: 2, b0: 3, b1: 4, b2: 5}).evalf() == expect1
+    assert expect1_.evalf() == expect1
+
+    c1, d0, d1, d2 = symbols('c1, d0:3')
+    p3, p4 = c1*p, d2*p**3 + d1*p**2 - d0
+    SP2 = TransferFunction(p3, p4, p)
+    expect2 = TransferFunction(2.0*p, 5.0*p**3 + 2.0*p**2 - 3.0, p)
+    expect2_ = TransferFunction(2*p, 5*p**3 + 2*p**2 - 3, p)
+    assert SP2.subs({c1: 2, d0: 3, d1: 2, d2: 5}) == expect2_
+    assert SP2.subs({c1: 2, d0: 3, d1: 2, d2: 5}).evalf() == expect2
+    assert expect2_.evalf() == expect2
+
+    SP3 = TransferFunction(a0*p**3 + a1*s**2 - b0*s + b1, a1*s + p, s)
+    expect3 = TransferFunction(2.0*p**3 + 4.0*s**2 - s + 5.0, p + 4.0*s, s)
+    expect3_ = TransferFunction(2*p**3 + 4*s**2 - s + 5, p + 4*s, s)
+    assert SP3.subs({a0: 2, a1: 4, b0: 1, b1: 5}) == expect3_
+    assert SP3.subs({a0: 2, a1: 4, b0: 1, b1: 5}).evalf() == expect3
+    assert expect3_.evalf() == expect3
+
+    SP4 = TransferFunction(s - a1*p**3, a0*s + p, p)
+    expect4 = TransferFunction(7.0*p**3 + s, p - s, p)
+    expect4_ = TransferFunction(7*p**3 + s, p - s, p)
+    assert SP4.subs({a0: -1, a1: -7}) == expect4_
+    assert SP4.subs({a0: -1, a1: -7}).evalf() == expect4
+    assert expect4_.evalf() == expect4
+
+    # Low-frequency (or DC) gain.
+    assert tf0.dc_gain() == 1
+    assert tf1.dc_gain() == Rational(3, 5)
+    assert SP2.dc_gain() == 0
+    assert expect4.dc_gain() == -1
+    assert expect2_.dc_gain() == 0
+    assert TransferFunction(1, s, s).dc_gain() == oo
+
+    # Poles of a transfer function.
+    tf_ = TransferFunction(x**3 - k, k, x)
+    _tf = TransferFunction(k, x**4 - k, x)
+    TF_ = TransferFunction(x**2, x**10 + x + x**2, x)
+    _TF = TransferFunction(x**10 + x + x**2, x**2, x)
+    assert G1.poles() == [I, I, -I, -I]
+    assert G2.poles() == []
+    assert tf1.poles() == [-5, 1]
+    assert expect4_.poles() == [s]
+    assert SP4.poles() == [-a0*s]
+    assert expect3.poles() == [-0.25*p]
+    assert str(expect2.poles()) == str([0.729001428685125, -0.564500714342563 - 0.710198984796332*I, -0.564500714342563 + 0.710198984796332*I])
+    assert str(expect1.poles()) == str([-0.4 - 0.66332495807108*I, -0.4 + 0.66332495807108*I])
+    assert _tf.poles() == [k**(Rational(1, 4)), -k**(Rational(1, 4)), I*k**(Rational(1, 4)), -I*k**(Rational(1, 4))]
+    assert TF_.poles() == [CRootOf(x**9 + x + 1, 0), 0, CRootOf(x**9 + x + 1, 1), CRootOf(x**9 + x + 1, 2),
+        CRootOf(x**9 + x + 1, 3), CRootOf(x**9 + x + 1, 4), CRootOf(x**9 + x + 1, 5), CRootOf(x**9 + x + 1, 6),
+        CRootOf(x**9 + x + 1, 7), CRootOf(x**9 + x + 1, 8)]
+    raises(NotImplementedError, lambda: TransferFunction(x**2, a0*x**10 + x + x**2, x).poles())
+
+    # Stability of a transfer function.
+    q, r = symbols('q, r', negative=True)
+    t = symbols('t', positive=True)
+    TF_ = TransferFunction(s**2 + a0 - a1*p, q*s - r, s)
+    stable_tf = TransferFunction(s**2 + a0 - a1*p, q*s - 1, s)
+    stable_tf_ = TransferFunction(s**2 + a0 - a1*p, q*s - t, s)
+
+    assert G1.is_stable() is False
+    assert G2.is_stable() is True
+    assert tf1.is_stable() is False   # as one pole is +ve, and the other is -ve.
+    assert expect2.is_stable() is False
+    assert expect1.is_stable() is True
+    assert stable_tf.is_stable() is True
+    assert stable_tf_.is_stable() is True
+    assert TF_.is_stable() is False
+    assert expect4_.is_stable() is None   # no assumption provided for the only pole 's'.
+    assert SP4.is_stable() is None
+
+    # Zeros of a transfer function.
+    assert G1.zeros() == [1, 1]
+    assert G2.zeros() == []
+    assert tf1.zeros() == [-3, 1]
+    assert expect4_.zeros() == [7**(Rational(2, 3))*(-s)**(Rational(1, 3))/7, -7**(Rational(2, 3))*(-s)**(Rational(1, 3))/14 -
+        sqrt(3)*7**(Rational(2, 3))*I*(-s)**(Rational(1, 3))/14, -7**(Rational(2, 3))*(-s)**(Rational(1, 3))/14 + sqrt(3)*7**(Rational(2, 3))*I*(-s)**(Rational(1, 3))/14]
+    assert SP4.zeros() == [(s/a1)**(Rational(1, 3)), -(s/a1)**(Rational(1, 3))/2 - sqrt(3)*I*(s/a1)**(Rational(1, 3))/2,
+        -(s/a1)**(Rational(1, 3))/2 + sqrt(3)*I*(s/a1)**(Rational(1, 3))/2]
+    assert str(expect3.zeros()) == str([0.125 - 1.11102430216445*sqrt(-0.405063291139241*p**3 - 1.0),
+        1.11102430216445*sqrt(-0.405063291139241*p**3 - 1.0) + 0.125])
+    assert tf_.zeros() == [k**(Rational(1, 3)), -k**(Rational(1, 3))/2 - sqrt(3)*I*k**(Rational(1, 3))/2,
+        -k**(Rational(1, 3))/2 + sqrt(3)*I*k**(Rational(1, 3))/2]
+    assert _TF.zeros() == [CRootOf(x**9 + x + 1, 0), 0, CRootOf(x**9 + x + 1, 1), CRootOf(x**9 + x + 1, 2),
+        CRootOf(x**9 + x + 1, 3), CRootOf(x**9 + x + 1, 4), CRootOf(x**9 + x + 1, 5), CRootOf(x**9 + x + 1, 6),
+        CRootOf(x**9 + x + 1, 7), CRootOf(x**9 + x + 1, 8)]
+    raises(NotImplementedError, lambda: TransferFunction(a0*x**10 + x + x**2, x**2, x).zeros())
+
+    # negation of TF.
+    tf2 = TransferFunction(s + 3, s**2 - s**3 + 9, s)
+    tf3 = TransferFunction(-3*p + 3, 1 - p, p)
+    assert -tf2 == TransferFunction(-s - 3, s**2 - s**3 + 9, s)
+    assert -tf3 == TransferFunction(3*p - 3, 1 - p, p)
+
+    # taking power of a TF.
+    tf4 = TransferFunction(p + 4, p - 3, p)
+    tf5 = TransferFunction(s**2 + 1, 1 - s, s)
+    expect2 = TransferFunction((s**2 + 1)**3, (1 - s)**3, s)
+    expect1 = TransferFunction((p + 4)**2, (p - 3)**2, p)
+    assert (tf4*tf4).doit() == tf4**2 == pow(tf4, 2) == expect1
+    assert (tf5*tf5*tf5).doit() == tf5**3 == pow(tf5, 3) == expect2
+    assert tf5**0 == pow(tf5, 0) == TransferFunction(1, 1, s)
+    assert Series(tf4).doit()**-1 == tf4**-1 == pow(tf4, -1) == TransferFunction(p - 3, p + 4, p)
+    assert (tf5*tf5).doit()**-1 == tf5**-2 == pow(tf5, -2) == TransferFunction((1 - s)**2, (s**2 + 1)**2, s)
+
+    raises(ValueError, lambda: tf4**(s**2 + s - 1))
+    raises(ValueError, lambda: tf5**s)
+    raises(ValueError, lambda: tf4**tf5)
+
+    # SymPy's own functions.
+    tf = TransferFunction(s - 1, s**2 - 2*s + 1, s)
+    tf6 = TransferFunction(s + p, p**2 - 5, s)
+    assert factor(tf) == TransferFunction(s - 1, (s - 1)**2, s)
+    assert tf.num.subs(s, 2) == tf.den.subs(s, 2) == 1
+    # subs & xreplace
+    assert tf.subs(s, 2) == TransferFunction(s - 1, s**2 - 2*s + 1, s)
+    assert tf6.subs(p, 3) == TransferFunction(s + 3, 4, s)
+    assert tf3.xreplace({p: s}) == TransferFunction(-3*s + 3, 1 - s, s)
+    raises(TypeError, lambda: tf3.xreplace({p: exp(2)}))
+    assert tf3.subs(p, exp(2)) == tf3
+
+    tf7 = TransferFunction(a0*s**p + a1*p**s, a2*p - s, s)
+    assert tf7.xreplace({s: k}) == TransferFunction(a0*k**p + a1*p**k, a2*p - k, k)
+    assert tf7.subs(s, k) == TransferFunction(a0*s**p + a1*p**s, a2*p - s, s)
+
+    # Conversion to Expr with to_expr()
+    tf8 = TransferFunction(a0*s**5 + 5*s**2 + 3, s**6 - 3, s)
+    tf9 = TransferFunction((5 + s), (5 + s)*(6 + s), s)
+    tf10 = TransferFunction(0, 1, s)
+    tf11 = TransferFunction(1, 1, s)
+    assert tf8.to_expr() == Mul((a0*s**5 + 5*s**2 + 3), Pow((s**6 - 3), -1, evaluate=False), evaluate=False)
+    assert tf9.to_expr() == Mul((s + 5), Pow((5 + s)*(6 + s), -1, evaluate=False), evaluate=False)
+    assert tf10.to_expr() == Mul(S(0), Pow(1, -1, evaluate=False), evaluate=False)
+    assert tf11.to_expr() == Pow(1, -1, evaluate=False)
+
+def test_TransferFunction_addition_and_subtraction():
+    tf1 = TransferFunction(s + 6, s - 5, s)
+    tf2 = TransferFunction(s + 3, s + 1, s)
+    tf3 = TransferFunction(s + 1, s**2 + s + 1, s)
+    tf4 = TransferFunction(p, 2 - p, p)
+
+    # addition
+    assert tf1 + tf2 == Parallel(tf1, tf2)
+    assert tf3 + tf1 == Parallel(tf3, tf1)
+    assert -tf1 + tf2 + tf3 == Parallel(-tf1, tf2, tf3)
+    assert tf1 + (tf2 + tf3) == Parallel(tf1, tf2, tf3)
+
+    c = symbols("c", commutative=False)
+    raises(ValueError, lambda: tf1 + Matrix([1, 2, 3]))
+    raises(ValueError, lambda: tf2 + c)
+    raises(ValueError, lambda: tf3 + tf4)
+    raises(ValueError, lambda: tf1 + (s - 1))
+    raises(ValueError, lambda: tf1 + 8)
+    raises(ValueError, lambda: (1 - p**3) + tf1)
+
+    # subtraction
+    assert tf1 - tf2 == Parallel(tf1, -tf2)
+    assert tf3 - tf2 == Parallel(tf3, -tf2)
+    assert -tf1 - tf3 == Parallel(-tf1, -tf3)
+    assert tf1 - tf2 + tf3 == Parallel(tf1, -tf2, tf3)
+
+    raises(ValueError, lambda: tf1 - Matrix([1, 2, 3]))
+    raises(ValueError, lambda: tf3 - tf4)
+    raises(ValueError, lambda: tf1 - (s - 1))
+    raises(ValueError, lambda: tf1 - 8)
+    raises(ValueError, lambda: (s + 5) - tf2)
+    raises(ValueError, lambda: (1 + p**4) - tf1)
+
+
+def test_TransferFunction_multiplication_and_division():
+    G1 = TransferFunction(s + 3, -s**3 + 9, s)
+    G2 = TransferFunction(s + 1, s - 5, s)
+    G3 = TransferFunction(p, p**4 - 6, p)
+    G4 = TransferFunction(p + 4, p - 5, p)
+    G5 = TransferFunction(s + 6, s - 5, s)
+    G6 = TransferFunction(s + 3, s + 1, s)
+    G7 = TransferFunction(1, 1, s)
+
+    # multiplication
+    assert G1*G2 == Series(G1, G2)
+    assert -G1*G5 == Series(-G1, G5)
+    assert -G2*G5*-G6 == Series(-G2, G5, -G6)
+    assert -G1*-G2*-G5*-G6 == Series(-G1, -G2, -G5, -G6)
+    assert G3*G4 == Series(G3, G4)
+    assert (G1*G2)*-(G5*G6) == \
+        Series(G1, G2, TransferFunction(-1, 1, s), Series(G5, G6))
+    assert G1*G2*(G5 + G6) == Series(G1, G2, Parallel(G5, G6))
+
+    c = symbols("c", commutative=False)
+    raises(ValueError, lambda: G3 * Matrix([1, 2, 3]))
+    raises(ValueError, lambda: G1 * c)
+    raises(ValueError, lambda: G3 * G5)
+    raises(ValueError, lambda: G5 * (s - 1))
+    raises(ValueError, lambda: 9 * G5)
+
+    raises(ValueError, lambda: G3 / Matrix([1, 2, 3]))
+    raises(ValueError, lambda: G6 / 0)
+    raises(ValueError, lambda: G3 / G5)
+    raises(ValueError, lambda: G5 / 2)
+    raises(ValueError, lambda: G5 / s**2)
+    raises(ValueError, lambda: (s - 4*s**2) / G2)
+    raises(ValueError, lambda: 0 / G4)
+    raises(ValueError, lambda: G5 / G6)
+    raises(ValueError, lambda: -G3 /G4)
+    raises(ValueError, lambda: G7 / (1 + G6))
+    raises(ValueError, lambda: G7 / (G5 * G6))
+    raises(ValueError, lambda: G7 / (G7 + (G5 + G6)))
+
+
+def test_TransferFunction_is_proper():
+    omega_o, zeta, tau = symbols('omega_o, zeta, tau')
+    G1 = TransferFunction(omega_o**2, s**2 + p*omega_o*zeta*s + omega_o**2, omega_o)
+    G2 = TransferFunction(tau - s**3, tau + p**4, tau)
+    G3 = TransferFunction(a*b*s**3 + s**2 - a*p + s, b - s*p**2, p)
+    G4 = TransferFunction(b*s**2 + p**2 - a*p + s, b - p**2, s)
+    assert G1.is_proper
+    assert G2.is_proper
+    assert G3.is_proper
+    assert not G4.is_proper
+
+
+def test_TransferFunction_is_strictly_proper():
+    omega_o, zeta, tau = symbols('omega_o, zeta, tau')
+    tf1 = TransferFunction(omega_o**2, s**2 + p*omega_o*zeta*s + omega_o**2, omega_o)
+    tf2 = TransferFunction(tau - s**3, tau + p**4, tau)
+    tf3 = TransferFunction(a*b*s**3 + s**2 - a*p + s, b - s*p**2, p)
+    tf4 = TransferFunction(b*s**2 + p**2 - a*p + s, b - p**2, s)
+    assert not tf1.is_strictly_proper
+    assert not tf2.is_strictly_proper
+    assert tf3.is_strictly_proper
+    assert not tf4.is_strictly_proper
+
+
+def test_TransferFunction_is_biproper():
+    tau, omega_o, zeta = symbols('tau, omega_o, zeta')
+    tf1 = TransferFunction(omega_o**2, s**2 + p*omega_o*zeta*s + omega_o**2, omega_o)
+    tf2 = TransferFunction(tau - s**3, tau + p**4, tau)
+    tf3 = TransferFunction(a*b*s**3 + s**2 - a*p + s, b - s*p**2, p)
+    tf4 = TransferFunction(b*s**2 + p**2 - a*p + s, b - p**2, s)
+    assert tf1.is_biproper
+    assert tf2.is_biproper
+    assert not tf3.is_biproper
+    assert not tf4.is_biproper
+
+
+def test_Series_construction():
+    tf = TransferFunction(a0*s**3 + a1*s**2 - a2*s, b0*p**4 + b1*p**3 - b2*s*p, s)
+    tf2 = TransferFunction(a2*p - s, a2*s + p, s)
+    tf3 = TransferFunction(a0*p + p**a1 - s, p, p)
+    tf4 = TransferFunction(1, s**2 + 2*zeta*wn*s + wn**2, s)
+    inp = Function('X_d')(s)
+    out = Function('X')(s)
+
+    s0 = Series(tf, tf2)
+    assert s0.args == (tf, tf2)
+    assert s0.var == s
+
+    s1 = Series(Parallel(tf, -tf2), tf2)
+    assert s1.args == (Parallel(tf, -tf2), tf2)
+    assert s1.var == s
+
+    tf3_ = TransferFunction(inp, 1, s)
+    tf4_ = TransferFunction(-out, 1, s)
+    s2 = Series(tf, Parallel(tf3_, tf4_), tf2)
+    assert s2.args == (tf, Parallel(tf3_, tf4_), tf2)
+
+    s3 = Series(tf, tf2, tf4)
+    assert s3.args == (tf, tf2, tf4)
+
+    s4 = Series(tf3_, tf4_)
+    assert s4.args == (tf3_, tf4_)
+    assert s4.var == s
+
+    s6 = Series(tf2, tf4, Parallel(tf2, -tf), tf4)
+    assert s6.args == (tf2, tf4, Parallel(tf2, -tf), tf4)
+
+    s7 = Series(tf, tf2)
+    assert s0 == s7
+    assert not s0 == s2
+
+    raises(ValueError, lambda: Series(tf, tf3))
+    raises(ValueError, lambda: Series(tf, tf2, tf3, tf4))
+    raises(ValueError, lambda: Series(-tf3, tf2))
+    raises(TypeError, lambda: Series(2, tf, tf4))
+    raises(TypeError, lambda: Series(s**2 + p*s, tf3, tf2))
+    raises(TypeError, lambda: Series(tf3, Matrix([1, 2, 3, 4])))
+
+
+def test_MIMOSeries_construction():
+    tf_1 = TransferFunction(a0*s**3 + a1*s**2 - a2*s, b0*p**4 + b1*p**3 - b2*s*p, s)
+    tf_2 = TransferFunction(a2*p - s, a2*s + p, s)
+    tf_3 = TransferFunction(1, s**2 + 2*zeta*wn*s + wn**2, s)
+
+    tfm_1 = TransferFunctionMatrix([[tf_1, tf_2, tf_3], [-tf_3, -tf_2, tf_1]])
+    tfm_2 = TransferFunctionMatrix([[-tf_2], [-tf_2], [-tf_3]])
+    tfm_3 = TransferFunctionMatrix([[-tf_3]])
+    tfm_4 = TransferFunctionMatrix([[TF3], [TF2], [-TF1]])
+    tfm_5 = TransferFunctionMatrix.from_Matrix(Matrix([1/p]), p)
+
+    s8 = MIMOSeries(tfm_2, tfm_1)
+    assert s8.args == (tfm_2, tfm_1)
+    assert s8.var == s
+    assert s8.shape == (s8.num_outputs, s8.num_inputs) == (2, 1)
+
+    s9 = MIMOSeries(tfm_3, tfm_2, tfm_1)
+    assert s9.args == (tfm_3, tfm_2, tfm_1)
+    assert s9.var == s
+    assert s9.shape == (s9.num_outputs, s9.num_inputs) == (2, 1)
+
+    s11 = MIMOSeries(tfm_3, MIMOParallel(-tfm_2, -tfm_4), tfm_1)
+    assert s11.args == (tfm_3, MIMOParallel(-tfm_2, -tfm_4), tfm_1)
+    assert s11.shape == (s11.num_outputs, s11.num_inputs) == (2, 1)
+
+    # arg cannot be empty tuple.
+    raises(ValueError, lambda: MIMOSeries())
+
+    # arg cannot contain SISO as well as MIMO systems.
+    raises(TypeError, lambda: MIMOSeries(tfm_1, tf_1))
+
+    # for all the adjacent transfer function matrices:
+    # no. of inputs of first TFM must be equal to the no. of outputs of the second TFM.
+    raises(ValueError, lambda: MIMOSeries(tfm_1, tfm_2, -tfm_1))
+
+    # all the TFMs must use the same complex variable.
+    raises(ValueError, lambda: MIMOSeries(tfm_3, tfm_5))
+
+    # Number or expression not allowed in the arguments.
+    raises(TypeError, lambda: MIMOSeries(2, tfm_2, tfm_3))
+    raises(TypeError, lambda: MIMOSeries(s**2 + p*s, -tfm_2, tfm_3))
+    raises(TypeError, lambda: MIMOSeries(Matrix([1/p]), tfm_3))
+
+
+def test_Series_functions():
+    tf1 = TransferFunction(1, s**2 + 2*zeta*wn*s + wn**2, s)
+    tf2 = TransferFunction(k, 1, s)
+    tf3 = TransferFunction(a2*p - s, a2*s + p, s)
+    tf4 = TransferFunction(a0*p + p**a1 - s, p, p)
+    tf5 = TransferFunction(a1*s**2 + a2*s - a0, s + a0, s)
+
+    assert tf1*tf2*tf3 == Series(tf1, tf2, tf3) == Series(Series(tf1, tf2), tf3) \
+        == Series(tf1, Series(tf2, tf3))
+    assert tf1*(tf2 + tf3) == Series(tf1, Parallel(tf2, tf3))
+    assert tf1*tf2 + tf5 == Parallel(Series(tf1, tf2), tf5)
+    assert tf1*tf2 - tf5 == Parallel(Series(tf1, tf2), -tf5)
+    assert tf1*tf2 + tf3 + tf5 == Parallel(Series(tf1, tf2), tf3, tf5)
+    assert tf1*tf2 - tf3 - tf5 == Parallel(Series(tf1, tf2), -tf3, -tf5)
+    assert tf1*tf2 - tf3 + tf5 == Parallel(Series(tf1, tf2), -tf3, tf5)
+    assert tf1*tf2 + tf3*tf5 == Parallel(Series(tf1, tf2), Series(tf3, tf5))
+    assert tf1*tf2 - tf3*tf5 == Parallel(Series(tf1, tf2), Series(TransferFunction(-1, 1, s), Series(tf3, tf5)))
+    assert tf2*tf3*(tf2 - tf1)*tf3 == Series(tf2, tf3, Parallel(tf2, -tf1), tf3)
+    assert -tf1*tf2 == Series(-tf1, tf2)
+    assert -(tf1*tf2) == Series(TransferFunction(-1, 1, s), Series(tf1, tf2))
+    raises(ValueError, lambda: tf1*tf2*tf4)
+    raises(ValueError, lambda: tf1*(tf2 - tf4))
+    raises(ValueError, lambda: tf3*Matrix([1, 2, 3]))
+
+    # evaluate=True -> doit()
+    assert Series(tf1, tf2, evaluate=True) == Series(tf1, tf2).doit() == \
+        TransferFunction(k, s**2 + 2*s*wn*zeta + wn**2, s)
+    assert Series(tf1, tf2, Parallel(tf1, -tf3), evaluate=True) == Series(tf1, tf2, Parallel(tf1, -tf3)).doit() == \
+        TransferFunction(k*(a2*s + p + (-a2*p + s)*(s**2 + 2*s*wn*zeta + wn**2)), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2)**2, s)
+    assert Series(tf2, tf1, -tf3, evaluate=True) == Series(tf2, tf1, -tf3).doit() == \
+        TransferFunction(k*(-a2*p + s), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert not Series(tf1, -tf2, evaluate=False) == Series(tf1, -tf2).doit()
+
+    assert Series(Parallel(tf1, tf2), Parallel(tf2, -tf3)).doit() == \
+        TransferFunction((k*(s**2 + 2*s*wn*zeta + wn**2) + 1)*(-a2*p + k*(a2*s + p) + s), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert Series(-tf1, -tf2, -tf3).doit() == \
+        TransferFunction(k*(-a2*p + s), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert -Series(tf1, tf2, tf3).doit() == \
+        TransferFunction(-k*(a2*p - s), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert Series(tf2, tf3, Parallel(tf2, -tf1), tf3).doit() == \
+        TransferFunction(k*(a2*p - s)**2*(k*(s**2 + 2*s*wn*zeta + wn**2) - 1), (a2*s + p)**2*(s**2 + 2*s*wn*zeta + wn**2), s)
+
+    assert Series(tf1, tf2).rewrite(TransferFunction) == TransferFunction(k, s**2 + 2*s*wn*zeta + wn**2, s)
+    assert Series(tf2, tf1, -tf3).rewrite(TransferFunction) == \
+        TransferFunction(k*(-a2*p + s), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+
+    S1 = Series(Parallel(tf1, tf2), Parallel(tf2, -tf3))
+    assert S1.is_proper
+    assert not S1.is_strictly_proper
+    assert S1.is_biproper
+
+    S2 = Series(tf1, tf2, tf3)
+    assert S2.is_proper
+    assert S2.is_strictly_proper
+    assert not S2.is_biproper
+
+    S3 = Series(tf1, -tf2, Parallel(tf1, -tf3))
+    assert S3.is_proper
+    assert S3.is_strictly_proper
+    assert not S3.is_biproper
+
+
+def test_MIMOSeries_functions():
+    tfm1 = TransferFunctionMatrix([[TF1, TF2, TF3], [-TF3, -TF2, TF1]])
+    tfm2 = TransferFunctionMatrix([[-TF1], [-TF2], [-TF3]])
+    tfm3 = TransferFunctionMatrix([[-TF1]])
+    tfm4 = TransferFunctionMatrix([[-TF2, -TF3], [-TF1, TF2]])
+    tfm5 = TransferFunctionMatrix([[TF2, -TF2], [-TF3, -TF2]])
+    tfm6 = TransferFunctionMatrix([[-TF3], [TF1]])
+    tfm7 = TransferFunctionMatrix([[TF1], [-TF2]])
+
+    assert tfm1*tfm2 + tfm6 == MIMOParallel(MIMOSeries(tfm2, tfm1), tfm6)
+    assert tfm1*tfm2 + tfm7 + tfm6 == MIMOParallel(MIMOSeries(tfm2, tfm1), tfm7, tfm6)
+    assert tfm1*tfm2 - tfm6 - tfm7 == MIMOParallel(MIMOSeries(tfm2, tfm1), -tfm6, -tfm7)
+    assert tfm4*tfm5 + (tfm4 - tfm5) == MIMOParallel(MIMOSeries(tfm5, tfm4), tfm4, -tfm5)
+    assert tfm4*-tfm6 + (-tfm4*tfm6) == MIMOParallel(MIMOSeries(-tfm6, tfm4), MIMOSeries(tfm6, -tfm4))
+
+    raises(ValueError, lambda: tfm1*tfm2 + TF1)
+    raises(TypeError, lambda: tfm1*tfm2 + a0)
+    raises(TypeError, lambda: tfm4*tfm6 - (s - 1))
+    raises(TypeError, lambda: tfm4*-tfm6 - 8)
+    raises(TypeError, lambda: (-1 + p**5) + tfm1*tfm2)
+
+    # Shape criteria.
+
+    raises(TypeError, lambda: -tfm1*tfm2 + tfm4)
+    raises(TypeError, lambda: tfm1*tfm2 - tfm4 + tfm5)
+    raises(TypeError, lambda: tfm1*tfm2 - tfm4*tfm5)
+
+    assert tfm1*tfm2*-tfm3 == MIMOSeries(-tfm3, tfm2, tfm1)
+    assert (tfm1*-tfm2)*tfm3 == MIMOSeries(tfm3, -tfm2, tfm1)
+
+    # Multiplication of a Series object with a SISO TF not allowed.
+
+    raises(ValueError, lambda: tfm4*tfm5*TF1)
+    raises(TypeError, lambda: tfm4*tfm5*a1)
+    raises(TypeError, lambda: tfm4*-tfm5*(s - 2))
+    raises(TypeError, lambda: tfm5*tfm4*9)
+    raises(TypeError, lambda: (-p**3 + 1)*tfm5*tfm4)
+
+    # Transfer function matrix in the arguments.
+    assert (MIMOSeries(tfm2, tfm1, evaluate=True) == MIMOSeries(tfm2, tfm1).doit()
+        == TransferFunctionMatrix(((TransferFunction(-k**2*(a2*s + p)**2*(s**2 + 2*s*wn*zeta + wn**2)**2 + (-a2*p + s)*(a2*p - s)*(s**2 + 2*s*wn*zeta + wn**2)**2 - (a2*s + p)**2,
+        (a2*s + p)**2*(s**2 + 2*s*wn*zeta + wn**2)**2, s),),
+        (TransferFunction(k**2*(a2*s + p)**2*(s**2 + 2*s*wn*zeta + wn**2)**2 + (-a2*p + s)*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2) + (a2*p - s)*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2),
+        (a2*s + p)**2*(s**2 + 2*s*wn*zeta + wn**2)**2, s),))))
+
+    # doit() should not cancel poles and zeros.
+    mat_1 = Matrix([[1/(1+s), (1+s)/(1+s**2+2*s)**3]])
+    mat_2 = Matrix([[(1+s)], [(1+s**2+2*s)**3/(1+s)]])
+    tm_1, tm_2 = TransferFunctionMatrix.from_Matrix(mat_1, s), TransferFunctionMatrix.from_Matrix(mat_2, s)
+    assert (MIMOSeries(tm_2, tm_1).doit()
+        == TransferFunctionMatrix(((TransferFunction(2*(s + 1)**2*(s**2 + 2*s + 1)**3, (s + 1)**2*(s**2 + 2*s + 1)**3, s),),)))
+    assert MIMOSeries(tm_2, tm_1).doit().simplify() == TransferFunctionMatrix(((TransferFunction(2, 1, s),),))
+
+    # calling doit() will expand the internal Series and Parallel objects.
+    assert (MIMOSeries(-tfm3, -tfm2, tfm1, evaluate=True)
+        == MIMOSeries(-tfm3, -tfm2, tfm1).doit()
+        == TransferFunctionMatrix(((TransferFunction(k**2*(a2*s + p)**2*(s**2 + 2*s*wn*zeta + wn**2)**2 + (a2*p - s)**2*(s**2 + 2*s*wn*zeta + wn**2)**2 + (a2*s + p)**2,
+        (a2*s + p)**2*(s**2 + 2*s*wn*zeta + wn**2)**3, s),),
+        (TransferFunction(-k**2*(a2*s + p)**2*(s**2 + 2*s*wn*zeta + wn**2)**2 + (-a2*p + s)*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2) + (a2*p - s)*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2),
+        (a2*s + p)**2*(s**2 + 2*s*wn*zeta + wn**2)**3, s),))))
+    assert (MIMOSeries(MIMOParallel(tfm4, tfm5), tfm5, evaluate=True)
+        == MIMOSeries(MIMOParallel(tfm4, tfm5), tfm5).doit()
+        == TransferFunctionMatrix(((TransferFunction(-k*(-a2*s - p + (-a2*p + s)*(s**2 + 2*s*wn*zeta + wn**2)), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s), TransferFunction(k*(-a2*p - \
+            k*(a2*s + p) + s), a2*s + p, s)), (TransferFunction(-k*(-a2*s - p + (-a2*p + s)*(s**2 + 2*s*wn*zeta + wn**2)), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s), \
+            TransferFunction((-a2*p + s)*(-a2*p - k*(a2*s + p) + s), (a2*s + p)**2, s)))) == MIMOSeries(MIMOParallel(tfm4, tfm5), tfm5).rewrite(TransferFunctionMatrix))
+
+
+def test_Parallel_construction():
+    tf = TransferFunction(a0*s**3 + a1*s**2 - a2*s, b0*p**4 + b1*p**3 - b2*s*p, s)
+    tf2 = TransferFunction(a2*p - s, a2*s + p, s)
+    tf3 = TransferFunction(a0*p + p**a1 - s, p, p)
+    tf4 = TransferFunction(1, s**2 + 2*zeta*wn*s + wn**2, s)
+    inp = Function('X_d')(s)
+    out = Function('X')(s)
+
+    p0 = Parallel(tf, tf2)
+    assert p0.args == (tf, tf2)
+    assert p0.var == s
+
+    p1 = Parallel(Series(tf, -tf2), tf2)
+    assert p1.args == (Series(tf, -tf2), tf2)
+    assert p1.var == s
+
+    tf3_ = TransferFunction(inp, 1, s)
+    tf4_ = TransferFunction(-out, 1, s)
+    p2 = Parallel(tf, Series(tf3_, -tf4_), tf2)
+    assert p2.args == (tf, Series(tf3_, -tf4_), tf2)
+
+    p3 = Parallel(tf, tf2, tf4)
+    assert p3.args == (tf, tf2, tf4)
+
+    p4 = Parallel(tf3_, tf4_)
+    assert p4.args == (tf3_, tf4_)
+    assert p4.var == s
+
+    p5 = Parallel(tf, tf2)
+    assert p0 == p5
+    assert not p0 == p1
+
+    p6 = Parallel(tf2, tf4, Series(tf2, -tf4))
+    assert p6.args == (tf2, tf4, Series(tf2, -tf4))
+
+    p7 = Parallel(tf2, tf4, Series(tf2, -tf), tf4)
+    assert p7.args == (tf2, tf4, Series(tf2, -tf), tf4)
+
+    raises(ValueError, lambda: Parallel(tf, tf3))
+    raises(ValueError, lambda: Parallel(tf, tf2, tf3, tf4))
+    raises(ValueError, lambda: Parallel(-tf3, tf4))
+    raises(TypeError, lambda: Parallel(2, tf, tf4))
+    raises(TypeError, lambda: Parallel(s**2 + p*s, tf3, tf2))
+    raises(TypeError, lambda: Parallel(tf3, Matrix([1, 2, 3, 4])))
+
+
+def test_MIMOParallel_construction():
+    tfm1 = TransferFunctionMatrix([[TF1], [TF2], [TF3]])
+    tfm2 = TransferFunctionMatrix([[-TF3], [TF2], [TF1]])
+    tfm3 = TransferFunctionMatrix([[TF1]])
+    tfm4 = TransferFunctionMatrix([[TF2], [TF1], [TF3]])
+    tfm5 = TransferFunctionMatrix([[TF1, TF2], [TF2, TF1]])
+    tfm6 = TransferFunctionMatrix([[TF2, TF1], [TF1, TF2]])
+    tfm7 = TransferFunctionMatrix.from_Matrix(Matrix([[1/p]]), p)
+
+    p8 = MIMOParallel(tfm1, tfm2)
+    assert p8.args == (tfm1, tfm2)
+    assert p8.var == s
+    assert p8.shape == (p8.num_outputs, p8.num_inputs) == (3, 1)
+
+    p9 = MIMOParallel(MIMOSeries(tfm3, tfm1), tfm2)
+    assert p9.args == (MIMOSeries(tfm3, tfm1), tfm2)
+    assert p9.var == s
+    assert p9.shape == (p9.num_outputs, p9.num_inputs) == (3, 1)
+
+    p10 = MIMOParallel(tfm1, MIMOSeries(tfm3, tfm4), tfm2)
+    assert p10.args == (tfm1, MIMOSeries(tfm3, tfm4), tfm2)
+    assert p10.var == s
+    assert p10.shape == (p10.num_outputs, p10.num_inputs) == (3, 1)
+
+    p11 = MIMOParallel(tfm2, tfm1, tfm4)
+    assert p11.args == (tfm2, tfm1, tfm4)
+    assert p11.shape == (p11.num_outputs, p11.num_inputs) == (3, 1)
+
+    p12 = MIMOParallel(tfm6, tfm5)
+    assert p12.args == (tfm6, tfm5)
+    assert p12.shape == (p12.num_outputs, p12.num_inputs) == (2, 2)
+
+    p13 = MIMOParallel(tfm2, tfm4, MIMOSeries(-tfm3, tfm4), -tfm4)
+    assert p13.args == (tfm2, tfm4, MIMOSeries(-tfm3, tfm4), -tfm4)
+    assert p13.shape == (p13.num_outputs, p13.num_inputs) == (3, 1)
+
+    # arg cannot be empty tuple.
+    raises(TypeError, lambda: MIMOParallel(()))
+
+    # arg cannot contain SISO as well as MIMO systems.
+    raises(TypeError, lambda: MIMOParallel(tfm1, tfm2, TF1))
+
+    # all TFMs must have same shapes.
+    raises(TypeError, lambda: MIMOParallel(tfm1, tfm3, tfm4))
+
+    # all TFMs must be using the same complex variable.
+    raises(ValueError, lambda: MIMOParallel(tfm3, tfm7))
+
+    # Number or expression not allowed in the arguments.
+    raises(TypeError, lambda: MIMOParallel(2, tfm1, tfm4))
+    raises(TypeError, lambda: MIMOParallel(s**2 + p*s, -tfm4, tfm2))
+
+
+def test_Parallel_functions():
+    tf1 = TransferFunction(1, s**2 + 2*zeta*wn*s + wn**2, s)
+    tf2 = TransferFunction(k, 1, s)
+    tf3 = TransferFunction(a2*p - s, a2*s + p, s)
+    tf4 = TransferFunction(a0*p + p**a1 - s, p, p)
+    tf5 = TransferFunction(a1*s**2 + a2*s - a0, s + a0, s)
+
+    assert tf1 + tf2 + tf3 == Parallel(tf1, tf2, tf3)
+    assert tf1 + tf2 + tf3 + tf5 == Parallel(tf1, tf2, tf3, tf5)
+    assert tf1 + tf2 - tf3 - tf5 == Parallel(tf1, tf2, -tf3, -tf5)
+    assert tf1 + tf2*tf3 == Parallel(tf1, Series(tf2, tf3))
+    assert tf1 - tf2*tf3 == Parallel(tf1, -Series(tf2,tf3))
+    assert -tf1 - tf2 == Parallel(-tf1, -tf2)
+    assert -(tf1 + tf2) == Series(TransferFunction(-1, 1, s), Parallel(tf1, tf2))
+    assert (tf2 + tf3)*tf1 == Series(Parallel(tf2, tf3), tf1)
+    assert (tf1 + tf2)*(tf3*tf5) == Series(Parallel(tf1, tf2), tf3, tf5)
+    assert -(tf2 + tf3)*-tf5 == Series(TransferFunction(-1, 1, s), Parallel(tf2, tf3), -tf5)
+    assert tf2 + tf3 + tf2*tf1 + tf5 == Parallel(tf2, tf3, Series(tf2, tf1), tf5)
+    assert tf2 + tf3 + tf2*tf1 - tf3 == Parallel(tf2, tf3, Series(tf2, tf1), -tf3)
+    assert (tf1 + tf2 + tf5)*(tf3 + tf5) == Series(Parallel(tf1, tf2, tf5), Parallel(tf3, tf5))
+    raises(ValueError, lambda: tf1 + tf2 + tf4)
+    raises(ValueError, lambda: tf1 - tf2*tf4)
+    raises(ValueError, lambda: tf3 + Matrix([1, 2, 3]))
+
+    # evaluate=True -> doit()
+    assert Parallel(tf1, tf2, evaluate=True) == Parallel(tf1, tf2).doit() == \
+        TransferFunction(k*(s**2 + 2*s*wn*zeta + wn**2) + 1, s**2 + 2*s*wn*zeta + wn**2, s)
+    assert Parallel(tf1, tf2, Series(-tf1, tf3), evaluate=True) == \
+        Parallel(tf1, tf2, Series(-tf1, tf3)).doit() == TransferFunction(k*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2)**2 + \
+            (-a2*p + s)*(s**2 + 2*s*wn*zeta + wn**2) + (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), (a2*s + p)*(s**2 + \
+                2*s*wn*zeta + wn**2)**2, s)
+    assert Parallel(tf2, tf1, -tf3, evaluate=True) == Parallel(tf2, tf1, -tf3).doit() == \
+        TransferFunction(a2*s + k*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2) + p + (-a2*p + s)*(s**2 + 2*s*wn*zeta + wn**2) \
+            , (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert not Parallel(tf1, -tf2, evaluate=False) == Parallel(tf1, -tf2).doit()
+
+    assert Parallel(Series(tf1, tf2), Series(tf2, tf3)).doit() == \
+        TransferFunction(k*(a2*p - s)*(s**2 + 2*s*wn*zeta + wn**2) + k*(a2*s + p), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert Parallel(-tf1, -tf2, -tf3).doit() == \
+        TransferFunction(-a2*s - k*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2) - p + (-a2*p + s)*(s**2 + 2*s*wn*zeta + wn**2), \
+            (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert -Parallel(tf1, tf2, tf3).doit() == \
+        TransferFunction(-a2*s - k*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2) - p - (a2*p - s)*(s**2 + 2*s*wn*zeta + wn**2), \
+            (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert Parallel(tf2, tf3, Series(tf2, -tf1), tf3).doit() == \
+        TransferFunction(k*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2) - k*(a2*s + p) + (2*a2*p - 2*s)*(s**2 + 2*s*wn*zeta \
+            + wn**2), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+
+    assert Parallel(tf1, tf2).rewrite(TransferFunction) == \
+        TransferFunction(k*(s**2 + 2*s*wn*zeta + wn**2) + 1, s**2 + 2*s*wn*zeta + wn**2, s)
+    assert Parallel(tf2, tf1, -tf3).rewrite(TransferFunction) == \
+        TransferFunction(a2*s + k*(a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2) + p + (-a2*p + s)*(s**2 + 2*s*wn*zeta + \
+             wn**2), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+
+    assert Parallel(tf1, Parallel(tf2, tf3)) == Parallel(tf1, tf2, tf3) == Parallel(Parallel(tf1, tf2), tf3)
+
+    P1 = Parallel(Series(tf1, tf2), Series(tf2, tf3))
+    assert P1.is_proper
+    assert not P1.is_strictly_proper
+    assert P1.is_biproper
+
+    P2 = Parallel(tf1, -tf2, -tf3)
+    assert P2.is_proper
+    assert not P2.is_strictly_proper
+    assert P2.is_biproper
+
+    P3 = Parallel(tf1, -tf2, Series(tf1, tf3))
+    assert P3.is_proper
+    assert not P3.is_strictly_proper
+    assert P3.is_biproper
+
+
+def test_MIMOParallel_functions():
+    tf4 = TransferFunction(a0*p + p**a1 - s, p, p)
+    tf5 = TransferFunction(a1*s**2 + a2*s - a0, s + a0, s)
+
+    tfm1 = TransferFunctionMatrix([[TF1], [TF2], [TF3]])
+    tfm2 = TransferFunctionMatrix([[-TF2], [tf5], [-TF1]])
+    tfm3 = TransferFunctionMatrix([[tf5], [-tf5], [TF2]])
+    tfm4 = TransferFunctionMatrix([[TF2, -tf5], [TF1, tf5]])
+    tfm5 = TransferFunctionMatrix([[TF1, TF2], [TF3, -tf5]])
+    tfm6 = TransferFunctionMatrix([[-TF2]])
+    tfm7 = TransferFunctionMatrix([[tf4], [-tf4], [tf4]])
+
+    assert tfm1 + tfm2 + tfm3 == MIMOParallel(tfm1, tfm2, tfm3) == MIMOParallel(MIMOParallel(tfm1, tfm2), tfm3)
+    assert tfm2 - tfm1 - tfm3 == MIMOParallel(tfm2, -tfm1, -tfm3)
+    assert tfm2 - tfm3 + (-tfm1*tfm6*-tfm6) == MIMOParallel(tfm2, -tfm3, MIMOSeries(-tfm6, tfm6, -tfm1))
+    assert tfm1 + tfm1 - (-tfm1*tfm6) == MIMOParallel(tfm1, tfm1, -MIMOSeries(tfm6, -tfm1))
+    assert tfm2 - tfm3 - tfm1 + tfm2 == MIMOParallel(tfm2, -tfm3, -tfm1, tfm2)
+    assert tfm1 + tfm2 - tfm3 - tfm1 == MIMOParallel(tfm1, tfm2, -tfm3, -tfm1)
+    raises(ValueError, lambda: tfm1 + tfm2 + TF2)
+    raises(TypeError, lambda: tfm1 - tfm2 - a1)
+    raises(TypeError, lambda: tfm2 - tfm3 - (s - 1))
+    raises(TypeError, lambda: -tfm3 - tfm2 - 9)
+    raises(TypeError, lambda: (1 - p**3) - tfm3 - tfm2)
+    # All TFMs must use the same complex var. tfm7 uses 'p'.
+    raises(ValueError, lambda: tfm3 - tfm2 - tfm7)
+    raises(ValueError, lambda: tfm2 - tfm1 + tfm7)
+    # (tfm1 +/- tfm2) has (3, 1) shape while tfm4 has (2, 2) shape.
+    raises(TypeError, lambda: tfm1 + tfm2 + tfm4)
+    raises(TypeError, lambda: (tfm1 - tfm2) - tfm4)
+
+    assert (tfm1 + tfm2)*tfm6 == MIMOSeries(tfm6, MIMOParallel(tfm1, tfm2))
+    assert (tfm2 - tfm3)*tfm6*-tfm6 == MIMOSeries(-tfm6, tfm6, MIMOParallel(tfm2, -tfm3))
+    assert (tfm2 - tfm1 - tfm3)*(tfm6 + tfm6) == MIMOSeries(MIMOParallel(tfm6, tfm6), MIMOParallel(tfm2, -tfm1, -tfm3))
+    raises(ValueError, lambda: (tfm4 + tfm5)*TF1)
+    raises(TypeError, lambda: (tfm2 - tfm3)*a2)
+    raises(TypeError, lambda: (tfm3 + tfm2)*(s - 6))
+    raises(TypeError, lambda: (tfm1 + tfm2 + tfm3)*0)
+    raises(TypeError, lambda: (1 - p**3)*(tfm1 + tfm3))
+
+    # (tfm3 - tfm2) has (3, 1) shape while tfm4*tfm5 has (2, 2) shape.
+    raises(ValueError, lambda: (tfm3 - tfm2)*tfm4*tfm5)
+    # (tfm1 - tfm2) has (3, 1) shape while tfm5 has (2, 2) shape.
+    raises(ValueError, lambda: (tfm1 - tfm2)*tfm5)
+
+    # TFM in the arguments.
+    assert (MIMOParallel(tfm1, tfm2, evaluate=True) == MIMOParallel(tfm1, tfm2).doit()
+    == MIMOParallel(tfm1, tfm2).rewrite(TransferFunctionMatrix)
+    == TransferFunctionMatrix(((TransferFunction(-k*(s**2 + 2*s*wn*zeta + wn**2) + 1, s**2 + 2*s*wn*zeta + wn**2, s),), \
+        (TransferFunction(-a0 + a1*s**2 + a2*s + k*(a0 + s), a0 + s, s),), (TransferFunction(-a2*s - p + (a2*p - s)* \
+        (s**2 + 2*s*wn*zeta + wn**2), (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s),))))
+
+
+def test_Feedback_construction():
+    tf1 = TransferFunction(1, s**2 + 2*zeta*wn*s + wn**2, s)
+    tf2 = TransferFunction(k, 1, s)
+    tf3 = TransferFunction(a2*p - s, a2*s + p, s)
+    tf4 = TransferFunction(a0*p + p**a1 - s, p, p)
+    tf5 = TransferFunction(a1*s**2 + a2*s - a0, s + a0, s)
+    tf6 = TransferFunction(s - p, p + s, p)
+
+    f1 = Feedback(TransferFunction(1, 1, s), tf1*tf2*tf3)
+    assert f1.args == (TransferFunction(1, 1, s), Series(tf1, tf2, tf3), -1)
+    assert f1.sys1 == TransferFunction(1, 1, s)
+    assert f1.sys2 == Series(tf1, tf2, tf3)
+    assert f1.var == s
+
+    f2 = Feedback(tf1, tf2*tf3)
+    assert f2.args == (tf1, Series(tf2, tf3), -1)
+    assert f2.sys1 == tf1
+    assert f2.sys2 == Series(tf2, tf3)
+    assert f2.var == s
+
+    f3 = Feedback(tf1*tf2, tf5)
+    assert f3.args == (Series(tf1, tf2), tf5, -1)
+    assert f3.sys1 == Series(tf1, tf2)
+
+    f4 = Feedback(tf4, tf6)
+    assert f4.args == (tf4, tf6, -1)
+    assert f4.sys1 == tf4
+    assert f4.var == p
+
+    f5 = Feedback(tf5, TransferFunction(1, 1, s))
+    assert f5.args == (tf5, TransferFunction(1, 1, s), -1)
+    assert f5.var == s
+    assert f5 == Feedback(tf5)  # When sys2 is not passed explicitly, it is assumed to be unit tf.
+
+    f6 = Feedback(TransferFunction(1, 1, p), tf4)
+    assert f6.args == (TransferFunction(1, 1, p), tf4, -1)
+    assert f6.var == p
+
+    f7 = -Feedback(tf4*tf6, TransferFunction(1, 1, p))
+    assert f7.args == (Series(TransferFunction(-1, 1, p), Series(tf4, tf6)), -TransferFunction(1, 1, p), -1)
+    assert f7.sys1 == Series(TransferFunction(-1, 1, p), Series(tf4, tf6))
+
+    # denominator can't be a Parallel instance
+    raises(TypeError, lambda: Feedback(tf1, tf2 + tf3))
+    raises(TypeError, lambda: Feedback(tf1, Matrix([1, 2, 3])))
+    raises(TypeError, lambda: Feedback(TransferFunction(1, 1, s), s - 1))
+    raises(TypeError, lambda: Feedback(1, 1))
+    # raises(ValueError, lambda: Feedback(TransferFunction(1, 1, s), TransferFunction(1, 1, s)))
+    raises(ValueError, lambda: Feedback(tf2, tf4*tf5))
+    raises(ValueError, lambda: Feedback(tf2, tf1, 1.5))  # `sign` can only be -1 or 1
+    raises(ValueError, lambda: Feedback(tf1, -tf1**-1))  # denominator can't be zero
+    raises(ValueError, lambda: Feedback(tf4, tf5))  # Both systems should use the same `var`
+
+
+def test_Feedback_functions():
+    tf = TransferFunction(1, 1, s)
+    tf1 = TransferFunction(1, s**2 + 2*zeta*wn*s + wn**2, s)
+    tf2 = TransferFunction(k, 1, s)
+    tf3 = TransferFunction(a2*p - s, a2*s + p, s)
+    tf4 = TransferFunction(a0*p + p**a1 - s, p, p)
+    tf5 = TransferFunction(a1*s**2 + a2*s - a0, s + a0, s)
+    tf6 = TransferFunction(s - p, p + s, p)
+
+    assert tf / (tf + tf1) == Feedback(tf, tf1)
+    assert tf / (tf + tf1*tf2*tf3) == Feedback(tf, tf1*tf2*tf3)
+    assert tf1 / (tf + tf1*tf2*tf3) == Feedback(tf1, tf2*tf3)
+    assert (tf1*tf2) / (tf + tf1*tf2) == Feedback(tf1*tf2, tf)
+    assert (tf1*tf2) / (tf + tf1*tf2*tf5) == Feedback(tf1*tf2, tf5)
+    assert (tf1*tf2) / (tf + tf1*tf2*tf5*tf3) in (Feedback(tf1*tf2, tf5*tf3), Feedback(tf1*tf2, tf3*tf5))
+    assert tf4 / (TransferFunction(1, 1, p) + tf4*tf6) == Feedback(tf4, tf6)
+    assert tf5 / (tf + tf5) == Feedback(tf5, tf)
+
+    raises(TypeError, lambda: tf1*tf2*tf3 / (1 + tf1*tf2*tf3))
+    raises(ValueError, lambda: tf1*tf2*tf3 / tf3*tf5)
+    raises(ValueError, lambda: tf2*tf3 / (tf + tf2*tf3*tf4))
+
+    assert Feedback(tf, tf1*tf2*tf3).doit() == \
+        TransferFunction((a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), k*(a2*p - s) + \
+        (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert Feedback(tf, tf1*tf2*tf3).sensitivity == \
+        1/(k*(a2*p - s)/((a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2)) + 1)
+    assert Feedback(tf1, tf2*tf3).doit() == \
+        TransferFunction((a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2), (k*(a2*p - s) + \
+        (a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2))*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert Feedback(tf1, tf2*tf3).sensitivity == \
+        1/(k*(a2*p - s)/((a2*s + p)*(s**2 + 2*s*wn*zeta + wn**2)) + 1)
+    assert Feedback(tf1*tf2, tf5).doit() == \
+        TransferFunction(k*(a0 + s)*(s**2 + 2*s*wn*zeta + wn**2), (k*(-a0 + a1*s**2 + a2*s) + \
+        (a0 + s)*(s**2 + 2*s*wn*zeta + wn**2))*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert Feedback(tf1*tf2, tf5, 1).sensitivity == \
+        1/(-k*(-a0 + a1*s**2 + a2*s)/((a0 + s)*(s**2 + 2*s*wn*zeta + wn**2)) + 1)
+    assert Feedback(tf4, tf6).doit() == \
+        TransferFunction(p*(p + s)*(a0*p + p**a1 - s), p*(p*(p + s) + (-p + s)*(a0*p + p**a1 - s)), p)
+    assert -Feedback(tf4*tf6, TransferFunction(1, 1, p)).doit() == \
+        TransferFunction(-p*(-p + s)*(p + s)*(a0*p + p**a1 - s), p*(p + s)*(p*(p + s) + (-p + s)*(a0*p + p**a1 - s)), p)
+    assert Feedback(tf, tf).doit() == TransferFunction(1, 2, s)
+
+    assert Feedback(tf1, tf2*tf5).rewrite(TransferFunction) == \
+        TransferFunction((a0 + s)*(s**2 + 2*s*wn*zeta + wn**2), (k*(-a0 + a1*s**2 + a2*s) + \
+        (a0 + s)*(s**2 + 2*s*wn*zeta + wn**2))*(s**2 + 2*s*wn*zeta + wn**2), s)
+    assert Feedback(TransferFunction(1, 1, p), tf4).rewrite(TransferFunction) == \
+        TransferFunction(p, a0*p + p + p**a1 - s, p)
+
+
+def test_MIMOFeedback_construction():
+    tf1 = TransferFunction(1, s, s)
+    tf2 = TransferFunction(s, s**3 - 1, s)
+    tf3 = TransferFunction(s, s + 1, s)
+    tf4 = TransferFunction(s, s**2 + 1, s)
+
+    tfm_1 = TransferFunctionMatrix([[tf1, tf2], [tf3, tf4]])
+    tfm_2 = TransferFunctionMatrix([[tf2, tf3], [tf4, tf1]])
+    tfm_3 = TransferFunctionMatrix([[tf3, tf4], [tf1, tf2]])
+
+    f1 = MIMOFeedback(tfm_1, tfm_2)
+    assert f1.args == (tfm_1, tfm_2, -1)
+    assert f1.sys1 == tfm_1
+    assert f1.sys2 == tfm_2
+    assert f1.var == s
+    assert f1.sign == -1
+    assert -(-f1) == f1
+
+    f2 = MIMOFeedback(tfm_2, tfm_1, 1)
+    assert f2.args == (tfm_2, tfm_1, 1)
+    assert f2.sys1 == tfm_2
+    assert f2.sys2 == tfm_1
+    assert f2.var == s
+    assert f2.sign == 1
+
+    f3 = MIMOFeedback(tfm_1, MIMOSeries(tfm_3, tfm_2))
+    assert f3.args == (tfm_1, MIMOSeries(tfm_3, tfm_2), -1)
+    assert f3.sys1 == tfm_1
+    assert f3.sys2 == MIMOSeries(tfm_3, tfm_2)
+    assert f3.var == s
+    assert f3.sign == -1
+
+    mat = Matrix([[1, 1/s], [0, 1]])
+    sys1 = controller = TransferFunctionMatrix.from_Matrix(mat, s)
+    f4 = MIMOFeedback(sys1, controller)
+    assert f4.args == (sys1, controller, -1)
+    assert f4.sys1 == f4.sys2 == sys1
+
+
+def test_MIMOFeedback_errors():
+    tf1 = TransferFunction(1, s, s)
+    tf2 = TransferFunction(s, s**3 - 1, s)
+    tf3 = TransferFunction(s, s - 1, s)
+    tf4 = TransferFunction(s, s**2 + 1, s)
+    tf5 = TransferFunction(1, 1, s)
+    tf6 = TransferFunction(-1, s - 1, s)
+
+    tfm_1 = TransferFunctionMatrix([[tf1, tf2], [tf3, tf4]])
+    tfm_2 = TransferFunctionMatrix([[tf2, tf3], [tf4, tf1]])
+    tfm_3 = TransferFunctionMatrix.from_Matrix(eye(2), var=s)
+    tfm_4 = TransferFunctionMatrix([[tf1, tf5], [tf5, tf5]])
+    tfm_5 = TransferFunctionMatrix([[-tf3, tf3], [tf3, tf6]])
+    # tfm_4 is inverse of tfm_5. Therefore tfm_5*tfm_4 = I
+    tfm_6 = TransferFunctionMatrix([[-tf3]])
+    tfm_7 = TransferFunctionMatrix([[tf3, tf4]])
+
+    # Unsupported Types
+    raises(TypeError, lambda: MIMOFeedback(tf1, tf2))
+    raises(TypeError, lambda: MIMOFeedback(MIMOParallel(tfm_1, tfm_2), tfm_3))
+    # Shape Errors
+    raises(ValueError, lambda: MIMOFeedback(tfm_1, tfm_6, 1))
+    raises(ValueError, lambda: MIMOFeedback(tfm_7, tfm_7))
+    # sign not 1/-1
+    raises(ValueError, lambda: MIMOFeedback(tfm_1, tfm_2, -2))
+    # Non-Invertible Systems
+    raises(ValueError, lambda: MIMOFeedback(tfm_5, tfm_4, 1))
+    raises(ValueError, lambda: MIMOFeedback(tfm_4, -tfm_5))
+    raises(ValueError, lambda: MIMOFeedback(tfm_3, tfm_3, 1))
+    # Variable not same in both the systems
+    tfm_8 = TransferFunctionMatrix.from_Matrix(eye(2), var=p)
+    raises(ValueError, lambda: MIMOFeedback(tfm_1, tfm_8, 1))
+
+
+def test_MIMOFeedback_functions():
+    tf1 = TransferFunction(1, s, s)
+    tf2 = TransferFunction(s, s - 1, s)
+    tf3 = TransferFunction(1, 1, s)
+    tf4 = TransferFunction(-1, s - 1, s)
+
+    tfm_1 = TransferFunctionMatrix.from_Matrix(eye(2), var=s)
+    tfm_2 = TransferFunctionMatrix([[tf1, tf3], [tf3, tf3]])
+    tfm_3 = TransferFunctionMatrix([[-tf2, tf2], [tf2, tf4]])
+    tfm_4 = TransferFunctionMatrix([[tf1, tf2], [-tf2, tf1]])
+
+    # sensitivity, doit(), rewrite()
+    F_1 = MIMOFeedback(tfm_2, tfm_3)
+    F_2 = MIMOFeedback(tfm_2, MIMOSeries(tfm_4, -tfm_1), 1)
+
+    assert F_1.sensitivity == Matrix([[S.Half, 0], [0, S.Half]])
+    assert F_2.sensitivity == Matrix([[(-2*s**4 + s**2)/(s**2 - s + 1),
+        (2*s**3 - s**2)/(s**2 - s + 1)], [-s**2, s]])
+
+    assert F_1.doit() == \
+        TransferFunctionMatrix(((TransferFunction(1, 2*s, s),
+        TransferFunction(1, 2, s)), (TransferFunction(1, 2, s),
+        TransferFunction(1, 2, s)))) == F_1.rewrite(TransferFunctionMatrix)
+    assert F_2.doit(cancel=False, expand=True) == \
+        TransferFunctionMatrix(((TransferFunction(-s**5 + 2*s**4 - 2*s**3 + s**2, s**5 - 2*s**4 + 3*s**3 - 2*s**2 + s, s),
+        TransferFunction(-2*s**4 + 2*s**3, s**2 - s + 1, s)), (TransferFunction(0, 1, s), TransferFunction(-s**2 + s, 1, s))))
+    assert F_2.doit(cancel=False) == \
+        TransferFunctionMatrix(((TransferFunction(s*(2*s**3 - s**2)*(s**2 - s + 1) + \
+        (-2*s**4 + s**2)*(s**2 - s + 1), s*(s**2 - s + 1)**2, s), TransferFunction(-2*s**4 + 2*s**3, s**2 - s + 1, s)),
+        (TransferFunction(0, 1, s), TransferFunction(-s**2 + s, 1, s))))
+    assert F_2.doit() == \
+        TransferFunctionMatrix(((TransferFunction(s*(-2*s**2 + s*(2*s - 1) + 1), s**2 - s + 1, s),
+        TransferFunction(-2*s**3*(s - 1), s**2 - s + 1, s)), (TransferFunction(0, 1, s), TransferFunction(s*(1 - s), 1, s))))
+    assert F_2.doit(expand=True) == \
+        TransferFunctionMatrix(((TransferFunction(-s**2 + s, s**2 - s + 1, s), TransferFunction(-2*s**4 + 2*s**3, s**2 - s + 1, s)),
+        (TransferFunction(0, 1, s), TransferFunction(-s**2 + s, 1, s))))
+
+    assert -(F_1.doit()) == (-F_1).doit()  # First negating then calculating vs calculating then negating.
+
+
+def test_TransferFunctionMatrix_construction():
+    tf5 = TransferFunction(a1*s**2 + a2*s - a0, s + a0, s)
+    tf4 = TransferFunction(a0*p + p**a1 - s, p, p)
+
+    tfm3_ = TransferFunctionMatrix([[-TF3]])
+    assert tfm3_.shape == (tfm3_.num_outputs, tfm3_.num_inputs) == (1, 1)
+    assert tfm3_.args == Tuple(Tuple(Tuple(-TF3)))
+    assert tfm3_.var == s
+
+    tfm5 = TransferFunctionMatrix([[TF1, -TF2], [TF3, tf5]])
+    assert tfm5.shape == (tfm5.num_outputs, tfm5.num_inputs) == (2, 2)
+    assert tfm5.args == Tuple(Tuple(Tuple(TF1, -TF2), Tuple(TF3, tf5)))
+    assert tfm5.var == s
+
+    tfm7 = TransferFunctionMatrix([[TF1, TF2], [TF3, -tf5], [-tf5, TF2]])
+    assert tfm7.shape == (tfm7.num_outputs, tfm7.num_inputs) == (3, 2)
+    assert tfm7.args == Tuple(Tuple(Tuple(TF1, TF2), Tuple(TF3, -tf5), Tuple(-tf5, TF2)))
+    assert tfm7.var == s
+
+    # all transfer functions will use the same complex variable. tf4 uses 'p'.
+    raises(ValueError, lambda: TransferFunctionMatrix([[TF1], [TF2], [tf4]]))
+    raises(ValueError, lambda: TransferFunctionMatrix([[TF1, tf4], [TF3, tf5]]))
+
+    # length of all the lists in the TFM should be equal.
+    raises(ValueError, lambda: TransferFunctionMatrix([[TF1], [TF3, tf5]]))
+    raises(ValueError, lambda: TransferFunctionMatrix([[TF1, TF3], [tf5]]))
+
+    # lists should only support transfer functions in them.
+    raises(TypeError, lambda: TransferFunctionMatrix([[TF1, TF2], [TF3, Matrix([1, 2])]]))
+    raises(TypeError, lambda: TransferFunctionMatrix([[TF1, Matrix([1, 2])], [TF3, TF2]]))
+
+    # `arg` should strictly be nested list of TransferFunction
+    raises(ValueError, lambda: TransferFunctionMatrix([TF1, TF2, tf5]))
+    raises(ValueError, lambda: TransferFunctionMatrix([TF1]))
+
+def test_TransferFunctionMatrix_functions():
+    tf5 = TransferFunction(a1*s**2 + a2*s - a0, s + a0, s)
+
+    #  Classmethod (from_matrix)
+
+    mat_1 = ImmutableMatrix([
+        [s*(s + 1)*(s - 3)/(s**4 + 1), 2],
+        [p, p*(s + 1)/(s*(s**1 + 1))]
+        ])
+    mat_2 = ImmutableMatrix([[(2*s + 1)/(s**2 - 9)]])
+    mat_3 = ImmutableMatrix([[1, 2], [3, 4]])
+    assert TransferFunctionMatrix.from_Matrix(mat_1, s) == \
+        TransferFunctionMatrix([[TransferFunction(s*(s - 3)*(s + 1), s**4 + 1, s), TransferFunction(2, 1, s)],
+        [TransferFunction(p, 1, s), TransferFunction(p, s, s)]])
+    assert TransferFunctionMatrix.from_Matrix(mat_2, s) == \
+        TransferFunctionMatrix([[TransferFunction(2*s + 1, s**2 - 9, s)]])
+    assert TransferFunctionMatrix.from_Matrix(mat_3, p) == \
+        TransferFunctionMatrix([[TransferFunction(1, 1, p), TransferFunction(2, 1, p)],
+        [TransferFunction(3, 1, p), TransferFunction(4, 1, p)]])
+
+    #  Negating a TFM
+
+    tfm1 = TransferFunctionMatrix([[TF1], [TF2]])
+    assert -tfm1 == TransferFunctionMatrix([[-TF1], [-TF2]])
+
+    tfm2 = TransferFunctionMatrix([[TF1, TF2, TF3], [tf5, -TF1, -TF3]])
+    assert -tfm2 == TransferFunctionMatrix([[-TF1, -TF2, -TF3], [-tf5, TF1, TF3]])
+
+    # subs()
+
+    H_1 = TransferFunctionMatrix.from_Matrix(mat_1, s)
+    H_2 = TransferFunctionMatrix([[TransferFunction(a*p*s, k*s**2, s), TransferFunction(p*s, k*(s**2 - a), s)]])
+    assert H_1.subs(p, 1) == TransferFunctionMatrix([[TransferFunction(s*(s - 3)*(s + 1), s**4 + 1, s), TransferFunction(2, 1, s)], [TransferFunction(1, 1, s), TransferFunction(1, s, s)]])
+    assert H_1.subs({p: 1}) == TransferFunctionMatrix([[TransferFunction(s*(s - 3)*(s + 1), s**4 + 1, s), TransferFunction(2, 1, s)], [TransferFunction(1, 1, s), TransferFunction(1, s, s)]])
+    assert H_1.subs({p: 1, s: 1}) == TransferFunctionMatrix([[TransferFunction(s*(s - 3)*(s + 1), s**4 + 1, s), TransferFunction(2, 1, s)], [TransferFunction(1, 1, s), TransferFunction(1, s, s)]]) # This should ignore `s` as it is `var`
+    assert H_2.subs(p, 2) == TransferFunctionMatrix([[TransferFunction(2*a*s, k*s**2, s), TransferFunction(2*s, k*(-a + s**2), s)]])
+    assert H_2.subs(k, 1) == TransferFunctionMatrix([[TransferFunction(a*p*s, s**2, s), TransferFunction(p*s, -a + s**2, s)]])
+    assert H_2.subs(a, 0) == TransferFunctionMatrix([[TransferFunction(0, k*s**2, s), TransferFunction(p*s, k*s**2, s)]])
+    assert H_2.subs({p: 1, k: 1, a: a0}) == TransferFunctionMatrix([[TransferFunction(a0*s, s**2, s), TransferFunction(s, -a0 + s**2, s)]])
+
+    # transpose()
+
+    assert H_1.transpose() == TransferFunctionMatrix([[TransferFunction(s*(s - 3)*(s + 1), s**4 + 1, s), TransferFunction(p, 1, s)], [TransferFunction(2, 1, s), TransferFunction(p, s, s)]])
+    assert H_2.transpose() == TransferFunctionMatrix([[TransferFunction(a*p*s, k*s**2, s)], [TransferFunction(p*s, k*(-a + s**2), s)]])
+    assert H_1.transpose().transpose() == H_1
+    assert H_2.transpose().transpose() == H_2
+
+    # elem_poles()
+
+    assert H_1.elem_poles() == [[[-sqrt(2)/2 - sqrt(2)*I/2, -sqrt(2)/2 + sqrt(2)*I/2, sqrt(2)/2 - sqrt(2)*I/2, sqrt(2)/2 + sqrt(2)*I/2], []],
+        [[], [0]]]
+    assert H_2.elem_poles() == [[[0, 0], [sqrt(a), -sqrt(a)]]]
+    assert tfm2.elem_poles() == [[[wn*(-zeta + sqrt((zeta - 1)*(zeta + 1))), wn*(-zeta - sqrt((zeta - 1)*(zeta + 1)))], [], [-p/a2]],
+        [[-a0], [wn*(-zeta + sqrt((zeta - 1)*(zeta + 1))), wn*(-zeta - sqrt((zeta - 1)*(zeta + 1)))], [-p/a2]]]
+
+    # elem_zeros()
+
+    assert H_1.elem_zeros() == [[[-1, 0, 3], []], [[], []]]
+    assert H_2.elem_zeros() == [[[0], [0]]]
+    assert tfm2.elem_zeros() == [[[], [], [a2*p]],
+        [[-a2/(2*a1) - sqrt(4*a0*a1 + a2**2)/(2*a1), -a2/(2*a1) + sqrt(4*a0*a1 + a2**2)/(2*a1)], [], [a2*p]]]
+
+    # doit()
+
+    H_3 = TransferFunctionMatrix([[Series(TransferFunction(1, s**3 - 3, s), TransferFunction(s**2 - 2*s + 5, 1, s), TransferFunction(1, s, s))]])
+    H_4 = TransferFunctionMatrix([[Parallel(TransferFunction(s**3 - 3, 4*s**4 - s**2 - 2*s + 5, s), TransferFunction(4 - s**3, 4*s**4 - s**2 - 2*s + 5, s))]])
+
+    assert H_3.doit() == TransferFunctionMatrix([[TransferFunction(s**2 - 2*s + 5, s*(s**3 - 3), s)]])
+    assert H_4.doit() == TransferFunctionMatrix([[TransferFunction(1, 4*s**4 - s**2 - 2*s + 5, s)]])
+
+    # _flat()
+
+    assert H_1._flat() == [TransferFunction(s*(s - 3)*(s + 1), s**4 + 1, s), TransferFunction(2, 1, s), TransferFunction(p, 1, s), TransferFunction(p, s, s)]
+    assert H_2._flat() == [TransferFunction(a*p*s, k*s**2, s), TransferFunction(p*s, k*(-a + s**2), s)]
+    assert H_3._flat() == [Series(TransferFunction(1, s**3 - 3, s), TransferFunction(s**2 - 2*s + 5, 1, s), TransferFunction(1, s, s))]
+    assert H_4._flat() == [Parallel(TransferFunction(s**3 - 3, 4*s**4 - s**2 - 2*s + 5, s), TransferFunction(4 - s**3, 4*s**4 - s**2 - 2*s + 5, s))]
+
+    # evalf()
+
+    assert H_1.evalf() == \
+        TransferFunctionMatrix(((TransferFunction(s*(s - 3.0)*(s + 1.0), s**4 + 1.0, s), TransferFunction(2.0, 1, s)), (TransferFunction(1.0*p, 1, s), TransferFunction(p, s, s))))
+    assert H_2.subs({a:3.141, p:2.88, k:2}).evalf() == \
+        TransferFunctionMatrix(((TransferFunction(4.5230399999999999494093572138808667659759521484375, s, s),
+        TransferFunction(2.87999999999999989341858963598497211933135986328125*s, 2.0*s**2 - 6.282000000000000028421709430404007434844970703125, s)),))
+
+    # simplify()
+
+    H_5 = TransferFunctionMatrix([[TransferFunction(s**5 + s**3 + s, s - s**2, s),
+        TransferFunction((s + 3)*(s - 1), (s - 1)*(s + 5), s)]])
+
+    assert H_5.simplify() == simplify(H_5) == \
+        TransferFunctionMatrix(((TransferFunction(-s**4 - s**2 - 1, s - 1, s), TransferFunction(s + 3, s + 5, s)),))
+
+    # expand()
+
+    assert (H_1.expand()
+            == TransferFunctionMatrix(((TransferFunction(s**3 - 2*s**2 - 3*s, s**4 + 1, s), TransferFunction(2, 1, s)),
+            (TransferFunction(p, 1, s), TransferFunction(p, s, s)))))
+    assert H_5.expand() == \
+        TransferFunctionMatrix(((TransferFunction(s**5 + s**3 + s, -s**2 + s, s), TransferFunction(s**2 + 2*s - 3, s**2 + 4*s - 5, s)),))
+
+def test_TransferFunction_bilinear():
+    # simple transfer function, e.g. ohms law
+    tf = TransferFunction(1, a*s+b, s)
+    numZ, denZ = bilinear(tf, T)
+    # discretized transfer function with coefs from tf.bilinear()
+    tf_test_bilinear = TransferFunction(s*numZ[0]+numZ[1], s*denZ[0]+denZ[1], s)
+    # corresponding tf with manually calculated coefs
+    tf_test_manual = TransferFunction(s*T+T, s*(T*b+2*a)+T*b-2*a, s)
+
+    assert S.Zero == (tf_test_bilinear-tf_test_manual).simplify().num
+
+def test_TransferFunction_backward_diff():
+    # simple transfer function, e.g. ohms law
+    tf = TransferFunction(1, a*s+b, s)
+    numZ, denZ = backward_diff(tf, T)
+    # discretized transfer function with coefs from tf.bilinear()
+    tf_test_bilinear = TransferFunction(s*numZ[0]+numZ[1], s*denZ[0]+denZ[1], s)
+    # corresponding tf with manually calculated coefs
+    tf_test_manual = TransferFunction(s*T, s*(T*b+a)-a, s)
+
+    assert S.Zero == (tf_test_bilinear-tf_test_manual).simplify().num