Add files using upload-large-folder tool

.gitattributes

@@ -186,3 +186,4 @@ env-llmeval/lib/python3.10/site-packages/pyarrow/libarrow_substrait.so.1500 filt
 env-llmeval/lib/python3.10/site-packages/pyarrow/lib.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 env-llmeval/lib/python3.10/site-packages/pyarrow/libarrow_flight.so.1500 filter=lfs diff=lfs merge=lfs -text
 llmeval-env/lib/python3.10/site-packages/scipy/stats/_unuran/unuran_wrapper.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+llmeval-env/lib/python3.10/site-packages/nvidia/cudnn/lib/libcudnn_adv_infer.so.8 filter=lfs diff=lfs merge=lfs -text

llmeval-env/lib/python3.10/site-packages/nvidia/cudnn/lib/libcudnn_adv_infer.so.8

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

llmeval-env/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']

llmeval-env/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

llmeval-env/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)

llmeval-env/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

llmeval-env/lib/python3.10/site-packages/sympy/physics/hep/tests/test_gamma_matrices.py

@@ -0,0 +1,427 @@
+from sympy.matrices.dense import eye, Matrix
+from sympy.tensor.tensor import tensor_indices, TensorHead, tensor_heads, \
+    TensExpr, canon_bp
+from sympy.physics.hep.gamma_matrices import GammaMatrix as G, LorentzIndex, \
+    kahane_simplify, gamma_trace, _simplify_single_line, simplify_gamma_expression
+from sympy import Symbol
+
+
+def _is_tensor_eq(arg1, arg2):
+    arg1 = canon_bp(arg1)
+    arg2 = canon_bp(arg2)
+    if isinstance(arg1, TensExpr):
+        return arg1.equals(arg2)
+    elif isinstance(arg2, TensExpr):
+        return arg2.equals(arg1)
+    return arg1 == arg2
+
+def execute_gamma_simplify_tests_for_function(tfunc, D):
+    """
+    Perform tests to check if sfunc is able to simplify gamma matrix expressions.
+
+    Parameters
+    ==========
+
+    `sfunc`     a function to simplify a `TIDS`, shall return the simplified `TIDS`.
+    `D`         the number of dimension (in most cases `D=4`).
+
+    """
+
+    mu, nu, rho, sigma = tensor_indices("mu, nu, rho, sigma", LorentzIndex)
+    a1, a2, a3, a4, a5, a6 = tensor_indices("a1:7", LorentzIndex)
+    mu11, mu12, mu21, mu31, mu32, mu41, mu51, mu52 = tensor_indices("mu11, mu12, mu21, mu31, mu32, mu41, mu51, mu52", LorentzIndex)
+    mu61, mu71, mu72 = tensor_indices("mu61, mu71, mu72", LorentzIndex)
+    m0, m1, m2, m3, m4, m5, m6 = tensor_indices("m0:7", LorentzIndex)
+
+    def g(xx, yy):
+        return (G(xx)*G(yy) + G(yy)*G(xx))/2
+
+    # Some examples taken from Kahane's paper, 4 dim only:
+    if D == 4:
+        t = (G(a1)*G(mu11)*G(a2)*G(mu21)*G(-a1)*G(mu31)*G(-a2))
+        assert _is_tensor_eq(tfunc(t), -4*G(mu11)*G(mu31)*G(mu21) - 4*G(mu31)*G(mu11)*G(mu21))
+
+        t = (G(a1)*G(mu11)*G(mu12)*\
+                              G(a2)*G(mu21)*\
+                              G(a3)*G(mu31)*G(mu32)*\
+                              G(a4)*G(mu41)*\
+                              G(-a2)*G(mu51)*G(mu52)*\
+                              G(-a1)*G(mu61)*\
+                              G(-a3)*G(mu71)*G(mu72)*\
+                              G(-a4))
+        assert _is_tensor_eq(tfunc(t), \
+            16*G(mu31)*G(mu32)*G(mu72)*G(mu71)*G(mu11)*G(mu52)*G(mu51)*G(mu12)*G(mu61)*G(mu21)*G(mu41) + 16*G(mu31)*G(mu32)*G(mu72)*G(mu71)*G(mu12)*G(mu51)*G(mu52)*G(mu11)*G(mu61)*G(mu21)*G(mu41) + 16*G(mu71)*G(mu72)*G(mu32)*G(mu31)*G(mu11)*G(mu52)*G(mu51)*G(mu12)*G(mu61)*G(mu21)*G(mu41) + 16*G(mu71)*G(mu72)*G(mu32)*G(mu31)*G(mu12)*G(mu51)*G(mu52)*G(mu11)*G(mu61)*G(mu21)*G(mu41))
+
+    # Fully Lorentz-contracted expressions, these return scalars:
+
+    def add_delta(ne):
+        return ne * eye(4)  # DiracSpinorIndex.delta(DiracSpinorIndex.auto_left, -DiracSpinorIndex.auto_right)
+
+    t = (G(mu)*G(-mu))
+    ts = add_delta(D)
+    assert _is_tensor_eq(tfunc(t), ts)
+
+    t = (G(mu)*G(nu)*G(-mu)*G(-nu))
+    ts = add_delta(2*D - D**2)  # -8
+    assert _is_tensor_eq(tfunc(t), ts)
+
+    t = (G(mu)*G(nu)*G(-nu)*G(-mu))
+    ts = add_delta(D**2)  # 16
+    assert _is_tensor_eq(tfunc(t), ts)
+
+    t = (G(mu)*G(nu)*G(-rho)*G(-nu)*G(-mu)*G(rho))
+    ts = add_delta(4*D - 4*D**2 + D**3)  # 16
+    assert _is_tensor_eq(tfunc(t), ts)
+
+    t = (G(mu)*G(nu)*G(rho)*G(-rho)*G(-nu)*G(-mu))
+    ts = add_delta(D**3)  # 64
+    assert _is_tensor_eq(tfunc(t), ts)
+
+    t = (G(a1)*G(a2)*G(a3)*G(a4)*G(-a3)*G(-a1)*G(-a2)*G(-a4))
+    ts = add_delta(-8*D + 16*D**2 - 8*D**3 + D**4)  # -32
+    assert _is_tensor_eq(tfunc(t), ts)
+
+    t = (G(-mu)*G(-nu)*G(-rho)*G(-sigma)*G(nu)*G(mu)*G(sigma)*G(rho))
+    ts = add_delta(-16*D + 24*D**2 - 8*D**3 + D**4)  # 64
+    assert _is_tensor_eq(tfunc(t), ts)
+
+    t = (G(-mu)*G(nu)*G(-rho)*G(sigma)*G(rho)*G(-nu)*G(mu)*G(-sigma))
+    ts = add_delta(8*D - 12*D**2 + 6*D**3 - D**4)  # -32
+    assert _is_tensor_eq(tfunc(t), ts)
+
+    t = (G(a1)*G(a2)*G(a3)*G(a4)*G(a5)*G(-a3)*G(-a2)*G(-a1)*G(-a5)*G(-a4))
+    ts = add_delta(64*D - 112*D**2 + 60*D**3 - 12*D**4 + D**5)  # 256
+    assert _is_tensor_eq(tfunc(t), ts)
+
+    t = (G(a1)*G(a2)*G(a3)*G(a4)*G(a5)*G(-a3)*G(-a1)*G(-a2)*G(-a4)*G(-a5))
+    ts = add_delta(64*D - 120*D**2 + 72*D**3 - 16*D**4 + D**5)  # -128
+    assert _is_tensor_eq(tfunc(t), ts)
+
+    t = (G(a1)*G(a2)*G(a3)*G(a4)*G(a5)*G(a6)*G(-a3)*G(-a2)*G(-a1)*G(-a6)*G(-a5)*G(-a4))
+    ts = add_delta(416*D - 816*D**2 + 528*D**3 - 144*D**4 + 18*D**5 - D**6)  # -128
+    assert _is_tensor_eq(tfunc(t), ts)
+
+    t = (G(a1)*G(a2)*G(a3)*G(a4)*G(a5)*G(a6)*G(-a2)*G(-a3)*G(-a1)*G(-a6)*G(-a4)*G(-a5))
+    ts = add_delta(416*D - 848*D**2 + 584*D**3 - 172*D**4 + 22*D**5 - D**6)  # -128
+    assert _is_tensor_eq(tfunc(t), ts)
+
+    # Expressions with free indices:
+
+    t = (G(mu)*G(nu)*G(rho)*G(sigma)*G(-mu))
+    assert _is_tensor_eq(tfunc(t), (-2*G(sigma)*G(rho)*G(nu) + (4-D)*G(nu)*G(rho)*G(sigma)))
+
+    t = (G(mu)*G(nu)*G(-mu))
+    assert _is_tensor_eq(tfunc(t), (2-D)*G(nu))
+
+    t = (G(mu)*G(nu)*G(rho)*G(-mu))
+    assert _is_tensor_eq(tfunc(t), 2*G(nu)*G(rho) + 2*G(rho)*G(nu) - (4-D)*G(nu)*G(rho))
+
+    t = 2*G(m2)*G(m0)*G(m1)*G(-m0)*G(-m1)
+    st = tfunc(t)
+    assert _is_tensor_eq(st, (D*(-2*D + 4))*G(m2))
+
+    t = G(m2)*G(m0)*G(m1)*G(-m0)*G(-m2)
+    st = tfunc(t)
+    assert _is_tensor_eq(st, ((-D + 2)**2)*G(m1))
+
+    t = G(m0)*G(m1)*G(m2)*G(m3)*G(-m1)
+    st = tfunc(t)
+    assert _is_tensor_eq(st, (D - 4)*G(m0)*G(m2)*G(m3) + 4*G(m0)*g(m2, m3))
+
+    t = G(m0)*G(m1)*G(m2)*G(m3)*G(-m1)*G(-m0)
+    st = tfunc(t)
+    assert _is_tensor_eq(st, ((D - 4)**2)*G(m2)*G(m3) + (8*D - 16)*g(m2, m3))
+
+    t = G(m2)*G(m0)*G(m1)*G(-m2)*G(-m0)
+    st = tfunc(t)
+    assert _is_tensor_eq(st, ((-D + 2)*(D - 4) + 4)*G(m1))
+
+    t = G(m3)*G(m1)*G(m0)*G(m2)*G(-m3)*G(-m0)*G(-m2)
+    st = tfunc(t)
+    assert _is_tensor_eq(st, (-4*D + (-D + 2)**2*(D - 4) + 8)*G(m1))
+
+    t = 2*G(m0)*G(m1)*G(m2)*G(m3)*G(-m0)
+    st = tfunc(t)
+    assert _is_tensor_eq(st, ((-2*D + 8)*G(m1)*G(m2)*G(m3) - 4*G(m3)*G(m2)*G(m1)))
+
+    t = G(m5)*G(m0)*G(m1)*G(m4)*G(m2)*G(-m4)*G(m3)*G(-m0)
+    st = tfunc(t)
+    assert _is_tensor_eq(st, (((-D + 2)*(-D + 4))*G(m5)*G(m1)*G(m2)*G(m3) + (2*D - 4)*G(m5)*G(m3)*G(m2)*G(m1)))
+
+    t = -G(m0)*G(m1)*G(m2)*G(m3)*G(-m0)*G(m4)
+    st = tfunc(t)
+    assert _is_tensor_eq(st, ((D - 4)*G(m1)*G(m2)*G(m3)*G(m4) + 2*G(m3)*G(m2)*G(m1)*G(m4)))
+
+    t = G(-m5)*G(m0)*G(m1)*G(m2)*G(m3)*G(m4)*G(-m0)*G(m5)
+    st = tfunc(t)
+
+    result1 = ((-D + 4)**2 + 4)*G(m1)*G(m2)*G(m3)*G(m4) +\
+        (4*D - 16)*G(m3)*G(m2)*G(m1)*G(m4) + (4*D - 16)*G(m4)*G(m1)*G(m2)*G(m3)\
+        + 4*G(m2)*G(m1)*G(m4)*G(m3) + 4*G(m3)*G(m4)*G(m1)*G(m2) +\
+        4*G(m4)*G(m3)*G(m2)*G(m1)
+
+    # Kahane's algorithm yields this result, which is equivalent to `result1`
+    # in four dimensions, but is not automatically recognized as equal:
+    result2 = 8*G(m1)*G(m2)*G(m3)*G(m4) + 8*G(m4)*G(m3)*G(m2)*G(m1)
+
+    if D == 4:
+        assert _is_tensor_eq(st, (result1)) or _is_tensor_eq(st, (result2))
+    else:
+        assert _is_tensor_eq(st, (result1))
+
+    # and a few very simple cases, with no contracted indices:
+
+    t = G(m0)
+    st = tfunc(t)
+    assert _is_tensor_eq(st, t)
+
+    t = -7*G(m0)
+    st = tfunc(t)
+    assert _is_tensor_eq(st, t)
+
+    t = 224*G(m0)*G(m1)*G(-m2)*G(m3)
+    st = tfunc(t)
+    assert _is_tensor_eq(st, t)
+
+
+def test_kahane_algorithm():
+    # Wrap this function to convert to and from TIDS:
+
+    def tfunc(e):
+        return _simplify_single_line(e)
+
+    execute_gamma_simplify_tests_for_function(tfunc, D=4)
+
+
+def test_kahane_simplify1():
+    i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15 = tensor_indices('i0:16', LorentzIndex)
+    mu, nu, rho, sigma = tensor_indices("mu, nu, rho, sigma", LorentzIndex)
+    D = 4
+    t = G(i0)*G(i1)
+    r = kahane_simplify(t)
+    assert r.equals(t)
+
+    t = G(i0)*G(i1)*G(-i0)
+    r = kahane_simplify(t)
+    assert r.equals(-2*G(i1))
+    t = G(i0)*G(i1)*G(-i0)
+    r = kahane_simplify(t)
+    assert r.equals(-2*G(i1))
+
+    t = G(i0)*G(i1)
+    r = kahane_simplify(t)
+    assert r.equals(t)
+    t = G(i0)*G(i1)
+    r = kahane_simplify(t)
+    assert r.equals(t)
+    t = G(i0)*G(-i0)
+    r = kahane_simplify(t)
+    assert r.equals(4*eye(4))
+    t = G(i0)*G(-i0)
+    r = kahane_simplify(t)
+    assert r.equals(4*eye(4))
+    t = G(i0)*G(-i0)
+    r = kahane_simplify(t)
+    assert r.equals(4*eye(4))
+    t = G(i0)*G(i1)*G(-i0)
+    r = kahane_simplify(t)
+    assert r.equals(-2*G(i1))
+    t = G(i0)*G(i1)*G(-i0)*G(-i1)
+    r = kahane_simplify(t)
+    assert r.equals((2*D - D**2)*eye(4))
+    t = G(i0)*G(i1)*G(-i0)*G(-i1)
+    r = kahane_simplify(t)
+    assert r.equals((2*D - D**2)*eye(4))
+    t = G(i0)*G(-i0)*G(i1)*G(-i1)
+    r = kahane_simplify(t)
+    assert r.equals(16*eye(4))
+    t = (G(mu)*G(nu)*G(-nu)*G(-mu))
+    r = kahane_simplify(t)
+    assert r.equals(D**2*eye(4))
+    t = (G(mu)*G(nu)*G(-nu)*G(-mu))
+    r = kahane_simplify(t)
+    assert r.equals(D**2*eye(4))
+    t = (G(mu)*G(nu)*G(-nu)*G(-mu))
+    r = kahane_simplify(t)
+    assert r.equals(D**2*eye(4))
+    t = (G(mu)*G(nu)*G(-rho)*G(-nu)*G(-mu)*G(rho))
+    r = kahane_simplify(t)
+    assert r.equals((4*D - 4*D**2 + D**3)*eye(4))
+    t = (G(-mu)*G(-nu)*G(-rho)*G(-sigma)*G(nu)*G(mu)*G(sigma)*G(rho))
+    r = kahane_simplify(t)
+    assert r.equals((-16*D + 24*D**2 - 8*D**3 + D**4)*eye(4))
+    t = (G(-mu)*G(nu)*G(-rho)*G(sigma)*G(rho)*G(-nu)*G(mu)*G(-sigma))
+    r = kahane_simplify(t)
+    assert r.equals((8*D - 12*D**2 + 6*D**3 - D**4)*eye(4))
+
+    # Expressions with free indices:
+    t = (G(mu)*G(nu)*G(rho)*G(sigma)*G(-mu))
+    r = kahane_simplify(t)
+    assert r.equals(-2*G(sigma)*G(rho)*G(nu))
+    t = (G(mu)*G(-mu)*G(rho)*G(sigma))
+    r = kahane_simplify(t)
+    assert r.equals(4*G(rho)*G(sigma))
+    t = (G(rho)*G(sigma)*G(mu)*G(-mu))
+    r = kahane_simplify(t)
+    assert r.equals(4*G(rho)*G(sigma))
+
+def test_gamma_matrix_class():
+    i, j, k = tensor_indices('i,j,k', LorentzIndex)
+
+    # define another type of TensorHead to see if exprs are correctly handled:
+    A = TensorHead('A', [LorentzIndex])
+
+    t = A(k)*G(i)*G(-i)
+    ts = simplify_gamma_expression(t)
+    assert _is_tensor_eq(ts, Matrix([
+        [4, 0, 0, 0],
+        [0, 4, 0, 0],
+        [0, 0, 4, 0],
+        [0, 0, 0, 4]])*A(k))
+
+    t = G(i)*A(k)*G(j)
+    ts = simplify_gamma_expression(t)
+    assert _is_tensor_eq(ts, A(k)*G(i)*G(j))
+
+    execute_gamma_simplify_tests_for_function(simplify_gamma_expression, D=4)
+
+
+def test_gamma_matrix_trace():
+    g = LorentzIndex.metric
+
+    m0, m1, m2, m3, m4, m5, m6 = tensor_indices('m0:7', LorentzIndex)
+    n0, n1, n2, n3, n4, n5 = tensor_indices('n0:6', LorentzIndex)
+
+    # working in D=4 dimensions
+    D = 4
+
+    # traces of odd number of gamma matrices are zero:
+    t = G(m0)
+    t1 = gamma_trace(t)
+    assert t1.equals(0)
+
+    t = G(m0)*G(m1)*G(m2)
+    t1 = gamma_trace(t)
+    assert t1.equals(0)
+
+    t = G(m0)*G(m1)*G(-m0)
+    t1 = gamma_trace(t)
+    assert t1.equals(0)
+
+    t = G(m0)*G(m1)*G(m2)*G(m3)*G(m4)
+    t1 = gamma_trace(t)
+    assert t1.equals(0)
+
+    # traces without internal contractions:
+    t = G(m0)*G(m1)
+    t1 = gamma_trace(t)
+    assert _is_tensor_eq(t1, 4*g(m0, m1))
+
+    t = G(m0)*G(m1)*G(m2)*G(m3)
+    t1 = gamma_trace(t)
+    t2 = -4*g(m0, m2)*g(m1, m3) + 4*g(m0, m1)*g(m2, m3) + 4*g(m0, m3)*g(m1, m2)
+    assert _is_tensor_eq(t1, t2)
+
+    t = G(m0)*G(m1)*G(m2)*G(m3)*G(m4)*G(m5)
+    t1 = gamma_trace(t)
+    t2 = t1*g(-m0, -m5)
+    t2 = t2.contract_metric(g)
+    assert _is_tensor_eq(t2, D*gamma_trace(G(m1)*G(m2)*G(m3)*G(m4)))
+
+    # traces of expressions with internal contractions:
+    t = G(m0)*G(-m0)
+    t1 = gamma_trace(t)
+    assert t1.equals(4*D)
+
+    t = G(m0)*G(m1)*G(-m0)*G(-m1)
+    t1 = gamma_trace(t)
+    assert t1.equals(8*D - 4*D**2)
+
+    t = G(m0)*G(m1)*G(m2)*G(m3)*G(m4)*G(-m0)
+    t1 = gamma_trace(t)
+    t2 = (-4*D)*g(m1, m3)*g(m2, m4) + (4*D)*g(m1, m2)*g(m3, m4) + \
+                 (4*D)*g(m1, m4)*g(m2, m3)
+    assert _is_tensor_eq(t1, t2)
+
+    t = G(-m5)*G(m0)*G(m1)*G(m2)*G(m3)*G(m4)*G(-m0)*G(m5)
+    t1 = gamma_trace(t)
+    t2 = (32*D + 4*(-D + 4)**2 - 64)*(g(m1, m2)*g(m3, m4) - \
+            g(m1, m3)*g(m2, m4) + g(m1, m4)*g(m2, m3))
+    assert _is_tensor_eq(t1, t2)
+
+    t = G(m0)*G(m1)*G(-m0)*G(m3)
+    t1 = gamma_trace(t)
+    assert t1.equals((-4*D + 8)*g(m1, m3))
+
+#    p, q = S1('p,q')
+#    ps = p(m0)*G(-m0)
+#    qs = q(m0)*G(-m0)
+#    t = ps*qs*ps*qs
+#    t1 = gamma_trace(t)
+#    assert t1 == 8*p(m0)*q(-m0)*p(m1)*q(-m1) - 4*p(m0)*p(-m0)*q(m1)*q(-m1)
+
+    t = G(m0)*G(m1)*G(m2)*G(m3)*G(m4)*G(m5)*G(-m0)*G(-m1)*G(-m2)*G(-m3)*G(-m4)*G(-m5)
+    t1 = gamma_trace(t)
+    assert t1.equals(-4*D**6 + 120*D**5 - 1040*D**4 + 3360*D**3 - 4480*D**2 + 2048*D)
+
+    t = G(m0)*G(m1)*G(n1)*G(m2)*G(n2)*G(m3)*G(m4)*G(-n2)*G(-n1)*G(-m0)*G(-m1)*G(-m2)*G(-m3)*G(-m4)
+    t1 = gamma_trace(t)
+    tresu = -7168*D + 16768*D**2 - 14400*D**3 + 5920*D**4 - 1232*D**5 + 120*D**6 - 4*D**7
+    assert t1.equals(tresu)
+
+    # checked with Mathematica
+    # In[1]:= <<Tracer.m
+    # In[2]:= Spur[l];
+    # In[3]:= GammaTrace[l, {m0},{m1},{n1},{m2},{n2},{m3},{m4},{n3},{n4},{m0},{m1},{m2},{m3},{m4}]
+    t = G(m0)*G(m1)*G(n1)*G(m2)*G(n2)*G(m3)*G(m4)*G(n3)*G(n4)*G(-m0)*G(-m1)*G(-m2)*G(-m3)*G(-m4)
+    t1 = gamma_trace(t)
+#    t1 = t1.expand_coeff()
+    c1 = -4*D**5 + 120*D**4 - 1200*D**3 + 5280*D**2 - 10560*D + 7808
+    c2 = -4*D**5 + 88*D**4 - 560*D**3 + 1440*D**2 - 1600*D + 640
+    assert _is_tensor_eq(t1, c1*g(n1, n4)*g(n2, n3) + c2*g(n1, n2)*g(n3, n4) + \
+            (-c1)*g(n1, n3)*g(n2, n4))
+
+    p, q = tensor_heads('p,q', [LorentzIndex])
+    ps = p(m0)*G(-m0)
+    qs = q(m0)*G(-m0)
+    p2 = p(m0)*p(-m0)
+    q2 = q(m0)*q(-m0)
+    pq = p(m0)*q(-m0)
+    t = ps*qs*ps*qs
+    r = gamma_trace(t)
+    assert _is_tensor_eq(r, 8*pq*pq - 4*p2*q2)
+    t = ps*qs*ps*qs*ps*qs
+    r = gamma_trace(t)
+    assert _is_tensor_eq(r, -12*p2*pq*q2 + 16*pq*pq*pq)
+    t = ps*qs*ps*qs*ps*qs*ps*qs
+    r = gamma_trace(t)
+    assert _is_tensor_eq(r, -32*pq*pq*p2*q2 + 32*pq*pq*pq*pq + 4*p2*p2*q2*q2)
+
+    t = 4*p(m1)*p(m0)*p(-m0)*q(-m1)*q(m2)*q(-m2)
+    assert _is_tensor_eq(gamma_trace(t), t)
+    t = ps*ps*ps*ps*ps*ps*ps*ps
+    r = gamma_trace(t)
+    assert r.equals(4*p2*p2*p2*p2)
+
+
+def test_bug_13636():
+    """Test issue 13636 regarding handling traces of sums of products
+    of GammaMatrix mixed with other factors."""
+    pi, ki, pf = tensor_heads("pi, ki, pf", [LorentzIndex])
+    i0, i1, i2, i3, i4 = tensor_indices("i0:5", LorentzIndex)
+    x = Symbol("x")
+    pis = pi(i2) * G(-i2)
+    kis = ki(i3) * G(-i3)
+    pfs = pf(i4) * G(-i4)
+
+    a = pfs * G(i0) * kis * G(i1) * pis * G(-i1) * kis * G(-i0)
+    b = pfs * G(i0) * kis * G(i1) * pis * x * G(-i0) * pi(-i1)
+    ta = gamma_trace(a)
+    tb = gamma_trace(b)
+    t_a_plus_b = gamma_trace(a + b)
+    assert ta == 4 * (
+        -4 * ki(i0) * ki(-i0) * pf(i1) * pi(-i1)
+        + 8 * ki(i0) * ki(i1) * pf(-i0) * pi(-i1)
+    )
+    assert tb == -8 * x * ki(i0) * pf(-i0) * pi(i1) * pi(-i1)
+    assert t_a_plus_b == ta + tb

llmeval-env/lib/python3.10/site-packages/sympy/physics/optics/__init__.py

@@ -0,0 +1,38 @@
+__all__ = [
+    'TWave',
+
+    'RayTransferMatrix', 'FreeSpace', 'FlatRefraction', 'CurvedRefraction',
+    'FlatMirror', 'CurvedMirror', 'ThinLens', 'GeometricRay', 'BeamParameter',
+    'waist2rayleigh', 'rayleigh2waist', 'geometric_conj_ab',
+    'geometric_conj_af', 'geometric_conj_bf', 'gaussian_conj',
+    'conjugate_gauss_beams',
+
+    'Medium',
+
+    'refraction_angle', 'deviation', 'fresnel_coefficients', 'brewster_angle',
+    'critical_angle', 'lens_makers_formula', 'mirror_formula', 'lens_formula',
+    'hyperfocal_distance', 'transverse_magnification',
+
+    'jones_vector', 'stokes_vector', 'jones_2_stokes', 'linear_polarizer',
+    'phase_retarder', 'half_wave_retarder', 'quarter_wave_retarder',
+    'transmissive_filter', 'reflective_filter', 'mueller_matrix',
+    'polarizing_beam_splitter',
+]
+from .waves import TWave
+
+from .gaussopt import (RayTransferMatrix, FreeSpace, FlatRefraction,
+        CurvedRefraction, FlatMirror, CurvedMirror, ThinLens, GeometricRay,
+        BeamParameter, waist2rayleigh, rayleigh2waist, geometric_conj_ab,
+        geometric_conj_af, geometric_conj_bf, gaussian_conj,
+        conjugate_gauss_beams)
+
+from .medium import Medium
+
+from .utils import (refraction_angle, deviation, fresnel_coefficients,
+        brewster_angle, critical_angle, lens_makers_formula, mirror_formula,
+        lens_formula, hyperfocal_distance, transverse_magnification)
+
+from .polarization import (jones_vector, stokes_vector, jones_2_stokes,
+        linear_polarizer, phase_retarder, half_wave_retarder,
+        quarter_wave_retarder, transmissive_filter, reflective_filter,
+        mueller_matrix, polarizing_beam_splitter)

llmeval-env/lib/python3.10/site-packages/sympy/physics/optics/gaussopt.py

@@ -0,0 +1,923 @@
+"""
+Gaussian optics.
+
+The module implements:
+
+- Ray transfer matrices for geometrical and gaussian optics.
+
+  See RayTransferMatrix, GeometricRay and BeamParameter
+
+- Conjugation relations for geometrical and gaussian optics.
+
+  See geometric_conj*, gauss_conj and conjugate_gauss_beams
+
+The conventions for the distances are as follows:
+
+focal distance
+    positive for convergent lenses
+object distance
+    positive for real objects
+image distance
+    positive for real images
+"""
+
+__all__ = [
+    'RayTransferMatrix',
+    'FreeSpace',
+    'FlatRefraction',
+    'CurvedRefraction',
+    'FlatMirror',
+    'CurvedMirror',
+    'ThinLens',
+    'GeometricRay',
+    'BeamParameter',
+    'waist2rayleigh',
+    'rayleigh2waist',
+    'geometric_conj_ab',
+    'geometric_conj_af',
+    'geometric_conj_bf',
+    'gaussian_conj',
+    'conjugate_gauss_beams',
+]
+
+
+from sympy.core.expr import Expr
+from sympy.core.numbers import (I, pi)
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.complexes import (im, re)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import atan2
+from sympy.matrices.dense import Matrix, MutableDenseMatrix
+from sympy.polys.rationaltools import together
+from sympy.utilities.misc import filldedent
+
+###
+# A, B, C, D matrices
+###
+
+
+class RayTransferMatrix(MutableDenseMatrix):
+    """
+    Base class for a Ray Transfer Matrix.
+
+    It should be used if there is not already a more specific subclass mentioned
+    in See Also.
+
+    Parameters
+    ==========
+
+    parameters :
+        A, B, C and D or 2x2 matrix (Matrix(2, 2, [A, B, C, D]))
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import RayTransferMatrix, ThinLens
+    >>> from sympy import Symbol, Matrix
+
+    >>> mat = RayTransferMatrix(1, 2, 3, 4)
+    >>> mat
+    Matrix([
+    [1, 2],
+    [3, 4]])
+
+    >>> RayTransferMatrix(Matrix([[1, 2], [3, 4]]))
+    Matrix([
+    [1, 2],
+    [3, 4]])
+
+    >>> mat.A
+    1
+
+    >>> f = Symbol('f')
+    >>> lens = ThinLens(f)
+    >>> lens
+    Matrix([
+    [   1, 0],
+    [-1/f, 1]])
+
+    >>> lens.C
+    -1/f
+
+    See Also
+    ========
+
+    GeometricRay, BeamParameter,
+    FreeSpace, FlatRefraction, CurvedRefraction,
+    FlatMirror, CurvedMirror, ThinLens
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Ray_transfer_matrix_analysis
+    """
+
+    def __new__(cls, *args):
+
+        if len(args) == 4:
+            temp = ((args[0], args[1]), (args[2], args[3]))
+        elif len(args) == 1 \
+            and isinstance(args[0], Matrix) \
+                and args[0].shape == (2, 2):
+            temp = args[0]
+        else:
+            raise ValueError(filldedent('''
+                Expecting 2x2 Matrix or the 4 elements of
+                the Matrix but got %s''' % str(args)))
+        return Matrix.__new__(cls, temp)
+
+    def __mul__(self, other):
+        if isinstance(other, RayTransferMatrix):
+            return RayTransferMatrix(Matrix.__mul__(self, other))
+        elif isinstance(other, GeometricRay):
+            return GeometricRay(Matrix.__mul__(self, other))
+        elif isinstance(other, BeamParameter):
+            temp = self*Matrix(((other.q,), (1,)))
+            q = (temp[0]/temp[1]).expand(complex=True)
+            return BeamParameter(other.wavelen,
+                                 together(re(q)),
+                                 z_r=together(im(q)))
+        else:
+            return Matrix.__mul__(self, other)
+
+    @property
+    def A(self):
+        """
+        The A parameter of the Matrix.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.optics import RayTransferMatrix
+        >>> mat = RayTransferMatrix(1, 2, 3, 4)
+        >>> mat.A
+        1
+        """
+        return self[0, 0]
+
+    @property
+    def B(self):
+        """
+        The B parameter of the Matrix.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.optics import RayTransferMatrix
+        >>> mat = RayTransferMatrix(1, 2, 3, 4)
+        >>> mat.B
+        2
+        """
+        return self[0, 1]
+
+    @property
+    def C(self):
+        """
+        The C parameter of the Matrix.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.optics import RayTransferMatrix
+        >>> mat = RayTransferMatrix(1, 2, 3, 4)
+        >>> mat.C
+        3
+        """
+        return self[1, 0]
+
+    @property
+    def D(self):
+        """
+        The D parameter of the Matrix.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.optics import RayTransferMatrix
+        >>> mat = RayTransferMatrix(1, 2, 3, 4)
+        >>> mat.D
+        4
+        """
+        return self[1, 1]
+
+
+class FreeSpace(RayTransferMatrix):
+    """
+    Ray Transfer Matrix for free space.
+
+    Parameters
+    ==========
+
+    distance
+
+    See Also
+    ========
+
+    RayTransferMatrix
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import FreeSpace
+    >>> from sympy import symbols
+    >>> d = symbols('d')
+    >>> FreeSpace(d)
+    Matrix([
+    [1, d],
+    [0, 1]])
+    """
+    def __new__(cls, d):
+        return RayTransferMatrix.__new__(cls, 1, d, 0, 1)
+
+
+class FlatRefraction(RayTransferMatrix):
+    """
+    Ray Transfer Matrix for refraction.
+
+    Parameters
+    ==========
+
+    n1 :
+        Refractive index of one medium.
+    n2 :
+        Refractive index of other medium.
+
+    See Also
+    ========
+
+    RayTransferMatrix
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import FlatRefraction
+    >>> from sympy import symbols
+    >>> n1, n2 = symbols('n1 n2')
+    >>> FlatRefraction(n1, n2)
+    Matrix([
+    [1,     0],
+    [0, n1/n2]])
+    """
+    def __new__(cls, n1, n2):
+        n1, n2 = map(sympify, (n1, n2))
+        return RayTransferMatrix.__new__(cls, 1, 0, 0, n1/n2)
+
+
+class CurvedRefraction(RayTransferMatrix):
+    """
+    Ray Transfer Matrix for refraction on curved interface.
+
+    Parameters
+    ==========
+
+    R :
+        Radius of curvature (positive for concave).
+    n1 :
+        Refractive index of one medium.
+    n2 :
+        Refractive index of other medium.
+
+    See Also
+    ========
+
+    RayTransferMatrix
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import CurvedRefraction
+    >>> from sympy import symbols
+    >>> R, n1, n2 = symbols('R n1 n2')
+    >>> CurvedRefraction(R, n1, n2)
+    Matrix([
+    [               1,     0],
+    [(n1 - n2)/(R*n2), n1/n2]])
+    """
+    def __new__(cls, R, n1, n2):
+        R, n1, n2 = map(sympify, (R, n1, n2))
+        return RayTransferMatrix.__new__(cls, 1, 0, (n1 - n2)/R/n2, n1/n2)
+
+
+class FlatMirror(RayTransferMatrix):
+    """
+    Ray Transfer Matrix for reflection.
+
+    See Also
+    ========
+
+    RayTransferMatrix
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import FlatMirror
+    >>> FlatMirror()
+    Matrix([
+    [1, 0],
+    [0, 1]])
+    """
+    def __new__(cls):
+        return RayTransferMatrix.__new__(cls, 1, 0, 0, 1)
+
+
+class CurvedMirror(RayTransferMatrix):
+    """
+    Ray Transfer Matrix for reflection from curved surface.
+
+    Parameters
+    ==========
+
+    R : radius of curvature (positive for concave)
+
+    See Also
+    ========
+
+    RayTransferMatrix
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import CurvedMirror
+    >>> from sympy import symbols
+    >>> R = symbols('R')
+    >>> CurvedMirror(R)
+    Matrix([
+    [   1, 0],
+    [-2/R, 1]])
+    """
+    def __new__(cls, R):
+        R = sympify(R)
+        return RayTransferMatrix.__new__(cls, 1, 0, -2/R, 1)
+
+
+class ThinLens(RayTransferMatrix):
+    """
+    Ray Transfer Matrix for a thin lens.
+
+    Parameters
+    ==========
+
+    f :
+        The focal distance.
+
+    See Also
+    ========
+
+    RayTransferMatrix
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import ThinLens
+    >>> from sympy import symbols
+    >>> f = symbols('f')
+    >>> ThinLens(f)
+    Matrix([
+    [   1, 0],
+    [-1/f, 1]])
+    """
+    def __new__(cls, f):
+        f = sympify(f)
+        return RayTransferMatrix.__new__(cls, 1, 0, -1/f, 1)
+
+
+###
+# Representation for geometric ray
+###
+
+class GeometricRay(MutableDenseMatrix):
+    """
+    Representation for a geometric ray in the Ray Transfer Matrix formalism.
+
+    Parameters
+    ==========
+
+    h : height, and
+    angle : angle, or
+    matrix : a 2x1 matrix (Matrix(2, 1, [height, angle]))
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import GeometricRay, FreeSpace
+    >>> from sympy import symbols, Matrix
+    >>> d, h, angle = symbols('d, h, angle')
+
+    >>> GeometricRay(h, angle)
+    Matrix([
+    [    h],
+    [angle]])
+
+    >>> FreeSpace(d)*GeometricRay(h, angle)
+    Matrix([
+    [angle*d + h],
+    [      angle]])
+
+    >>> GeometricRay( Matrix( ((h,), (angle,)) ) )
+    Matrix([
+    [    h],
+    [angle]])
+
+    See Also
+    ========
+
+    RayTransferMatrix
+
+    """
+
+    def __new__(cls, *args):
+        if len(args) == 1 and isinstance(args[0], Matrix) \
+                and args[0].shape == (2, 1):
+            temp = args[0]
+        elif len(args) == 2:
+            temp = ((args[0],), (args[1],))
+        else:
+            raise ValueError(filldedent('''
+                Expecting 2x1 Matrix or the 2 elements of
+                the Matrix but got %s''' % str(args)))
+        return Matrix.__new__(cls, temp)
+
+    @property
+    def height(self):
+        """
+        The distance from the optical axis.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.optics import GeometricRay
+        >>> from sympy import symbols
+        >>> h, angle = symbols('h, angle')
+        >>> gRay = GeometricRay(h, angle)
+        >>> gRay.height
+        h
+        """
+        return self[0]
+
+    @property
+    def angle(self):
+        """
+        The angle with the optical axis.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.optics import GeometricRay
+        >>> from sympy import symbols
+        >>> h, angle = symbols('h, angle')
+        >>> gRay = GeometricRay(h, angle)
+        >>> gRay.angle
+        angle
+        """
+        return self[1]
+
+
+###
+# Representation for gauss beam
+###
+
+class BeamParameter(Expr):
+    """
+    Representation for a gaussian ray in the Ray Transfer Matrix formalism.
+
+    Parameters
+    ==========
+
+    wavelen : the wavelength,
+    z : the distance to waist, and
+    w : the waist, or
+    z_r : the rayleigh range.
+    n : the refractive index of medium.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import BeamParameter
+    >>> p = BeamParameter(530e-9, 1, w=1e-3)
+    >>> p.q
+    1 + 1.88679245283019*I*pi
+
+    >>> p.q.n()
+    1.0 + 5.92753330865999*I
+    >>> p.w_0.n()
+    0.00100000000000000
+    >>> p.z_r.n()
+    5.92753330865999
+
+    >>> from sympy.physics.optics import FreeSpace
+    >>> fs = FreeSpace(10)
+    >>> p1 = fs*p
+    >>> p.w.n()
+    0.00101413072159615
+    >>> p1.w.n()
+    0.00210803120913829
+
+    See Also
+    ========
+
+    RayTransferMatrix
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Complex_beam_parameter
+    .. [2] https://en.wikipedia.org/wiki/Gaussian_beam
+    """
+    #TODO A class Complex may be implemented. The BeamParameter may
+    # subclass it. See:
+    # https://groups.google.com/d/topic/sympy/7XkU07NRBEs/discussion
+
+    def __new__(cls, wavelen, z, z_r=None, w=None, n=1):
+        wavelen = sympify(wavelen)
+        z = sympify(z)
+        n = sympify(n)
+
+        if z_r is not None and w is None:
+            z_r = sympify(z_r)
+        elif w is not None and z_r is None:
+            z_r = waist2rayleigh(sympify(w), wavelen, n)
+        elif z_r is None and w is None:
+            raise ValueError('Must specify one of w and z_r.')
+
+        return Expr.__new__(cls, wavelen, z, z_r, n)
+
+    @property
+    def wavelen(self):
+        return self.args[0]
+
+    @property
+    def z(self):
+        return self.args[1]
+
+    @property
+    def z_r(self):
+        return self.args[2]
+
+    @property
+    def n(self):
+        return self.args[3]
+
+    @property
+    def q(self):
+        """
+        The complex parameter representing the beam.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.optics import BeamParameter
+        >>> p = BeamParameter(530e-9, 1, w=1e-3)
+        >>> p.q
+        1 + 1.88679245283019*I*pi
+        """
+        return self.z + I*self.z_r
+
+    @property
+    def radius(self):
+        """
+        The radius of curvature of the phase front.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.optics import BeamParameter
+        >>> p = BeamParameter(530e-9, 1, w=1e-3)
+        >>> p.radius
+        1 + 3.55998576005696*pi**2
+        """
+        return self.z*(1 + (self.z_r/self.z)**2)
+
+    @property
+    def w(self):
+        """
+        The radius of the beam w(z), at any position z along the beam.
+        The beam radius at `1/e^2` intensity (axial value).
+
+        See Also
+        ========
+
+        w_0 :
+            The minimal radius of beam.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.optics import BeamParameter
+        >>> p = BeamParameter(530e-9, 1, w=1e-3)
+        >>> p.w
+        0.001*sqrt(0.2809/pi**2 + 1)
+        """
+        return self.w_0*sqrt(1 + (self.z/self.z_r)**2)
+
+    @property
+    def w_0(self):
+        """
+         The minimal radius of beam at `1/e^2` intensity (peak value).
+
+        See Also
+        ========
+
+        w : the beam radius at `1/e^2` intensity (axial value).
+
+        Examples
+        ========
+
+        >>> from sympy.physics.optics import BeamParameter
+        >>> p = BeamParameter(530e-9, 1, w=1e-3)
+        >>> p.w_0
+        0.00100000000000000
+        """
+        return sqrt(self.z_r/(pi*self.n)*self.wavelen)
+
+    @property
+    def divergence(self):
+        """
+        Half of the total angular spread.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.optics import BeamParameter
+        >>> p = BeamParameter(530e-9, 1, w=1e-3)
+        >>> p.divergence
+        0.00053/pi
+        """
+        return self.wavelen/pi/self.w_0
+
+    @property
+    def gouy(self):
+        """
+        The Gouy phase.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.optics import BeamParameter
+        >>> p = BeamParameter(530e-9, 1, w=1e-3)
+        >>> p.gouy
+        atan(0.53/pi)
+        """
+        return atan2(self.z, self.z_r)
+
+    @property
+    def waist_approximation_limit(self):
+        """
+        The minimal waist for which the gauss beam approximation is valid.
+
+        Explanation
+        ===========
+
+        The gauss beam is a solution to the paraxial equation. For curvatures
+        that are too great it is not a valid approximation.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.optics import BeamParameter
+        >>> p = BeamParameter(530e-9, 1, w=1e-3)
+        >>> p.waist_approximation_limit
+        1.06e-6/pi
+        """
+        return 2*self.wavelen/pi
+
+
+###
+# Utilities
+###
+
+def waist2rayleigh(w, wavelen, n=1):
+    """
+    Calculate the rayleigh range from the waist of a gaussian beam.
+
+    See Also
+    ========
+
+    rayleigh2waist, BeamParameter
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import waist2rayleigh
+    >>> from sympy import symbols
+    >>> w, wavelen = symbols('w wavelen')
+    >>> waist2rayleigh(w, wavelen)
+    pi*w**2/wavelen
+    """
+    w, wavelen = map(sympify, (w, wavelen))
+    return w**2*n*pi/wavelen
+
+
+def rayleigh2waist(z_r, wavelen):
+    """Calculate the waist from the rayleigh range of a gaussian beam.
+
+    See Also
+    ========
+
+    waist2rayleigh, BeamParameter
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import rayleigh2waist
+    >>> from sympy import symbols
+    >>> z_r, wavelen = symbols('z_r wavelen')
+    >>> rayleigh2waist(z_r, wavelen)
+    sqrt(wavelen*z_r)/sqrt(pi)
+    """
+    z_r, wavelen = map(sympify, (z_r, wavelen))
+    return sqrt(z_r/pi*wavelen)
+
+
+def geometric_conj_ab(a, b):
+    """
+    Conjugation relation for geometrical beams under paraxial conditions.
+
+    Explanation
+    ===========
+
+    Takes the distances to the optical element and returns the needed
+    focal distance.
+
+    See Also
+    ========
+
+    geometric_conj_af, geometric_conj_bf
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import geometric_conj_ab
+    >>> from sympy import symbols
+    >>> a, b = symbols('a b')
+    >>> geometric_conj_ab(a, b)
+    a*b/(a + b)
+    """
+    a, b = map(sympify, (a, b))
+    if a.is_infinite or b.is_infinite:
+        return a if b.is_infinite else b
+    else:
+        return a*b/(a + b)
+
+
+def geometric_conj_af(a, f):
+    """
+    Conjugation relation for geometrical beams under paraxial conditions.
+
+    Explanation
+    ===========
+
+    Takes the object distance (for geometric_conj_af) or the image distance
+    (for geometric_conj_bf) to the optical element and the focal distance.
+    Then it returns the other distance needed for conjugation.
+
+    See Also
+    ========
+
+    geometric_conj_ab
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics.gaussopt import geometric_conj_af, geometric_conj_bf
+    >>> from sympy import symbols
+    >>> a, b, f = symbols('a b f')
+    >>> geometric_conj_af(a, f)
+    a*f/(a - f)
+    >>> geometric_conj_bf(b, f)
+    b*f/(b - f)
+    """
+    a, f = map(sympify, (a, f))
+    return -geometric_conj_ab(a, -f)
+
+geometric_conj_bf = geometric_conj_af
+
+
+def gaussian_conj(s_in, z_r_in, f):
+    """
+    Conjugation relation for gaussian beams.
+
+    Parameters
+    ==========
+
+    s_in :
+        The distance to optical element from the waist.
+    z_r_in :
+        The rayleigh range of the incident beam.
+    f :
+        The focal length of the optical element.
+
+    Returns
+    =======
+
+    a tuple containing (s_out, z_r_out, m)
+    s_out :
+        The distance between the new waist and the optical element.
+    z_r_out :
+        The rayleigh range of the emergent beam.
+    m :
+        The ration between the new and the old waists.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import gaussian_conj
+    >>> from sympy import symbols
+    >>> s_in, z_r_in, f = symbols('s_in z_r_in f')
+
+    >>> gaussian_conj(s_in, z_r_in, f)[0]
+    1/(-1/(s_in + z_r_in**2/(-f + s_in)) + 1/f)
+
+    >>> gaussian_conj(s_in, z_r_in, f)[1]
+    z_r_in/(1 - s_in**2/f**2 + z_r_in**2/f**2)
+
+    >>> gaussian_conj(s_in, z_r_in, f)[2]
+    1/sqrt(1 - s_in**2/f**2 + z_r_in**2/f**2)
+    """
+    s_in, z_r_in, f = map(sympify, (s_in, z_r_in, f))
+    s_out = 1 / ( -1/(s_in + z_r_in**2/(s_in - f)) + 1/f )
+    m = 1/sqrt((1 - (s_in/f)**2) + (z_r_in/f)**2)
+    z_r_out = z_r_in / ((1 - (s_in/f)**2) + (z_r_in/f)**2)
+    return (s_out, z_r_out, m)
+
+
+def conjugate_gauss_beams(wavelen, waist_in, waist_out, **kwargs):
+    """
+    Find the optical setup conjugating the object/image waists.
+
+    Parameters
+    ==========
+
+    wavelen :
+        The wavelength of the beam.
+    waist_in and waist_out :
+        The waists to be conjugated.
+    f :
+        The focal distance of the element used in the conjugation.
+
+    Returns
+    =======
+
+    a tuple containing (s_in, s_out, f)
+    s_in :
+        The distance before the optical element.
+    s_out :
+        The distance after the optical element.
+    f :
+        The focal distance of the optical element.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import conjugate_gauss_beams
+    >>> from sympy import symbols, factor
+    >>> l, w_i, w_o, f = symbols('l w_i w_o f')
+
+    >>> conjugate_gauss_beams(l, w_i, w_o, f=f)[0]
+    f*(1 - sqrt(w_i**2/w_o**2 - pi**2*w_i**4/(f**2*l**2)))
+
+    >>> factor(conjugate_gauss_beams(l, w_i, w_o, f=f)[1])
+    f*w_o**2*(w_i**2/w_o**2 - sqrt(w_i**2/w_o**2 -
+              pi**2*w_i**4/(f**2*l**2)))/w_i**2
+
+    >>> conjugate_gauss_beams(l, w_i, w_o, f=f)[2]
+    f
+    """
+    #TODO add the other possible arguments
+    wavelen, waist_in, waist_out = map(sympify, (wavelen, waist_in, waist_out))
+    m = waist_out / waist_in
+    z = waist2rayleigh(waist_in, wavelen)
+    if len(kwargs) != 1:
+        raise ValueError("The function expects only one named argument")
+    elif 'dist' in kwargs:
+        raise NotImplementedError(filldedent('''
+            Currently only focal length is supported as a parameter'''))
+    elif 'f' in kwargs:
+        f = sympify(kwargs['f'])
+        s_in = f * (1 - sqrt(1/m**2 - z**2/f**2))
+        s_out = gaussian_conj(s_in, z, f)[0]
+    elif 's_in' in kwargs:
+        raise NotImplementedError(filldedent('''
+            Currently only focal length is supported as a parameter'''))
+    else:
+        raise ValueError(filldedent('''
+            The functions expects the focal length as a named argument'''))
+    return (s_in, s_out, f)
+
+#TODO
+#def plot_beam():
+#    """Plot the beam radius as it propagates in space."""
+#    pass
+
+#TODO
+#def plot_beam_conjugation():
+#    """
+#    Plot the intersection of two beams.
+#
+#    Represents the conjugation relation.
+#
+#    See Also
+#    ========
+#
+#    conjugate_gauss_beams
+#    """
+#    pass

llmeval-env/lib/python3.10/site-packages/sympy/physics/optics/medium.py

@@ -0,0 +1,253 @@
+"""
+**Contains**
+
+* Medium
+"""
+from sympy.physics.units import second, meter, kilogram, ampere
+
+__all__ = ['Medium']
+
+from sympy.core.basic import Basic
+from sympy.core.symbol import Str
+from sympy.core.sympify import _sympify
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.physics.units import speed_of_light, u0, e0
+
+
+c = speed_of_light.convert_to(meter/second)
+_e0mksa = e0.convert_to(ampere**2*second**4/(kilogram*meter**3))
+_u0mksa = u0.convert_to(meter*kilogram/(ampere**2*second**2))
+
+
+class Medium(Basic):
+
+    """
+    This class represents an optical medium. The prime reason to implement this is
+    to facilitate refraction, Fermat's principle, etc.
+
+    Explanation
+    ===========
+
+    An optical medium is a material through which electromagnetic waves propagate.
+    The permittivity and permeability of the medium define how electromagnetic
+    waves propagate in it.
+
+
+    Parameters
+    ==========
+
+    name: string
+        The display name of the Medium.
+
+    permittivity: Sympifyable
+        Electric permittivity of the space.
+
+    permeability: Sympifyable
+        Magnetic permeability of the space.
+
+    n: Sympifyable
+        Index of refraction of the medium.
+
+
+    Examples
+    ========
+
+    >>> from sympy.abc import epsilon, mu
+    >>> from sympy.physics.optics import Medium
+    >>> m1 = Medium('m1')
+    >>> m2 = Medium('m2', epsilon, mu)
+    >>> m1.intrinsic_impedance
+    149896229*pi*kilogram*meter**2/(1250000*ampere**2*second**3)
+    >>> m2.refractive_index
+    299792458*meter*sqrt(epsilon*mu)/second
+
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Optical_medium
+
+    """
+
+    def __new__(cls, name, permittivity=None, permeability=None, n=None):
+        if not isinstance(name, Str):
+            name = Str(name)
+
+        permittivity = _sympify(permittivity) if permittivity is not None else permittivity
+        permeability = _sympify(permeability) if permeability is not None else permeability
+        n = _sympify(n) if n is not None else n
+
+        if n is not None:
+            if permittivity is not None and permeability is None:
+                permeability = n**2/(c**2*permittivity)
+                return MediumPP(name, permittivity, permeability)
+            elif permeability is not None and permittivity is None:
+                permittivity = n**2/(c**2*permeability)
+                return MediumPP(name, permittivity, permeability)
+            elif permittivity is not None and permittivity is not None:
+                raise ValueError("Specifying all of permittivity, permeability, and n is not allowed")
+            else:
+                return MediumN(name, n)
+        elif permittivity is not None and permeability is not None:
+            return MediumPP(name, permittivity, permeability)
+        elif permittivity is None and permeability is None:
+            return MediumPP(name, _e0mksa, _u0mksa)
+        else:
+            raise ValueError("Arguments are underspecified. Either specify n or any two of permittivity, "
+                             "permeability, and n")
+
+    @property
+    def name(self):
+        return self.args[0]
+
+    @property
+    def speed(self):
+        """
+        Returns speed of the electromagnetic wave travelling in the medium.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.optics import Medium
+        >>> m = Medium('m')
+        >>> m.speed
+        299792458*meter/second
+        >>> m2 = Medium('m2', n=1)
+        >>> m.speed == m2.speed
+        True
+
+        """
+        return c / self.n
+
+    @property
+    def refractive_index(self):
+        """
+        Returns refractive index of the medium.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.optics import Medium
+        >>> m = Medium('m')
+        >>> m.refractive_index
+        1
+
+        """
+        return (c/self.speed)
+
+
+class MediumN(Medium):
+
+    """
+    Represents an optical medium for which only the refractive index is known.
+    Useful for simple ray optics.
+
+    This class should never be instantiated directly.
+    Instead it should be instantiated indirectly by instantiating Medium with
+    only n specified.
+
+    Examples
+    ========
+    >>> from sympy.physics.optics import Medium
+    >>> m = Medium('m', n=2)
+    >>> m
+    MediumN(Str('m'), 2)
+    """
+
+    def __new__(cls, name, n):
+        obj = super(Medium, cls).__new__(cls, name, n)
+        return obj
+
+    @property
+    def n(self):
+        return self.args[1]
+
+
+class MediumPP(Medium):
+    """
+    Represents an optical medium for which the permittivity and permeability are known.
+
+    This class should never be instantiated directly. Instead it should be
+    instantiated indirectly by instantiating Medium with any two of
+    permittivity, permeability, and n specified, or by not specifying any
+    of permittivity, permeability, or n, in which case default values for
+    permittivity and permeability will be used.
+
+    Examples
+    ========
+    >>> from sympy.physics.optics import Medium
+    >>> from sympy.abc import epsilon, mu
+    >>> m1 = Medium('m1', permittivity=epsilon, permeability=mu)
+    >>> m1
+    MediumPP(Str('m1'), epsilon, mu)
+    >>> m2 = Medium('m2')
+    >>> m2
+    MediumPP(Str('m2'), 625000*ampere**2*second**4/(22468879468420441*pi*kilogram*meter**3), pi*kilogram*meter/(2500000*ampere**2*second**2))
+    """
+
+
+    def __new__(cls, name, permittivity, permeability):
+        obj = super(Medium, cls).__new__(cls, name, permittivity, permeability)
+        return obj
+
+    @property
+    def intrinsic_impedance(self):
+        """
+        Returns intrinsic impedance of the medium.
+
+        Explanation
+        ===========
+
+        The intrinsic impedance of a medium is the ratio of the
+        transverse components of the electric and magnetic fields
+        of the electromagnetic wave travelling in the medium.
+        In a region with no electrical conductivity it simplifies
+        to the square root of ratio of magnetic permeability to
+        electric permittivity.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.optics import Medium
+        >>> m = Medium('m')
+        >>> m.intrinsic_impedance
+        149896229*pi*kilogram*meter**2/(1250000*ampere**2*second**3)
+
+        """
+        return sqrt(self.permeability / self.permittivity)
+
+    @property
+    def permittivity(self):
+        """
+        Returns electric permittivity of the medium.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.optics import Medium
+        >>> m = Medium('m')
+        >>> m.permittivity
+        625000*ampere**2*second**4/(22468879468420441*pi*kilogram*meter**3)
+
+        """
+        return self.args[1]
+
+    @property
+    def permeability(self):
+        """
+        Returns magnetic permeability of the medium.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.optics import Medium
+        >>> m = Medium('m')
+        >>> m.permeability
+        pi*kilogram*meter/(2500000*ampere**2*second**2)
+
+        """
+        return self.args[2]
+
+    @property
+    def n(self):
+        return c*sqrt(self.permittivity*self.permeability)

llmeval-env/lib/python3.10/site-packages/sympy/physics/optics/polarization.py

@@ -0,0 +1,732 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+The module implements routines to model the polarization of optical fields
+and can be used to calculate the effects of polarization optical elements on
+the fields.
+
+- Jones vectors.
+
+- Stokes vectors.
+
+- Jones matrices.
+
+- Mueller matrices.
+
+Examples
+========
+
+We calculate a generic Jones vector:
+
+>>> from sympy import symbols, pprint, zeros, simplify
+>>> from sympy.physics.optics.polarization import (jones_vector, stokes_vector,
+...     half_wave_retarder, polarizing_beam_splitter, jones_2_stokes)
+
+>>> psi, chi, p, I0 = symbols("psi, chi, p, I0", real=True)
+>>> x0 = jones_vector(psi, chi)
+>>> pprint(x0, use_unicode=True)
+⎡-ⅈ⋅sin(χ)⋅sin(ψ) + cos(χ)⋅cos(ψ)⎤
+⎢                                ⎥
+⎣ⅈ⋅sin(χ)⋅cos(ψ) + sin(ψ)⋅cos(χ) ⎦
+
+And the more general Stokes vector:
+
+>>> s0 = stokes_vector(psi, chi, p, I0)
+>>> pprint(s0, use_unicode=True)
+⎡          I₀          ⎤
+⎢                      ⎥
+⎢I₀⋅p⋅cos(2⋅χ)⋅cos(2⋅ψ)⎥
+⎢                      ⎥
+⎢I₀⋅p⋅sin(2⋅ψ)⋅cos(2⋅χ)⎥
+⎢                      ⎥
+⎣    I₀⋅p⋅sin(2⋅χ)     ⎦
+
+We calculate how the Jones vector is modified by a half-wave plate:
+
+>>> alpha = symbols("alpha", real=True)
+>>> HWP = half_wave_retarder(alpha)
+>>> x1 = simplify(HWP*x0)
+
+We calculate the very common operation of passing a beam through a half-wave
+plate and then through a polarizing beam-splitter. We do this by putting this
+Jones vector as the first entry of a two-Jones-vector state that is transformed
+by a 4x4 Jones matrix modelling the polarizing beam-splitter to get the
+transmitted and reflected Jones vectors:
+
+>>> PBS = polarizing_beam_splitter()
+>>> X1 = zeros(4, 1)
+>>> X1[:2, :] = x1
+>>> X2 = PBS*X1
+>>> transmitted_port = X2[:2, :]
+>>> reflected_port = X2[2:, :]
+
+This allows us to calculate how the power in both ports depends on the initial
+polarization:
+
+>>> transmitted_power = jones_2_stokes(transmitted_port)[0]
+>>> reflected_power = jones_2_stokes(reflected_port)[0]
+>>> print(transmitted_power)
+cos(-2*alpha + chi + psi)**2/2 + cos(2*alpha + chi - psi)**2/2
+
+
+>>> print(reflected_power)
+sin(-2*alpha + chi + psi)**2/2 + sin(2*alpha + chi - psi)**2/2
+
+Please see the description of the individual functions for further
+details and examples.
+
+References
+==========
+
+.. [1] https://en.wikipedia.org/wiki/Jones_calculus
+.. [2] https://en.wikipedia.org/wiki/Mueller_calculus
+.. [3] https://en.wikipedia.org/wiki/Stokes_parameters
+
+"""
+
+from sympy.core.numbers import (I, pi)
+from sympy.functions.elementary.complexes import (Abs, im, re)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.matrices.dense import Matrix
+from sympy.simplify.simplify import simplify
+from sympy.physics.quantum import TensorProduct
+
+
+def jones_vector(psi, chi):
+    """A Jones vector corresponding to a polarization ellipse with `psi` tilt,
+    and `chi` circularity.
+
+    Parameters
+    ==========
+
+    psi : numeric type or SymPy Symbol
+        The tilt of the polarization relative to the `x` axis.
+
+    chi : numeric type or SymPy Symbol
+        The angle adjacent to the mayor axis of the polarization ellipse.
+
+
+    Returns
+    =======
+
+    Matrix :
+        A Jones vector.
+
+    Examples
+    ========
+
+    The axes on the Poincaré sphere.
+
+    >>> from sympy import pprint, symbols, pi
+    >>> from sympy.physics.optics.polarization import jones_vector
+    >>> psi, chi = symbols("psi, chi", real=True)
+
+    A general Jones vector.
+
+    >>> pprint(jones_vector(psi, chi), use_unicode=True)
+    ⎡-ⅈ⋅sin(χ)⋅sin(ψ) + cos(χ)⋅cos(ψ)⎤
+    ⎢                                ⎥
+    ⎣ⅈ⋅sin(χ)⋅cos(ψ) + sin(ψ)⋅cos(χ) ⎦
+
+    Horizontal polarization.
+
+    >>> pprint(jones_vector(0, 0), use_unicode=True)
+    ⎡1⎤
+    ⎢ ⎥
+    ⎣0⎦
+
+    Vertical polarization.
+
+    >>> pprint(jones_vector(pi/2, 0), use_unicode=True)
+    ⎡0⎤
+    ⎢ ⎥
+    ⎣1⎦
+
+    Diagonal polarization.
+
+    >>> pprint(jones_vector(pi/4, 0), use_unicode=True)
+    ⎡√2⎤
+    ⎢──⎥
+    ⎢2 ⎥
+    ⎢  ⎥
+    ⎢√2⎥
+    ⎢──⎥
+    ⎣2 ⎦
+
+    Anti-diagonal polarization.
+
+    >>> pprint(jones_vector(-pi/4, 0), use_unicode=True)
+    ⎡ √2 ⎤
+    ⎢ ── ⎥
+    ⎢ 2  ⎥
+    ⎢    ⎥
+    ⎢-√2 ⎥
+    ⎢────⎥
+    ⎣ 2  ⎦
+
+    Right-hand circular polarization.
+
+    >>> pprint(jones_vector(0, pi/4), use_unicode=True)
+    ⎡ √2 ⎤
+    ⎢ ── ⎥
+    ⎢ 2  ⎥
+    ⎢    ⎥
+    ⎢√2⋅ⅈ⎥
+    ⎢────⎥
+    ⎣ 2  ⎦
+
+    Left-hand circular polarization.
+
+    >>> pprint(jones_vector(0, -pi/4), use_unicode=True)
+    ⎡  √2  ⎤
+    ⎢  ──  ⎥
+    ⎢  2   ⎥
+    ⎢      ⎥
+    ⎢-√2⋅ⅈ ⎥
+    ⎢──────⎥
+    ⎣  2   ⎦
+
+    """
+    return Matrix([-I*sin(chi)*sin(psi) + cos(chi)*cos(psi),
+                   I*sin(chi)*cos(psi) + sin(psi)*cos(chi)])
+
+
+def stokes_vector(psi, chi, p=1, I=1):
+    """A Stokes vector corresponding to a polarization ellipse with ``psi``
+    tilt, and ``chi`` circularity.
+
+    Parameters
+    ==========
+
+    psi : numeric type or SymPy Symbol
+        The tilt of the polarization relative to the ``x`` axis.
+    chi : numeric type or SymPy Symbol
+        The angle adjacent to the mayor axis of the polarization ellipse.
+    p : numeric type or SymPy Symbol
+        The degree of polarization.
+    I : numeric type or SymPy Symbol
+        The intensity of the field.
+
+
+    Returns
+    =======
+
+    Matrix :
+        A Stokes vector.
+
+    Examples
+    ========
+
+    The axes on the Poincaré sphere.
+
+    >>> from sympy import pprint, symbols, pi
+    >>> from sympy.physics.optics.polarization import stokes_vector
+    >>> psi, chi, p, I = symbols("psi, chi, p, I", real=True)
+    >>> pprint(stokes_vector(psi, chi, p, I), use_unicode=True)
+    ⎡          I          ⎤
+    ⎢                     ⎥
+    ⎢I⋅p⋅cos(2⋅χ)⋅cos(2⋅ψ)⎥
+    ⎢                     ⎥
+    ⎢I⋅p⋅sin(2⋅ψ)⋅cos(2⋅χ)⎥
+    ⎢                     ⎥
+    ⎣    I⋅p⋅sin(2⋅χ)     ⎦
+
+
+    Horizontal polarization
+
+    >>> pprint(stokes_vector(0, 0), use_unicode=True)
+    ⎡1⎤
+    ⎢ ⎥
+    ⎢1⎥
+    ⎢ ⎥
+    ⎢0⎥
+    ⎢ ⎥
+    ⎣0⎦
+
+    Vertical polarization
+
+    >>> pprint(stokes_vector(pi/2, 0), use_unicode=True)
+    ⎡1 ⎤
+    ⎢  ⎥
+    ⎢-1⎥
+    ⎢  ⎥
+    ⎢0 ⎥
+    ⎢  ⎥
+    ⎣0 ⎦
+
+    Diagonal polarization
+
+    >>> pprint(stokes_vector(pi/4, 0), use_unicode=True)
+    ⎡1⎤
+    ⎢ ⎥
+    ⎢0⎥
+    ⎢ ⎥
+    ⎢1⎥
+    ⎢ ⎥
+    ⎣0⎦
+
+    Anti-diagonal polarization
+
+    >>> pprint(stokes_vector(-pi/4, 0), use_unicode=True)
+    ⎡1 ⎤
+    ⎢  ⎥
+    ⎢0 ⎥
+    ⎢  ⎥
+    ⎢-1⎥
+    ⎢  ⎥
+    ⎣0 ⎦
+
+    Right-hand circular polarization
+
+    >>> pprint(stokes_vector(0, pi/4), use_unicode=True)
+    ⎡1⎤
+    ⎢ ⎥
+    ⎢0⎥
+    ⎢ ⎥
+    ⎢0⎥
+    ⎢ ⎥
+    ⎣1⎦
+
+    Left-hand circular polarization
+
+    >>> pprint(stokes_vector(0, -pi/4), use_unicode=True)
+    ⎡1 ⎤
+    ⎢  ⎥
+    ⎢0 ⎥
+    ⎢  ⎥
+    ⎢0 ⎥
+    ⎢  ⎥
+    ⎣-1⎦
+
+    Unpolarized light
+
+    >>> pprint(stokes_vector(0, 0, 0), use_unicode=True)
+    ⎡1⎤
+    ⎢ ⎥
+    ⎢0⎥
+    ⎢ ⎥
+    ⎢0⎥
+    ⎢ ⎥
+    ⎣0⎦
+
+    """
+    S0 = I
+    S1 = I*p*cos(2*psi)*cos(2*chi)
+    S2 = I*p*sin(2*psi)*cos(2*chi)
+    S3 = I*p*sin(2*chi)
+    return Matrix([S0, S1, S2, S3])
+
+
+def jones_2_stokes(e):
+    """Return the Stokes vector for a Jones vector ``e``.
+
+    Parameters
+    ==========
+
+    e : SymPy Matrix
+        A Jones vector.
+
+    Returns
+    =======
+
+    SymPy Matrix
+        A Jones vector.
+
+    Examples
+    ========
+
+    The axes on the Poincaré sphere.
+
+    >>> from sympy import pprint, pi
+    >>> from sympy.physics.optics.polarization import jones_vector
+    >>> from sympy.physics.optics.polarization import jones_2_stokes
+    >>> H = jones_vector(0, 0)
+    >>> V = jones_vector(pi/2, 0)
+    >>> D = jones_vector(pi/4, 0)
+    >>> A = jones_vector(-pi/4, 0)
+    >>> R = jones_vector(0, pi/4)
+    >>> L = jones_vector(0, -pi/4)
+    >>> pprint([jones_2_stokes(e) for e in [H, V, D, A, R, L]],
+    ...         use_unicode=True)
+    ⎡⎡1⎤  ⎡1 ⎤  ⎡1⎤  ⎡1 ⎤  ⎡1⎤  ⎡1 ⎤⎤
+    ⎢⎢ ⎥  ⎢  ⎥  ⎢ ⎥  ⎢  ⎥  ⎢ ⎥  ⎢  ⎥⎥
+    ⎢⎢1⎥  ⎢-1⎥  ⎢0⎥  ⎢0 ⎥  ⎢0⎥  ⎢0 ⎥⎥
+    ⎢⎢ ⎥, ⎢  ⎥, ⎢ ⎥, ⎢  ⎥, ⎢ ⎥, ⎢  ⎥⎥
+    ⎢⎢0⎥  ⎢0 ⎥  ⎢1⎥  ⎢-1⎥  ⎢0⎥  ⎢0 ⎥⎥
+    ⎢⎢ ⎥  ⎢  ⎥  ⎢ ⎥  ⎢  ⎥  ⎢ ⎥  ⎢  ⎥⎥
+    ⎣⎣0⎦  ⎣0 ⎦  ⎣0⎦  ⎣0 ⎦  ⎣1⎦  ⎣-1⎦⎦
+
+    """
+    ex, ey = e
+    return Matrix([Abs(ex)**2 + Abs(ey)**2,
+                   Abs(ex)**2 - Abs(ey)**2,
+                   2*re(ex*ey.conjugate()),
+                   -2*im(ex*ey.conjugate())])
+
+
+def linear_polarizer(theta=0):
+    """A linear polarizer Jones matrix with transmission axis at
+    an angle ``theta``.
+
+    Parameters
+    ==========
+
+    theta : numeric type or SymPy Symbol
+        The angle of the transmission axis relative to the horizontal plane.
+
+    Returns
+    =======
+
+    SymPy Matrix
+        A Jones matrix representing the polarizer.
+
+    Examples
+    ========
+
+    A generic polarizer.
+
+    >>> from sympy import pprint, symbols
+    >>> from sympy.physics.optics.polarization import linear_polarizer
+    >>> theta = symbols("theta", real=True)
+    >>> J = linear_polarizer(theta)
+    >>> pprint(J, use_unicode=True)
+    ⎡      2                     ⎤
+    ⎢   cos (θ)     sin(θ)⋅cos(θ)⎥
+    ⎢                            ⎥
+    ⎢                     2      ⎥
+    ⎣sin(θ)⋅cos(θ)     sin (θ)   ⎦
+
+
+    """
+    M = Matrix([[cos(theta)**2, sin(theta)*cos(theta)],
+                [sin(theta)*cos(theta), sin(theta)**2]])
+    return M
+
+
+def phase_retarder(theta=0, delta=0):
+    """A phase retarder Jones matrix with retardance ``delta`` at angle ``theta``.
+
+    Parameters
+    ==========
+
+    theta : numeric type or SymPy Symbol
+        The angle of the fast axis relative to the horizontal plane.
+    delta : numeric type or SymPy Symbol
+        The phase difference between the fast and slow axes of the
+        transmitted light.
+
+    Returns
+    =======
+
+    SymPy Matrix :
+        A Jones matrix representing the retarder.
+
+    Examples
+    ========
+
+    A generic retarder.
+
+    >>> from sympy import pprint, symbols
+    >>> from sympy.physics.optics.polarization import phase_retarder
+    >>> theta, delta = symbols("theta, delta", real=True)
+    >>> R = phase_retarder(theta, delta)
+    >>> pprint(R, use_unicode=True)
+    ⎡                          -ⅈ⋅δ               -ⅈ⋅δ               ⎤
+    ⎢                          ─────              ─────              ⎥
+    ⎢⎛ ⅈ⋅δ    2         2   ⎞    2    ⎛     ⅈ⋅δ⎞    2                ⎥
+    ⎢⎝ℯ   ⋅sin (θ) + cos (θ)⎠⋅ℯ       ⎝1 - ℯ   ⎠⋅ℯ     ⋅sin(θ)⋅cos(θ)⎥
+    ⎢                                                                ⎥
+    ⎢            -ⅈ⋅δ                                           -ⅈ⋅δ ⎥
+    ⎢            ─────                                          ─────⎥
+    ⎢⎛     ⅈ⋅δ⎞    2                  ⎛ ⅈ⋅δ    2         2   ⎞    2  ⎥
+    ⎣⎝1 - ℯ   ⎠⋅ℯ     ⋅sin(θ)⋅cos(θ)  ⎝ℯ   ⋅cos (θ) + sin (θ)⎠⋅ℯ     ⎦
+
+    """
+    R = Matrix([[cos(theta)**2 + exp(I*delta)*sin(theta)**2,
+                (1-exp(I*delta))*cos(theta)*sin(theta)],
+                [(1-exp(I*delta))*cos(theta)*sin(theta),
+                sin(theta)**2 + exp(I*delta)*cos(theta)**2]])
+    return R*exp(-I*delta/2)
+
+
+def half_wave_retarder(theta):
+    """A half-wave retarder Jones matrix at angle ``theta``.
+
+    Parameters
+    ==========
+
+    theta : numeric type or SymPy Symbol
+        The angle of the fast axis relative to the horizontal plane.
+
+    Returns
+    =======
+
+    SymPy Matrix
+        A Jones matrix representing the retarder.
+
+    Examples
+    ========
+
+    A generic half-wave plate.
+
+    >>> from sympy import pprint, symbols
+    >>> from sympy.physics.optics.polarization import half_wave_retarder
+    >>> theta= symbols("theta", real=True)
+    >>> HWP = half_wave_retarder(theta)
+    >>> pprint(HWP, use_unicode=True)
+    ⎡   ⎛     2         2   ⎞                        ⎤
+    ⎢-ⅈ⋅⎝- sin (θ) + cos (θ)⎠    -2⋅ⅈ⋅sin(θ)⋅cos(θ)  ⎥
+    ⎢                                                ⎥
+    ⎢                             ⎛   2         2   ⎞⎥
+    ⎣   -2⋅ⅈ⋅sin(θ)⋅cos(θ)     -ⅈ⋅⎝sin (θ) - cos (θ)⎠⎦
+
+    """
+    return phase_retarder(theta, pi)
+
+
+def quarter_wave_retarder(theta):
+    """A quarter-wave retarder Jones matrix at angle ``theta``.
+
+    Parameters
+    ==========
+
+    theta : numeric type or SymPy Symbol
+        The angle of the fast axis relative to the horizontal plane.
+
+    Returns
+    =======
+
+    SymPy Matrix
+        A Jones matrix representing the retarder.
+
+    Examples
+    ========
+
+    A generic quarter-wave plate.
+
+    >>> from sympy import pprint, symbols
+    >>> from sympy.physics.optics.polarization import quarter_wave_retarder
+    >>> theta= symbols("theta", real=True)
+    >>> QWP = quarter_wave_retarder(theta)
+    >>> pprint(QWP, use_unicode=True)
+    ⎡                       -ⅈ⋅π            -ⅈ⋅π               ⎤
+    ⎢                       ─────           ─────              ⎥
+    ⎢⎛     2         2   ⎞    4               4                ⎥
+    ⎢⎝ⅈ⋅sin (θ) + cos (θ)⎠⋅ℯ       (1 - ⅈ)⋅ℯ     ⋅sin(θ)⋅cos(θ)⎥
+    ⎢                                                          ⎥
+    ⎢         -ⅈ⋅π                                        -ⅈ⋅π ⎥
+    ⎢         ─────                                       ─────⎥
+    ⎢           4                  ⎛   2           2   ⎞    4  ⎥
+    ⎣(1 - ⅈ)⋅ℯ     ⋅sin(θ)⋅cos(θ)  ⎝sin (θ) + ⅈ⋅cos (θ)⎠⋅ℯ     ⎦
+
+    """
+    return phase_retarder(theta, pi/2)
+
+
+def transmissive_filter(T):
+    """An attenuator Jones matrix with transmittance ``T``.
+
+    Parameters
+    ==========
+
+    T : numeric type or SymPy Symbol
+        The transmittance of the attenuator.
+
+    Returns
+    =======
+
+    SymPy Matrix
+        A Jones matrix representing the filter.
+
+    Examples
+    ========
+
+    A generic filter.
+
+    >>> from sympy import pprint, symbols
+    >>> from sympy.physics.optics.polarization import transmissive_filter
+    >>> T = symbols("T", real=True)
+    >>> NDF = transmissive_filter(T)
+    >>> pprint(NDF, use_unicode=True)
+    ⎡√T  0 ⎤
+    ⎢      ⎥
+    ⎣0   √T⎦
+
+    """
+    return Matrix([[sqrt(T), 0], [0, sqrt(T)]])
+
+
+def reflective_filter(R):
+    """A reflective filter Jones matrix with reflectance ``R``.
+
+    Parameters
+    ==========
+
+    R : numeric type or SymPy Symbol
+        The reflectance of the filter.
+
+    Returns
+    =======
+
+    SymPy Matrix
+        A Jones matrix representing the filter.
+
+    Examples
+    ========
+
+    A generic filter.
+
+    >>> from sympy import pprint, symbols
+    >>> from sympy.physics.optics.polarization import reflective_filter
+    >>> R = symbols("R", real=True)
+    >>> pprint(reflective_filter(R), use_unicode=True)
+    ⎡√R   0 ⎤
+    ⎢       ⎥
+    ⎣0   -√R⎦
+
+    """
+    return Matrix([[sqrt(R), 0], [0, -sqrt(R)]])
+
+
+def mueller_matrix(J):
+    """The Mueller matrix corresponding to Jones matrix `J`.
+
+    Parameters
+    ==========
+
+    J : SymPy Matrix
+        A Jones matrix.
+
+    Returns
+    =======
+
+    SymPy Matrix
+        The corresponding Mueller matrix.
+
+    Examples
+    ========
+
+    Generic optical components.
+
+    >>> from sympy import pprint, symbols
+    >>> from sympy.physics.optics.polarization import (mueller_matrix,
+    ...     linear_polarizer, half_wave_retarder, quarter_wave_retarder)
+    >>> theta = symbols("theta", real=True)
+
+    A linear_polarizer
+
+    >>> pprint(mueller_matrix(linear_polarizer(theta)), use_unicode=True)
+    ⎡            cos(2⋅θ)      sin(2⋅θ)     ⎤
+    ⎢  1/2       ────────      ────────    0⎥
+    ⎢               2             2         ⎥
+    ⎢                                       ⎥
+    ⎢cos(2⋅θ)  cos(4⋅θ)   1    sin(4⋅θ)     ⎥
+    ⎢────────  ──────── + ─    ────────    0⎥
+    ⎢   2         4       4       4         ⎥
+    ⎢                                       ⎥
+    ⎢sin(2⋅θ)    sin(4⋅θ)    1   cos(4⋅θ)   ⎥
+    ⎢────────    ────────    ─ - ────────  0⎥
+    ⎢   2           4        4      4       ⎥
+    ⎢                                       ⎥
+    ⎣   0           0             0        0⎦
+
+    A half-wave plate
+
+    >>> pprint(mueller_matrix(half_wave_retarder(theta)), use_unicode=True)
+    ⎡1              0                           0               0 ⎤
+    ⎢                                                             ⎥
+    ⎢        4           2                                        ⎥
+    ⎢0  8⋅sin (θ) - 8⋅sin (θ) + 1           sin(4⋅θ)            0 ⎥
+    ⎢                                                             ⎥
+    ⎢                                     4           2           ⎥
+    ⎢0          sin(4⋅θ)           - 8⋅sin (θ) + 8⋅sin (θ) - 1  0 ⎥
+    ⎢                                                             ⎥
+    ⎣0              0                           0               -1⎦
+
+    A quarter-wave plate
+
+    >>> pprint(mueller_matrix(quarter_wave_retarder(theta)), use_unicode=True)
+    ⎡1       0             0            0    ⎤
+    ⎢                                        ⎥
+    ⎢   cos(4⋅θ)   1    sin(4⋅θ)             ⎥
+    ⎢0  ──────── + ─    ────────    -sin(2⋅θ)⎥
+    ⎢      2       2       2                 ⎥
+    ⎢                                        ⎥
+    ⎢     sin(4⋅θ)    1   cos(4⋅θ)           ⎥
+    ⎢0    ────────    ─ - ────────  cos(2⋅θ) ⎥
+    ⎢        2        2      2               ⎥
+    ⎢                                        ⎥
+    ⎣0    sin(2⋅θ)     -cos(2⋅θ)        0    ⎦
+
+    """
+    A = Matrix([[1, 0, 0, 1],
+                [1, 0, 0, -1],
+                [0, 1, 1, 0],
+                [0, -I, I, 0]])
+
+    return simplify(A*TensorProduct(J, J.conjugate())*A.inv())
+
+
+def polarizing_beam_splitter(Tp=1, Rs=1, Ts=0, Rp=0, phia=0, phib=0):
+    r"""A polarizing beam splitter Jones matrix at angle `theta`.
+
+    Parameters
+    ==========
+
+    J : SymPy Matrix
+        A Jones matrix.
+    Tp : numeric type or SymPy Symbol
+        The transmissivity of the P-polarized component.
+    Rs : numeric type or SymPy Symbol
+        The reflectivity of the S-polarized component.
+    Ts : numeric type or SymPy Symbol
+        The transmissivity of the S-polarized component.
+    Rp : numeric type or SymPy Symbol
+        The reflectivity of the P-polarized component.
+    phia : numeric type or SymPy Symbol
+        The phase difference between transmitted and reflected component for
+        output mode a.
+    phib : numeric type or SymPy Symbol
+        The phase difference between transmitted and reflected component for
+        output mode b.
+
+
+    Returns
+    =======
+
+    SymPy Matrix
+        A 4x4 matrix representing the PBS. This matrix acts on a 4x1 vector
+        whose first two entries are the Jones vector on one of the PBS ports,
+        and the last two entries the Jones vector on the other port.
+
+    Examples
+    ========
+
+    Generic polarizing beam-splitter.
+
+    >>> from sympy import pprint, symbols
+    >>> from sympy.physics.optics.polarization import polarizing_beam_splitter
+    >>> Ts, Rs, Tp, Rp = symbols(r"Ts, Rs, Tp, Rp", positive=True)
+    >>> phia, phib = symbols("phi_a, phi_b", real=True)
+    >>> PBS = polarizing_beam_splitter(Tp, Rs, Ts, Rp, phia, phib)
+    >>> pprint(PBS, use_unicode=False)
+    [   ____                           ____                    ]
+    [ \/ Tp            0           I*\/ Rp           0         ]
+    [                                                          ]
+    [                  ____                       ____  I*phi_a]
+    [   0            \/ Ts            0      -I*\/ Rs *e       ]
+    [                                                          ]
+    [    ____                         ____                     ]
+    [I*\/ Rp           0            \/ Tp            0         ]
+    [                                                          ]
+    [               ____  I*phi_b                    ____      ]
+    [   0      -I*\/ Rs *e            0            \/ Ts       ]
+
+    """
+    PBS = Matrix([[sqrt(Tp), 0, I*sqrt(Rp), 0],
+                  [0, sqrt(Ts), 0, -I*sqrt(Rs)*exp(I*phia)],
+                  [I*sqrt(Rp), 0, sqrt(Tp), 0],
+                  [0, -I*sqrt(Rs)*exp(I*phib), 0, sqrt(Ts)]])
+    return PBS

llmeval-env/lib/python3.10/site-packages/sympy/physics/optics/tests/test_gaussopt.py

@@ -0,0 +1,102 @@
+from sympy.core.evalf import N
+from sympy.core.numbers import (Float, I, oo, pi)
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import atan2
+from sympy.matrices.dense import Matrix
+from sympy.polys.polytools import factor
+
+from sympy.physics.optics import (BeamParameter, CurvedMirror,
+  CurvedRefraction, FlatMirror, FlatRefraction, FreeSpace, GeometricRay,
+  RayTransferMatrix, ThinLens, conjugate_gauss_beams,
+  gaussian_conj, geometric_conj_ab, geometric_conj_af, geometric_conj_bf,
+  rayleigh2waist, waist2rayleigh)
+
+
+def streq(a, b):
+    return str(a) == str(b)
+
+
+def test_gauss_opt():
+    mat = RayTransferMatrix(1, 2, 3, 4)
+    assert mat == Matrix([[1, 2], [3, 4]])
+    assert mat == RayTransferMatrix( Matrix([[1, 2], [3, 4]]) )
+    assert [mat.A, mat.B, mat.C, mat.D] == [1, 2, 3, 4]
+
+    d, f, h, n1, n2, R = symbols('d f h n1 n2 R')
+    lens = ThinLens(f)
+    assert lens == Matrix([[   1, 0], [-1/f, 1]])
+    assert lens.C == -1/f
+    assert FreeSpace(d) == Matrix([[ 1, d], [0, 1]])
+    assert FlatRefraction(n1, n2) == Matrix([[1, 0], [0, n1/n2]])
+    assert CurvedRefraction(
+        R, n1, n2) == Matrix([[1, 0], [(n1 - n2)/(R*n2), n1/n2]])
+    assert FlatMirror() == Matrix([[1, 0], [0, 1]])
+    assert CurvedMirror(R) == Matrix([[   1, 0], [-2/R, 1]])
+    assert ThinLens(f) == Matrix([[   1, 0], [-1/f, 1]])
+
+    mul = CurvedMirror(R)*FreeSpace(d)
+    mul_mat = Matrix([[   1, 0], [-2/R, 1]])*Matrix([[ 1, d], [0, 1]])
+    assert mul.A == mul_mat[0, 0]
+    assert mul.B == mul_mat[0, 1]
+    assert mul.C == mul_mat[1, 0]
+    assert mul.D == mul_mat[1, 1]
+
+    angle = symbols('angle')
+    assert GeometricRay(h, angle) == Matrix([[    h], [angle]])
+    assert FreeSpace(
+        d)*GeometricRay(h, angle) == Matrix([[angle*d + h], [angle]])
+    assert GeometricRay( Matrix( ((h,), (angle,)) ) ) == Matrix([[h], [angle]])
+    assert (FreeSpace(d)*GeometricRay(h, angle)).height == angle*d + h
+    assert (FreeSpace(d)*GeometricRay(h, angle)).angle == angle
+
+    p = BeamParameter(530e-9, 1, w=1e-3)
+    assert streq(p.q, 1 + 1.88679245283019*I*pi)
+    assert streq(N(p.q), 1.0 + 5.92753330865999*I)
+    assert streq(N(p.w_0), Float(0.00100000000000000))
+    assert streq(N(p.z_r), Float(5.92753330865999))
+    fs = FreeSpace(10)
+    p1 = fs*p
+    assert streq(N(p.w), Float(0.00101413072159615))
+    assert streq(N(p1.w), Float(0.00210803120913829))
+
+    w, wavelen = symbols('w wavelen')
+    assert waist2rayleigh(w, wavelen) == pi*w**2/wavelen
+    z_r, wavelen = symbols('z_r wavelen')
+    assert rayleigh2waist(z_r, wavelen) == sqrt(wavelen*z_r)/sqrt(pi)
+
+    a, b, f = symbols('a b f')
+    assert geometric_conj_ab(a, b) == a*b/(a + b)
+    assert geometric_conj_af(a, f) == a*f/(a - f)
+    assert geometric_conj_bf(b, f) == b*f/(b - f)
+    assert geometric_conj_ab(oo, b) == b
+    assert geometric_conj_ab(a, oo) == a
+
+    s_in, z_r_in, f = symbols('s_in z_r_in f')
+    assert gaussian_conj(
+        s_in, z_r_in, f)[0] == 1/(-1/(s_in + z_r_in**2/(-f + s_in)) + 1/f)
+    assert gaussian_conj(
+        s_in, z_r_in, f)[1] == z_r_in/(1 - s_in**2/f**2 + z_r_in**2/f**2)
+    assert gaussian_conj(
+        s_in, z_r_in, f)[2] == 1/sqrt(1 - s_in**2/f**2 + z_r_in**2/f**2)
+
+    l, w_i, w_o, f = symbols('l w_i w_o f')
+    assert conjugate_gauss_beams(l, w_i, w_o, f=f)[0] == f*(
+        -sqrt(w_i**2/w_o**2 - pi**2*w_i**4/(f**2*l**2)) + 1)
+    assert factor(conjugate_gauss_beams(l, w_i, w_o, f=f)[1]) == f*w_o**2*(
+        w_i**2/w_o**2 - sqrt(w_i**2/w_o**2 - pi**2*w_i**4/(f**2*l**2)))/w_i**2
+    assert conjugate_gauss_beams(l, w_i, w_o, f=f)[2] == f
+
+    z, l, w_0 = symbols('z l w_0', positive=True)
+    p = BeamParameter(l, z, w=w_0)
+    assert p.radius == z*(pi**2*w_0**4/(l**2*z**2) + 1)
+    assert p.w == w_0*sqrt(l**2*z**2/(pi**2*w_0**4) + 1)
+    assert p.w_0 == w_0
+    assert p.divergence == l/(pi*w_0)
+    assert p.gouy == atan2(z, pi*w_0**2/l)
+    assert p.waist_approximation_limit == 2*l/pi
+
+    p = BeamParameter(530e-9, 1, w=1e-3, n=2)
+    assert streq(p.q, 1 + 3.77358490566038*I*pi)
+    assert streq(N(p.z_r), Float(11.8550666173200))
+    assert streq(N(p.w_0), Float(0.00100000000000000))

llmeval-env/lib/python3.10/site-packages/sympy/physics/optics/tests/test_medium.py

@@ -0,0 +1,48 @@
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.physics.optics import Medium
+from sympy.abc import epsilon, mu, n
+from sympy.physics.units import speed_of_light, u0, e0, m, kg, s, A
+
+from sympy.testing.pytest import raises
+
+c = speed_of_light.convert_to(m/s)
+e0 = e0.convert_to(A**2*s**4/(kg*m**3))
+u0 = u0.convert_to(m*kg/(A**2*s**2))
+
+
+def test_medium():
+    m1 = Medium('m1')
+    assert m1.intrinsic_impedance == sqrt(u0/e0)
+    assert m1.speed == 1/sqrt(e0*u0)
+    assert m1.refractive_index == c*sqrt(e0*u0)
+    assert m1.permittivity == e0
+    assert m1.permeability == u0
+    m2 = Medium('m2', epsilon, mu)
+    assert m2.intrinsic_impedance == sqrt(mu/epsilon)
+    assert m2.speed == 1/sqrt(epsilon*mu)
+    assert m2.refractive_index == c*sqrt(epsilon*mu)
+    assert m2.permittivity == epsilon
+    assert m2.permeability == mu
+    # Increasing electric permittivity and magnetic permeability
+    # by small amount from its value in vacuum.
+    m3 = Medium('m3', 9.0*10**(-12)*s**4*A**2/(m**3*kg), 1.45*10**(-6)*kg*m/(A**2*s**2))
+    assert m3.refractive_index > m1.refractive_index
+    assert m3 != m1
+    # Decreasing electric permittivity and magnetic permeability
+    # by small amount from its value in vacuum.
+    m4 = Medium('m4', 7.0*10**(-12)*s**4*A**2/(m**3*kg), 1.15*10**(-6)*kg*m/(A**2*s**2))
+    assert m4.refractive_index < m1.refractive_index
+    m5 = Medium('m5', permittivity=710*10**(-12)*s**4*A**2/(m**3*kg), n=1.33)
+    assert abs(m5.intrinsic_impedance - 6.24845417765552*kg*m**2/(A**2*s**3)) \
+                < 1e-12*kg*m**2/(A**2*s**3)
+    assert abs(m5.speed - 225407863.157895*m/s) < 1e-6*m/s
+    assert abs(m5.refractive_index - 1.33000000000000) < 1e-12
+    assert abs(m5.permittivity - 7.1e-10*A**2*s**4/(kg*m**3)) \
+                < 1e-20*A**2*s**4/(kg*m**3)
+    assert abs(m5.permeability - 2.77206575232851e-8*kg*m/(A**2*s**2)) \
+                < 1e-20*kg*m/(A**2*s**2)
+    m6 = Medium('m6', None, mu, n)
+    assert m6.permittivity == n**2/(c**2*mu)
+    # test for equality of refractive indices
+    assert Medium('m7').refractive_index == Medium('m8', e0, u0).refractive_index
+    raises(ValueError, lambda:Medium('m9', e0, u0, 2))

llmeval-env/lib/python3.10/site-packages/sympy/physics/optics/tests/test_polarization.py

@@ -0,0 +1,57 @@
+from sympy.physics.optics.polarization import (jones_vector, stokes_vector,
+    jones_2_stokes, linear_polarizer, phase_retarder, half_wave_retarder,
+    quarter_wave_retarder, transmissive_filter, reflective_filter,
+    mueller_matrix, polarizing_beam_splitter)
+from sympy.core.numbers import (I, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+from sympy.matrices.dense import Matrix
+
+
+def test_polarization():
+    assert jones_vector(0, 0) == Matrix([1, 0])
+    assert jones_vector(pi/2, 0) == Matrix([0, 1])
+    #################################################################
+    assert stokes_vector(0, 0) == Matrix([1, 1, 0, 0])
+    assert stokes_vector(pi/2, 0) == Matrix([1, -1, 0, 0])
+    #################################################################
+    H = jones_vector(0, 0)
+    V = jones_vector(pi/2, 0)
+    D = jones_vector(pi/4, 0)
+    A = jones_vector(-pi/4, 0)
+    R = jones_vector(0, pi/4)
+    L = jones_vector(0, -pi/4)
+
+    res = [Matrix([1, 1, 0, 0]),
+           Matrix([1, -1, 0, 0]),
+           Matrix([1, 0, 1, 0]),
+           Matrix([1, 0, -1, 0]),
+           Matrix([1, 0, 0, 1]),
+           Matrix([1, 0, 0, -1])]
+
+    assert [jones_2_stokes(e) for e in [H, V, D, A, R, L]] == res
+    #################################################################
+    assert linear_polarizer(0) == Matrix([[1, 0], [0, 0]])
+    #################################################################
+    delta = symbols("delta", real=True)
+    res = Matrix([[exp(-I*delta/2), 0], [0, exp(I*delta/2)]])
+    assert phase_retarder(0, delta) == res
+    #################################################################
+    assert half_wave_retarder(0) == Matrix([[-I, 0], [0, I]])
+    #################################################################
+    res = Matrix([[exp(-I*pi/4), 0], [0, I*exp(-I*pi/4)]])
+    assert quarter_wave_retarder(0) == res
+    #################################################################
+    assert transmissive_filter(1) == Matrix([[1, 0], [0, 1]])
+    #################################################################
+    assert reflective_filter(1) == Matrix([[1, 0], [0, -1]])
+
+    res = Matrix([[S(1)/2, S(1)/2, 0, 0],
+                  [S(1)/2, S(1)/2, 0, 0],
+                  [0, 0, 0, 0],
+                  [0, 0, 0, 0]])
+    assert mueller_matrix(linear_polarizer(0)) == res
+    #################################################################
+    res = Matrix([[1, 0, 0, 0], [0, 0, 0, -I], [0, 0, 1, 0], [0, -I, 0, 0]])
+    assert polarizing_beam_splitter() == res

llmeval-env/lib/python3.10/site-packages/sympy/physics/optics/tests/test_utils.py

@@ -0,0 +1,202 @@
+from sympy.core.numbers import comp, Rational
+from sympy.physics.optics.utils import (refraction_angle, fresnel_coefficients,
+        deviation, brewster_angle, critical_angle, lens_makers_formula,
+        mirror_formula, lens_formula, hyperfocal_distance,
+        transverse_magnification)
+from sympy.physics.optics.medium import Medium
+from sympy.physics.units import e0
+
+from sympy.core.numbers import oo
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.matrices.dense import Matrix
+from sympy.geometry.point import Point3D
+from sympy.geometry.line import Ray3D
+from sympy.geometry.plane import Plane
+
+from sympy.testing.pytest import raises
+
+
+ae = lambda a, b, n: comp(a, b, 10**-n)
+
+
+def test_refraction_angle():
+    n1, n2 = symbols('n1, n2')
+    m1 = Medium('m1')
+    m2 = Medium('m2')
+    r1 = Ray3D(Point3D(-1, -1, 1), Point3D(0, 0, 0))
+    i = Matrix([1, 1, 1])
+    n = Matrix([0, 0, 1])
+    normal_ray = Ray3D(Point3D(0, 0, 0), Point3D(0, 0, 1))
+    P = Plane(Point3D(0, 0, 0), normal_vector=[0, 0, 1])
+    assert refraction_angle(r1, 1, 1, n) == Matrix([
+                                            [ 1],
+                                            [ 1],
+                                            [-1]])
+    assert refraction_angle([1, 1, 1], 1, 1, n) == Matrix([
+                                            [ 1],
+                                            [ 1],
+                                            [-1]])
+    assert refraction_angle((1, 1, 1), 1, 1, n) == Matrix([
+                                            [ 1],
+                                            [ 1],
+                                            [-1]])
+    assert refraction_angle(i, 1, 1, [0, 0, 1]) == Matrix([
+                                            [ 1],
+                                            [ 1],
+                                            [-1]])
+    assert refraction_angle(i, 1, 1, (0, 0, 1)) == Matrix([
+                                            [ 1],
+                                            [ 1],
+                                            [-1]])
+    assert refraction_angle(i, 1, 1, normal_ray) == Matrix([
+                                            [ 1],
+                                            [ 1],
+                                            [-1]])
+    assert refraction_angle(i, 1, 1, plane=P) == Matrix([
+                                            [ 1],
+                                            [ 1],
+                                            [-1]])
+    assert refraction_angle(r1, 1, 1, plane=P) == \
+        Ray3D(Point3D(0, 0, 0), Point3D(1, 1, -1))
+    assert refraction_angle(r1, m1, 1.33, plane=P) == \
+        Ray3D(Point3D(0, 0, 0), Point3D(Rational(100, 133), Rational(100, 133), -789378201649271*sqrt(3)/1000000000000000))
+    assert refraction_angle(r1, 1, m2, plane=P) == \
+        Ray3D(Point3D(0, 0, 0), Point3D(1, 1, -1))
+    assert refraction_angle(r1, n1, n2, plane=P) == \
+        Ray3D(Point3D(0, 0, 0), Point3D(n1/n2, n1/n2, -sqrt(3)*sqrt(-2*n1**2/(3*n2**2) + 1)))
+    assert refraction_angle(r1, 1.33, 1, plane=P) == 0  # TIR
+    assert refraction_angle(r1, 1, 1, normal_ray) == \
+        Ray3D(Point3D(0, 0, 0), direction_ratio=[1, 1, -1])
+    assert ae(refraction_angle(0.5, 1, 2), 0.24207, 5)
+    assert ae(refraction_angle(0.5, 2, 1), 1.28293, 5)
+    raises(ValueError, lambda: refraction_angle(r1, m1, m2, normal_ray, P))
+    raises(TypeError, lambda: refraction_angle(m1, m1, m2)) # can add other values for arg[0]
+    raises(TypeError, lambda: refraction_angle(r1, m1, m2, None, i))
+    raises(TypeError, lambda: refraction_angle(r1, m1, m2, m2))
+
+
+def test_fresnel_coefficients():
+    assert all(ae(i, j, 5) for i, j in zip(
+        fresnel_coefficients(0.5, 1, 1.33),
+        [0.11163, -0.17138, 0.83581, 0.82862]))
+    assert all(ae(i, j, 5) for i, j in zip(
+        fresnel_coefficients(0.5, 1.33, 1),
+        [-0.07726, 0.20482, 1.22724, 1.20482]))
+    m1 = Medium('m1')
+    m2 = Medium('m2', n=2)
+    assert all(ae(i, j, 5) for i, j in zip(
+        fresnel_coefficients(0.3, m1, m2),
+        [0.31784, -0.34865, 0.65892, 0.65135]))
+    ans = [[-0.23563, -0.97184], [0.81648, -0.57738]]
+    got = fresnel_coefficients(0.6, m2, m1)
+    for i, j in zip(got, ans):
+        for a, b in zip(i.as_real_imag(), j):
+            assert ae(a, b, 5)
+
+
+def test_deviation():
+    n1, n2 = symbols('n1, n2')
+    r1 = Ray3D(Point3D(-1, -1, 1), Point3D(0, 0, 0))
+    n = Matrix([0, 0, 1])
+    i = Matrix([-1, -1, -1])
+    normal_ray = Ray3D(Point3D(0, 0, 0), Point3D(0, 0, 1))
+    P = Plane(Point3D(0, 0, 0), normal_vector=[0, 0, 1])
+    assert deviation(r1, 1, 1, normal=n) == 0
+    assert deviation(r1, 1, 1, plane=P) == 0
+    assert deviation(r1, 1, 1.1, plane=P).evalf(3) + 0.119 < 1e-3
+    assert deviation(i, 1, 1.1, normal=normal_ray).evalf(3) + 0.119 < 1e-3
+    assert deviation(r1, 1.33, 1, plane=P) is None  # TIR
+    assert deviation(r1, 1, 1, normal=[0, 0, 1]) == 0
+    assert deviation([-1, -1, -1], 1, 1, normal=[0, 0, 1]) == 0
+    assert ae(deviation(0.5, 1, 2), -0.25793, 5)
+    assert ae(deviation(0.5, 2, 1), 0.78293, 5)
+
+
+def test_brewster_angle():
+    m1 = Medium('m1', n=1)
+    m2 = Medium('m2', n=1.33)
+    assert ae(brewster_angle(m1, m2), 0.93, 2)
+    m1 = Medium('m1', permittivity=e0, n=1)
+    m2 = Medium('m2', permittivity=e0, n=1.33)
+    assert ae(brewster_angle(m1, m2), 0.93, 2)
+    assert ae(brewster_angle(1, 1.33), 0.93, 2)
+
+
+def test_critical_angle():
+    m1 = Medium('m1', n=1)
+    m2 = Medium('m2', n=1.33)
+    assert ae(critical_angle(m2, m1), 0.85, 2)
+
+
+def test_lens_makers_formula():
+    n1, n2 = symbols('n1, n2')
+    m1 = Medium('m1', permittivity=e0, n=1)
+    m2 = Medium('m2', permittivity=e0, n=1.33)
+    assert lens_makers_formula(n1, n2, 10, -10) == 5.0*n2/(n1 - n2)
+    assert ae(lens_makers_formula(m1, m2, 10, -10), -20.15, 2)
+    assert ae(lens_makers_formula(1.33, 1, 10, -10),  15.15, 2)
+
+
+def test_mirror_formula():
+    u, v, f = symbols('u, v, f')
+    assert mirror_formula(focal_length=f, u=u) == f*u/(-f + u)
+    assert mirror_formula(focal_length=f, v=v) == f*v/(-f + v)
+    assert mirror_formula(u=u, v=v) == u*v/(u + v)
+    assert mirror_formula(u=oo, v=v) == v
+    assert mirror_formula(u=oo, v=oo) is oo
+    assert mirror_formula(focal_length=oo, u=u) == -u
+    assert mirror_formula(u=u, v=oo) == u
+    assert mirror_formula(focal_length=oo, v=oo) is oo
+    assert mirror_formula(focal_length=f, v=oo) == f
+    assert mirror_formula(focal_length=oo, v=v) == -v
+    assert mirror_formula(focal_length=oo, u=oo) is oo
+    assert mirror_formula(focal_length=f, u=oo) == f
+    assert mirror_formula(focal_length=oo, u=u) == -u
+    raises(ValueError, lambda: mirror_formula(focal_length=f, u=u, v=v))
+
+
+def test_lens_formula():
+    u, v, f = symbols('u, v, f')
+    assert lens_formula(focal_length=f, u=u) == f*u/(f + u)
+    assert lens_formula(focal_length=f, v=v) == f*v/(f - v)
+    assert lens_formula(u=u, v=v) == u*v/(u - v)
+    assert lens_formula(u=oo, v=v) == v
+    assert lens_formula(u=oo, v=oo) is oo
+    assert lens_formula(focal_length=oo, u=u) == u
+    assert lens_formula(u=u, v=oo) == -u
+    assert lens_formula(focal_length=oo, v=oo) is -oo
+    assert lens_formula(focal_length=oo, v=v) == v
+    assert lens_formula(focal_length=f, v=oo) == -f
+    assert lens_formula(focal_length=oo, u=oo) is oo
+    assert lens_formula(focal_length=oo, u=u) == u
+    assert lens_formula(focal_length=f, u=oo) == f
+    raises(ValueError, lambda: lens_formula(focal_length=f, u=u, v=v))
+
+
+def test_hyperfocal_distance():
+    f, N, c = symbols('f, N, c')
+    assert hyperfocal_distance(f=f, N=N, c=c) == f**2/(N*c)
+    assert ae(hyperfocal_distance(f=0.5, N=8, c=0.0033), 9.47, 2)
+
+
+def test_transverse_magnification():
+    si, so = symbols('si, so')
+    assert transverse_magnification(si, so) == -si/so
+    assert transverse_magnification(30, 15) == -2
+
+
+def test_lens_makers_formula_thick_lens():
+    n1, n2 = symbols('n1, n2')
+    m1 = Medium('m1', permittivity=e0, n=1)
+    m2 = Medium('m2', permittivity=e0, n=1.33)
+    assert ae(lens_makers_formula(m1, m2, 10, -10, d=1), -19.82, 2)
+    assert lens_makers_formula(n1, n2, 1, -1, d=0.1) == n2/((2.0 - (0.1*n1 - 0.1*n2)/n1)*(n1 - n2))
+
+
+def test_lens_makers_formula_plano_lens():
+    n1, n2 = symbols('n1, n2')
+    m1 = Medium('m1', permittivity=e0, n=1)
+    m2 = Medium('m2', permittivity=e0, n=1.33)
+    assert ae(lens_makers_formula(m1, m2, 10, oo), -40.30, 2)
+    assert lens_makers_formula(n1, n2, 10, oo) == 10.0*n2/(n1 - n2)

llmeval-env/lib/python3.10/site-packages/sympy/physics/optics/tests/test_waves.py

@@ -0,0 +1,82 @@
+from sympy.core.function import (Derivative, Function)
+from sympy.core.numbers import (I, pi)
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (atan2, cos, sin)
+from sympy.simplify.simplify import simplify
+from sympy.abc import epsilon, mu
+from sympy.functions.elementary.exponential import exp
+from sympy.physics.units import speed_of_light, m, s
+from sympy.physics.optics import TWave
+
+from sympy.testing.pytest import raises
+
+c = speed_of_light.convert_to(m/s)
+
+def test_twave():
+    A1, phi1, A2, phi2, f = symbols('A1, phi1, A2, phi2, f')
+    n = Symbol('n')  # Refractive index
+    t = Symbol('t')  # Time
+    x = Symbol('x')  # Spatial variable
+    E = Function('E')
+    w1 = TWave(A1, f, phi1)
+    w2 = TWave(A2, f, phi2)
+    assert w1.amplitude == A1
+    assert w1.frequency == f
+    assert w1.phase == phi1
+    assert w1.wavelength == c/(f*n)
+    assert w1.time_period == 1/f
+    assert w1.angular_velocity == 2*pi*f
+    assert w1.wavenumber == 2*pi*f*n/c
+    assert w1.speed == c/n
+
+    w3 = w1 + w2
+    assert w3.amplitude == sqrt(A1**2 + 2*A1*A2*cos(phi1 - phi2) + A2**2)
+    assert w3.frequency == f
+    assert w3.phase == atan2(A1*sin(phi1) + A2*sin(phi2), A1*cos(phi1) + A2*cos(phi2))
+    assert w3.wavelength == c/(f*n)
+    assert w3.time_period == 1/f
+    assert w3.angular_velocity == 2*pi*f
+    assert w3.wavenumber == 2*pi*f*n/c
+    assert w3.speed == c/n
+    assert simplify(w3.rewrite(sin) - w2.rewrite(sin) - w1.rewrite(sin)) == 0
+    assert w3.rewrite('pde') == epsilon*mu*Derivative(E(x, t), t, t) + Derivative(E(x, t), x, x)
+    assert w3.rewrite(cos) == sqrt(A1**2 + 2*A1*A2*cos(phi1 - phi2)
+        + A2**2)*cos(pi*f*n*x*s/(149896229*m) - 2*pi*f*t + atan2(A1*sin(phi1)
+        + A2*sin(phi2), A1*cos(phi1) + A2*cos(phi2)))
+    assert w3.rewrite(exp) == sqrt(A1**2 + 2*A1*A2*cos(phi1 - phi2)
+        + A2**2)*exp(I*(-2*pi*f*t + atan2(A1*sin(phi1) + A2*sin(phi2), A1*cos(phi1)
+        + A2*cos(phi2)) + pi*s*f*n*x/(149896229*m)))
+
+    w4 = TWave(A1, None, 0, 1/f)
+    assert w4.frequency == f
+
+    w5 = w1 - w2
+    assert w5.amplitude == sqrt(A1**2 - 2*A1*A2*cos(phi1 - phi2) + A2**2)
+    assert w5.frequency == f
+    assert w5.phase == atan2(A1*sin(phi1) - A2*sin(phi2), A1*cos(phi1) - A2*cos(phi2))
+    assert w5.wavelength == c/(f*n)
+    assert w5.time_period == 1/f
+    assert w5.angular_velocity == 2*pi*f
+    assert w5.wavenumber == 2*pi*f*n/c
+    assert w5.speed == c/n
+    assert simplify(w5.rewrite(sin) - w1.rewrite(sin) + w2.rewrite(sin)) == 0
+    assert w5.rewrite('pde') == epsilon*mu*Derivative(E(x, t), t, t) + Derivative(E(x, t), x, x)
+    assert w5.rewrite(cos) == sqrt(A1**2 - 2*A1*A2*cos(phi1 - phi2)
+        + A2**2)*cos(-2*pi*f*t + atan2(A1*sin(phi1) - A2*sin(phi2), A1*cos(phi1)
+        - A2*cos(phi2)) + pi*s*f*n*x/(149896229*m))
+    assert w5.rewrite(exp) == sqrt(A1**2 - 2*A1*A2*cos(phi1 - phi2)
+        + A2**2)*exp(I*(-2*pi*f*t + atan2(A1*sin(phi1) - A2*sin(phi2), A1*cos(phi1)
+        - A2*cos(phi2)) + pi*s*f*n*x/(149896229*m)))
+
+    w6 = 2*w1
+    assert w6.amplitude == 2*A1
+    assert w6.frequency == f
+    assert w6.phase == phi1
+    w7 = -w6
+    assert w7.amplitude == -2*A1
+    assert w7.frequency == f
+    assert w7.phase == phi1
+
+    raises(ValueError, lambda:TWave(A1))
+    raises(ValueError, lambda:TWave(A1, f, phi1, t))

llmeval-env/lib/python3.10/site-packages/sympy/physics/optics/utils.py

@@ -0,0 +1,698 @@
+"""
+**Contains**
+
+* refraction_angle
+* fresnel_coefficients
+* deviation
+* brewster_angle
+* critical_angle
+* lens_makers_formula
+* mirror_formula
+* lens_formula
+* hyperfocal_distance
+* transverse_magnification
+"""
+
+__all__ = ['refraction_angle',
+           'deviation',
+           'fresnel_coefficients',
+           'brewster_angle',
+           'critical_angle',
+           'lens_makers_formula',
+           'mirror_formula',
+           'lens_formula',
+           'hyperfocal_distance',
+           'transverse_magnification'
+           ]
+
+from sympy.core.numbers import (Float, I, oo, pi, zoo)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, asin, atan2, cos, sin, tan)
+from sympy.matrices.dense import Matrix
+from sympy.polys.polytools import cancel
+from sympy.series.limits import Limit
+from sympy.geometry.line import Ray3D
+from sympy.geometry.util import intersection
+from sympy.geometry.plane import Plane
+from sympy.utilities.iterables import is_sequence
+from .medium import Medium
+
+
+def refractive_index_of_medium(medium):
+    """
+    Helper function that returns refractive index, given a medium
+    """
+    if isinstance(medium, Medium):
+        n = medium.refractive_index
+    else:
+        n = sympify(medium)
+    return n
+
+
+def refraction_angle(incident, medium1, medium2, normal=None, plane=None):
+    """
+    This function calculates transmitted vector after refraction at planar
+    surface. ``medium1`` and ``medium2`` can be ``Medium`` or any sympifiable object.
+    If ``incident`` is a number then treated as angle of incidence (in radians)
+    in which case refraction angle is returned.
+
+    If ``incident`` is an object of `Ray3D`, `normal` also has to be an instance
+    of `Ray3D` in order to get the output as a `Ray3D`. Please note that if
+    plane of separation is not provided and normal is an instance of `Ray3D`,
+    ``normal`` will be assumed to be intersecting incident ray at the plane of
+    separation. This will not be the case when `normal` is a `Matrix` or
+    any other sequence.
+    If ``incident`` is an instance of `Ray3D` and `plane` has not been provided
+    and ``normal`` is not `Ray3D`, output will be a `Matrix`.
+
+    Parameters
+    ==========
+
+    incident : Matrix, Ray3D, sequence or a number
+        Incident vector or angle of incidence
+    medium1 : sympy.physics.optics.medium.Medium or sympifiable
+        Medium 1 or its refractive index
+    medium2 : sympy.physics.optics.medium.Medium or sympifiable
+        Medium 2 or its refractive index
+    normal : Matrix, Ray3D, or sequence
+        Normal vector
+    plane : Plane
+        Plane of separation of the two media.
+
+    Returns
+    =======
+
+    Returns an angle of refraction or a refracted ray depending on inputs.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import refraction_angle
+    >>> from sympy.geometry import Point3D, Ray3D, Plane
+    >>> from sympy.matrices import Matrix
+    >>> from sympy import symbols, pi
+    >>> n = Matrix([0, 0, 1])
+    >>> P = Plane(Point3D(0, 0, 0), normal_vector=[0, 0, 1])
+    >>> r1 = Ray3D(Point3D(-1, -1, 1), Point3D(0, 0, 0))
+    >>> refraction_angle(r1, 1, 1, n)
+    Matrix([
+    [ 1],
+    [ 1],
+    [-1]])
+    >>> refraction_angle(r1, 1, 1, plane=P)
+    Ray3D(Point3D(0, 0, 0), Point3D(1, 1, -1))
+
+    With different index of refraction of the two media
+
+    >>> n1, n2 = symbols('n1, n2')
+    >>> refraction_angle(r1, n1, n2, n)
+    Matrix([
+    [                                n1/n2],
+    [                                n1/n2],
+    [-sqrt(3)*sqrt(-2*n1**2/(3*n2**2) + 1)]])
+    >>> refraction_angle(r1, n1, n2, plane=P)
+    Ray3D(Point3D(0, 0, 0), Point3D(n1/n2, n1/n2, -sqrt(3)*sqrt(-2*n1**2/(3*n2**2) + 1)))
+    >>> round(refraction_angle(pi/6, 1.2, 1.5), 5)
+    0.41152
+    """
+
+    n1 = refractive_index_of_medium(medium1)
+    n2 = refractive_index_of_medium(medium2)
+
+    # check if an incidence angle was supplied instead of a ray
+    try:
+        angle_of_incidence = float(incident)
+    except TypeError:
+        angle_of_incidence = None
+
+    try:
+        critical_angle_ = critical_angle(medium1, medium2)
+    except (ValueError, TypeError):
+        critical_angle_ = None
+
+    if angle_of_incidence is not None:
+        if normal is not None or plane is not None:
+            raise ValueError('Normal/plane not allowed if incident is an angle')
+
+        if not 0.0 <= angle_of_incidence < pi*0.5:
+            raise ValueError('Angle of incidence not in range [0:pi/2)')
+
+        if critical_angle_ and angle_of_incidence > critical_angle_:
+            raise ValueError('Ray undergoes total internal reflection')
+        return asin(n1*sin(angle_of_incidence)/n2)
+
+    # Treat the incident as ray below
+    # A flag to check whether to return Ray3D or not
+    return_ray = False
+
+    if plane is not None and normal is not None:
+        raise ValueError("Either plane or normal is acceptable.")
+
+    if not isinstance(incident, Matrix):
+        if is_sequence(incident):
+            _incident = Matrix(incident)
+        elif isinstance(incident, Ray3D):
+            _incident = Matrix(incident.direction_ratio)
+        else:
+            raise TypeError(
+                "incident should be a Matrix, Ray3D, or sequence")
+    else:
+        _incident = incident
+
+    # If plane is provided, get direction ratios of the normal
+    # to the plane from the plane else go with `normal` param.
+    if plane is not None:
+        if not isinstance(plane, Plane):
+            raise TypeError("plane should be an instance of geometry.plane.Plane")
+        # If we have the plane, we can get the intersection
+        # point of incident ray and the plane and thus return
+        # an instance of Ray3D.
+        if isinstance(incident, Ray3D):
+            return_ray = True
+            intersection_pt = plane.intersection(incident)[0]
+        _normal = Matrix(plane.normal_vector)
+    else:
+        if not isinstance(normal, Matrix):
+            if is_sequence(normal):
+                _normal = Matrix(normal)
+            elif isinstance(normal, Ray3D):
+                _normal = Matrix(normal.direction_ratio)
+                if isinstance(incident, Ray3D):
+                    intersection_pt = intersection(incident, normal)
+                    if len(intersection_pt) == 0:
+                        raise ValueError(
+                            "Normal isn't concurrent with the incident ray.")
+                    else:
+                        return_ray = True
+                        intersection_pt = intersection_pt[0]
+            else:
+                raise TypeError(
+                    "Normal should be a Matrix, Ray3D, or sequence")
+        else:
+            _normal = normal
+
+    eta = n1/n2  # Relative index of refraction
+    # Calculating magnitude of the vectors
+    mag_incident = sqrt(sum([i**2 for i in _incident]))
+    mag_normal = sqrt(sum([i**2 for i in _normal]))
+    # Converting vectors to unit vectors by dividing
+    # them with their magnitudes
+    _incident /= mag_incident
+    _normal /= mag_normal
+    c1 = -_incident.dot(_normal)  # cos(angle_of_incidence)
+    cs2 = 1 - eta**2*(1 - c1**2)  # cos(angle_of_refraction)**2
+    if cs2.is_negative:  # This is the case of total internal reflection(TIR).
+        return S.Zero
+    drs = eta*_incident + (eta*c1 - sqrt(cs2))*_normal
+    # Multiplying unit vector by its magnitude
+    drs = drs*mag_incident
+    if not return_ray:
+        return drs
+    else:
+        return Ray3D(intersection_pt, direction_ratio=drs)
+
+
+def fresnel_coefficients(angle_of_incidence, medium1, medium2):
+    """
+    This function uses Fresnel equations to calculate reflection and
+    transmission coefficients. Those are obtained for both polarisations
+    when the electric field vector is in the plane of incidence (labelled 'p')
+    and when the electric field vector is perpendicular to the plane of
+    incidence (labelled 's'). There are four real coefficients unless the
+    incident ray reflects in total internal in which case there are two complex
+    ones. Angle of incidence is the angle between the incident ray and the
+    surface normal. ``medium1`` and ``medium2`` can be ``Medium`` or any
+    sympifiable object.
+
+    Parameters
+    ==========
+
+    angle_of_incidence : sympifiable
+
+    medium1 : Medium or sympifiable
+        Medium 1 or its refractive index
+
+    medium2 : Medium or sympifiable
+        Medium 2 or its refractive index
+
+    Returns
+    =======
+
+    Returns a list with four real Fresnel coefficients:
+    [reflection p (TM), reflection s (TE),
+    transmission p (TM), transmission s (TE)]
+    If the ray is undergoes total internal reflection then returns a
+    list of two complex Fresnel coefficients:
+    [reflection p (TM), reflection s (TE)]
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import fresnel_coefficients
+    >>> fresnel_coefficients(0.3, 1, 2)
+    [0.317843553417859, -0.348645229818821,
+            0.658921776708929, 0.651354770181179]
+    >>> fresnel_coefficients(0.6, 2, 1)
+    [-0.235625382192159 - 0.971843958291041*I,
+             0.816477005968898 - 0.577377951366403*I]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Fresnel_equations
+    """
+    if not 0 <= 2*angle_of_incidence < pi:
+        raise ValueError('Angle of incidence not in range [0:pi/2)')
+
+    n1 = refractive_index_of_medium(medium1)
+    n2 = refractive_index_of_medium(medium2)
+
+    angle_of_refraction = asin(n1*sin(angle_of_incidence)/n2)
+    try:
+        angle_of_total_internal_reflection_onset = critical_angle(n1, n2)
+    except ValueError:
+        angle_of_total_internal_reflection_onset = None
+
+    if angle_of_total_internal_reflection_onset is None or\
+    angle_of_total_internal_reflection_onset > angle_of_incidence:
+        R_s = -sin(angle_of_incidence - angle_of_refraction)\
+                /sin(angle_of_incidence + angle_of_refraction)
+        R_p = tan(angle_of_incidence - angle_of_refraction)\
+                /tan(angle_of_incidence + angle_of_refraction)
+        T_s = 2*sin(angle_of_refraction)*cos(angle_of_incidence)\
+                /sin(angle_of_incidence + angle_of_refraction)
+        T_p = 2*sin(angle_of_refraction)*cos(angle_of_incidence)\
+                /(sin(angle_of_incidence + angle_of_refraction)\
+                *cos(angle_of_incidence - angle_of_refraction))
+        return [R_p, R_s, T_p, T_s]
+    else:
+        n = n2/n1
+        R_s = cancel((cos(angle_of_incidence)-\
+                I*sqrt(sin(angle_of_incidence)**2 - n**2))\
+                /(cos(angle_of_incidence)+\
+                I*sqrt(sin(angle_of_incidence)**2 - n**2)))
+        R_p = cancel((n**2*cos(angle_of_incidence)-\
+                I*sqrt(sin(angle_of_incidence)**2 - n**2))\
+                /(n**2*cos(angle_of_incidence)+\
+                I*sqrt(sin(angle_of_incidence)**2 - n**2)))
+        return [R_p, R_s]
+
+
+def deviation(incident, medium1, medium2, normal=None, plane=None):
+    """
+    This function calculates the angle of deviation of a ray
+    due to refraction at planar surface.
+
+    Parameters
+    ==========
+
+    incident : Matrix, Ray3D, sequence or float
+        Incident vector or angle of incidence
+    medium1 : sympy.physics.optics.medium.Medium or sympifiable
+        Medium 1 or its refractive index
+    medium2 : sympy.physics.optics.medium.Medium or sympifiable
+        Medium 2 or its refractive index
+    normal : Matrix, Ray3D, or sequence
+        Normal vector
+    plane : Plane
+        Plane of separation of the two media.
+
+    Returns angular deviation between incident and refracted rays
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import deviation
+    >>> from sympy.geometry import Point3D, Ray3D, Plane
+    >>> from sympy.matrices import Matrix
+    >>> from sympy import symbols
+    >>> n1, n2 = symbols('n1, n2')
+    >>> n = Matrix([0, 0, 1])
+    >>> P = Plane(Point3D(0, 0, 0), normal_vector=[0, 0, 1])
+    >>> r1 = Ray3D(Point3D(-1, -1, 1), Point3D(0, 0, 0))
+    >>> deviation(r1, 1, 1, n)
+    0
+    >>> deviation(r1, n1, n2, plane=P)
+    -acos(-sqrt(-2*n1**2/(3*n2**2) + 1)) + acos(-sqrt(3)/3)
+    >>> round(deviation(0.1, 1.2, 1.5), 5)
+    -0.02005
+    """
+    refracted = refraction_angle(incident,
+                                 medium1,
+                                 medium2,
+                                 normal=normal,
+                                 plane=plane)
+    try:
+        angle_of_incidence = Float(incident)
+    except TypeError:
+        angle_of_incidence = None
+
+    if angle_of_incidence is not None:
+        return float(refracted) - angle_of_incidence
+
+    if refracted != 0:
+        if isinstance(refracted, Ray3D):
+            refracted = Matrix(refracted.direction_ratio)
+
+        if not isinstance(incident, Matrix):
+            if is_sequence(incident):
+                _incident = Matrix(incident)
+            elif isinstance(incident, Ray3D):
+                _incident = Matrix(incident.direction_ratio)
+            else:
+                raise TypeError(
+                    "incident should be a Matrix, Ray3D, or sequence")
+        else:
+            _incident = incident
+
+        if plane is None:
+            if not isinstance(normal, Matrix):
+                if is_sequence(normal):
+                    _normal = Matrix(normal)
+                elif isinstance(normal, Ray3D):
+                    _normal = Matrix(normal.direction_ratio)
+                else:
+                    raise TypeError(
+                        "normal should be a Matrix, Ray3D, or sequence")
+            else:
+                _normal = normal
+        else:
+            _normal = Matrix(plane.normal_vector)
+
+        mag_incident = sqrt(sum([i**2 for i in _incident]))
+        mag_normal = sqrt(sum([i**2 for i in _normal]))
+        mag_refracted = sqrt(sum([i**2 for i in refracted]))
+        _incident /= mag_incident
+        _normal /= mag_normal
+        refracted /= mag_refracted
+        i = acos(_incident.dot(_normal))
+        r = acos(refracted.dot(_normal))
+        return i - r
+
+
+def brewster_angle(medium1, medium2):
+    """
+    This function calculates the Brewster's angle of incidence to Medium 2 from
+    Medium 1 in radians.
+
+    Parameters
+    ==========
+
+    medium 1 : Medium or sympifiable
+        Refractive index of Medium 1
+    medium 2 : Medium or sympifiable
+        Refractive index of Medium 1
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import brewster_angle
+    >>> brewster_angle(1, 1.33)
+    0.926093295503462
+
+    """
+
+    n1 = refractive_index_of_medium(medium1)
+    n2 = refractive_index_of_medium(medium2)
+
+    return atan2(n2, n1)
+
+def critical_angle(medium1, medium2):
+    """
+    This function calculates the critical angle of incidence (marking the onset
+    of total internal) to Medium 2 from Medium 1 in radians.
+
+    Parameters
+    ==========
+
+    medium 1 : Medium or sympifiable
+        Refractive index of Medium 1.
+    medium 2 : Medium or sympifiable
+        Refractive index of Medium 1.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import critical_angle
+    >>> critical_angle(1.33, 1)
+    0.850908514477849
+
+    """
+
+    n1 = refractive_index_of_medium(medium1)
+    n2 = refractive_index_of_medium(medium2)
+
+    if n2 > n1:
+        raise ValueError('Total internal reflection impossible for n1 < n2')
+    else:
+        return asin(n2/n1)
+
+
+
+def lens_makers_formula(n_lens, n_surr, r1, r2, d=0):
+    """
+    This function calculates focal length of a lens.
+    It follows cartesian sign convention.
+
+    Parameters
+    ==========
+
+    n_lens : Medium or sympifiable
+        Index of refraction of lens.
+    n_surr : Medium or sympifiable
+        Index of reflection of surrounding.
+    r1 : sympifiable
+        Radius of curvature of first surface.
+    r2 : sympifiable
+        Radius of curvature of second surface.
+    d : sympifiable, optional
+        Thickness of lens, default value is 0.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import lens_makers_formula
+    >>> from sympy import S
+    >>> lens_makers_formula(1.33, 1, 10, -10)
+    15.1515151515151
+    >>> lens_makers_formula(1.2, 1, 10, S.Infinity)
+    50.0000000000000
+    >>> lens_makers_formula(1.33, 1, 10, -10, d=1)
+    15.3418463277618
+
+    """
+
+    if isinstance(n_lens, Medium):
+        n_lens = n_lens.refractive_index
+    else:
+        n_lens = sympify(n_lens)
+    if isinstance(n_surr, Medium):
+        n_surr = n_surr.refractive_index
+    else:
+        n_surr = sympify(n_surr)
+    d = sympify(d)
+
+    focal_length = 1/((n_lens - n_surr) / n_surr*(1/r1 - 1/r2 + (((n_lens - n_surr) * d) / (n_lens * r1 * r2))))
+
+    if focal_length == zoo:
+        return S.Infinity
+    return focal_length
+
+
+def mirror_formula(focal_length=None, u=None, v=None):
+    """
+    This function provides one of the three parameters
+    when two of them are supplied.
+    This is valid only for paraxial rays.
+
+    Parameters
+    ==========
+
+    focal_length : sympifiable
+        Focal length of the mirror.
+    u : sympifiable
+        Distance of object from the pole on
+        the principal axis.
+    v : sympifiable
+        Distance of the image from the pole
+        on the principal axis.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import mirror_formula
+    >>> from sympy.abc import f, u, v
+    >>> mirror_formula(focal_length=f, u=u)
+    f*u/(-f + u)
+    >>> mirror_formula(focal_length=f, v=v)
+    f*v/(-f + v)
+    >>> mirror_formula(u=u, v=v)
+    u*v/(u + v)
+
+    """
+    if focal_length and u and v:
+        raise ValueError("Please provide only two parameters")
+
+    focal_length = sympify(focal_length)
+    u = sympify(u)
+    v = sympify(v)
+    if u is oo:
+        _u = Symbol('u')
+    if v is oo:
+        _v = Symbol('v')
+    if focal_length is oo:
+        _f = Symbol('f')
+    if focal_length is None:
+        if u is oo and v is oo:
+            return Limit(Limit(_v*_u/(_v + _u), _u, oo), _v, oo).doit()
+        if u is oo:
+            return Limit(v*_u/(v + _u), _u, oo).doit()
+        if v is oo:
+            return Limit(_v*u/(_v + u), _v, oo).doit()
+        return v*u/(v + u)
+    if u is None:
+        if v is oo and focal_length is oo:
+            return Limit(Limit(_v*_f/(_v - _f), _v, oo), _f, oo).doit()
+        if v is oo:
+            return Limit(_v*focal_length/(_v - focal_length), _v, oo).doit()
+        if focal_length is oo:
+            return Limit(v*_f/(v - _f), _f, oo).doit()
+        return v*focal_length/(v - focal_length)
+    if v is None:
+        if u is oo and focal_length is oo:
+            return Limit(Limit(_u*_f/(_u - _f), _u, oo), _f, oo).doit()
+        if u is oo:
+            return Limit(_u*focal_length/(_u - focal_length), _u, oo).doit()
+        if focal_length is oo:
+            return Limit(u*_f/(u - _f), _f, oo).doit()
+        return u*focal_length/(u - focal_length)
+
+
+def lens_formula(focal_length=None, u=None, v=None):
+    """
+    This function provides one of the three parameters
+    when two of them are supplied.
+    This is valid only for paraxial rays.
+
+    Parameters
+    ==========
+
+    focal_length : sympifiable
+        Focal length of the mirror.
+    u : sympifiable
+        Distance of object from the optical center on
+        the principal axis.
+    v : sympifiable
+        Distance of the image from the optical center
+        on the principal axis.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.optics import lens_formula
+    >>> from sympy.abc import f, u, v
+    >>> lens_formula(focal_length=f, u=u)
+    f*u/(f + u)
+    >>> lens_formula(focal_length=f, v=v)
+    f*v/(f - v)
+    >>> lens_formula(u=u, v=v)
+    u*v/(u - v)
+
+    """
+    if focal_length and u and v:
+        raise ValueError("Please provide only two parameters")
+
+    focal_length = sympify(focal_length)
+    u = sympify(u)
+    v = sympify(v)
+    if u is oo:
+        _u = Symbol('u')
+    if v is oo:
+        _v = Symbol('v')
+    if focal_length is oo:
+        _f = Symbol('f')
+    if focal_length is None:
+        if u is oo and v is oo:
+            return Limit(Limit(_v*_u/(_u - _v), _u, oo), _v, oo).doit()
+        if u is oo:
+            return Limit(v*_u/(_u - v), _u, oo).doit()
+        if v is oo:
+            return Limit(_v*u/(u - _v), _v, oo).doit()
+        return v*u/(u - v)
+    if u is None:
+        if v is oo and focal_length is oo:
+            return Limit(Limit(_v*_f/(_f - _v), _v, oo), _f, oo).doit()
+        if v is oo:
+            return Limit(_v*focal_length/(focal_length - _v), _v, oo).doit()
+        if focal_length is oo:
+            return Limit(v*_f/(_f - v), _f, oo).doit()
+        return v*focal_length/(focal_length - v)
+    if v is None:
+        if u is oo and focal_length is oo:
+            return Limit(Limit(_u*_f/(_u + _f), _u, oo), _f, oo).doit()
+        if u is oo:
+            return Limit(_u*focal_length/(_u + focal_length), _u, oo).doit()
+        if focal_length is oo:
+            return Limit(u*_f/(u + _f), _f, oo).doit()
+        return u*focal_length/(u + focal_length)
+
+def hyperfocal_distance(f, N, c):
+    """
+
+    Parameters
+    ==========
+
+    f: sympifiable
+        Focal length of a given lens.
+
+    N: sympifiable
+        F-number of a given lens.
+
+    c: sympifiable
+        Circle of Confusion (CoC) of a given image format.
+
+    Example
+    =======
+
+    >>> from sympy.physics.optics import hyperfocal_distance
+    >>> round(hyperfocal_distance(f = 0.5, N = 8, c = 0.0033), 2)
+    9.47
+    """
+
+    f = sympify(f)
+    N = sympify(N)
+    c = sympify(c)
+
+    return (1/(N * c))*(f**2)
+
+def transverse_magnification(si, so):
+    """
+
+    Calculates the transverse magnification, which is the ratio of the
+    image size to the object size.
+
+    Parameters
+    ==========
+
+    so: sympifiable
+        Lens-object distance.
+
+    si: sympifiable
+        Lens-image distance.
+
+    Example
+    =======
+
+    >>> from sympy.physics.optics import transverse_magnification
+    >>> transverse_magnification(30, 15)
+    -2
+
+    """
+
+    si = sympify(si)
+    so = sympify(so)
+
+    return (-(si/so))