Skip to content

Block Diagram Algebra & Interconnections

algebra

System interconnection and block diagram algebra functions.

series 

series(*systems)

Connect two or more systems in series (cascade).

The output of each system is connected to the input of the next system:

.. math::

u \longrightarrow G_1(s) \longrightarrow G_2(s) \longrightarrow \cdots \longrightarrow G_n(s) \longrightarrow y

The equivalent transfer function is the product of individual blocks:

.. math::

G_{\text{total}}(s) = G_n(s) \cdots G_2(s) G_1(s)

Parameters:

Name Type Description Default
*systems LinearTimeInvariant | float | int | number

Two or more systems (or scalar gains) to cascade in order.

 ()

Returns:

Type Description
LinearTimeInvariant

The resulting series-connected system.

Raises:

Type Description
ValueError

If no systems are provided.
Source code in src/ctrlpy/algebra.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
def series(
    *systems: LinearTimeInvariant | float | np.number[Any],
) -> LinearTimeInvariant:
    r"""Connect two or more systems in series (cascade).

    The output of each system is connected to the input of the next system:

    .. math::

        u \longrightarrow G_1(s) \longrightarrow G_2(s) \longrightarrow \cdots \longrightarrow G_n(s) \longrightarrow y

    The equivalent transfer function is the product of individual blocks:

    .. math::

        G_{\text{total}}(s) = G_n(s) \cdots G_2(s) G_1(s)

    Parameters
    ----------
    *systems : LinearTimeInvariant | float | int | np.number
        Two or more systems (or scalar gains) to cascade in order.

    Returns
    -------
    LinearTimeInvariant
        The resulting series-connected system.

    Raises
    ------
    ValueError
        If no systems are provided.
    """
    if not systems:
        raise ValueError("At least one system must be provided for series connection.")

    first = systems[0]
    res: LinearTimeInvariant = (
        first if isinstance(first, LinearTimeInvariant) else TransferFunction(float(first), 1.0)
    )

    for sys in systems[1:]:
        sys_obj = sys if isinstance(sys, LinearTimeInvariant) else TransferFunction(float(sys), 1.0)
        # Cascade order: u -> res -> sys_obj -> y
        res = sys_obj * res

    return res

parallel 

parallel(*systems)

Connect two or more systems in parallel.

Inputs are connected together and outputs are summed:

.. math::

y(t) = \sum_{i=1}^n y_i(t)

The equivalent transfer function is the sum of individual blocks:

.. math::

G_{\text{total}}(s) = G_1(s) + G_2(s) + \cdots + G_n(s)

Parameters:

Name Type Description Default
*systems LinearTimeInvariant | float | int | number

Two or more systems (or scalar gains) to connect in parallel.

 ()

Returns:

Type Description
LinearTimeInvariant

The resulting parallel-connected system.

Raises:

Type Description
ValueError

If no systems are provided.
Source code in src/ctrlpy/algebra.py 
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
def parallel(
    *systems: LinearTimeInvariant | float | np.number[Any],
) -> LinearTimeInvariant:
    r"""Connect two or more systems in parallel.

    Inputs are connected together and outputs are summed:

    .. math::

        y(t) = \sum_{i=1}^n y_i(t)

    The equivalent transfer function is the sum of individual blocks:

    .. math::

        G_{\text{total}}(s) = G_1(s) + G_2(s) + \cdots + G_n(s)

    Parameters
    ----------
    *systems : LinearTimeInvariant | float | int | np.number
        Two or more systems (or scalar gains) to connect in parallel.

    Returns
    -------
    LinearTimeInvariant
        The resulting parallel-connected system.

    Raises
    ------
    ValueError
        If no systems are provided.
    """
    if not systems:
        raise ValueError("At least one system must be provided for parallel connection.")

    first = systems[0]
    res: LinearTimeInvariant = (
        first if isinstance(first, LinearTimeInvariant) else TransferFunction(float(first), 1.0)
    )

    for sys in systems[1:]:
        sys_obj = sys if isinstance(sys, LinearTimeInvariant) else TransferFunction(float(sys), 1.0)
        res = res + sys_obj

    return res

feedback 

feedback(sys1, sys2=1, sign=-1)

Connect two systems in a closed-loop feedback interconnection.

The closed-loop system relates reference \(r(t)\) to output \(y(t)\):

.. math::

e(t) = r(t) + \text{sign} \cdot (H y)(t), \quad y(t) = (G e)(t)

The closed-loop transfer function is given by:

.. math::

T(s) = \frac{G(s)}{1 - \text{sign} \cdot G(s) H(s)}

For standard negative feedback (\(\text{sign} = -1\)):

.. math::

T(s) = \frac{G(s)}{1 + G(s) H(s)}

Parameters:

Name Type Description Default
sys1 LinearTimeInvariant | float | int | number

Forward path system \(G(s)\).

 required
sys2 LinearTimeInvariant | float | int | number

Feedback path system \(H(s)\), defaults to 1 (unity feedback).

 1
sign int | float

Feedback sign. Defaults to -1 for standard negative feedback.

 -1

Returns:

Type Description
LinearTimeInvariant

Closed-loop system \(T(s)\).
Source code in src/ctrlpy/algebra.py 
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
def feedback(
    sys1: LinearTimeInvariant | float | np.number[Any],
    sys2: LinearTimeInvariant | float | np.number[Any] = 1,
    sign: float = -1,
) -> LinearTimeInvariant:
    r"""Connect two systems in a closed-loop feedback interconnection.

    The closed-loop system relates reference $r(t)$ to output $y(t)$:

    .. math::

        e(t) = r(t) + \text{sign} \cdot (H y)(t), \quad y(t) = (G e)(t)

    The closed-loop transfer function is given by:

    .. math::

        T(s) = \frac{G(s)}{1 - \text{sign} \cdot G(s) H(s)}

    For standard negative feedback ($\text{sign} = -1$):

    .. math::

        T(s) = \frac{G(s)}{1 + G(s) H(s)}

    Parameters
    ----------
    sys1 : LinearTimeInvariant | float | int | np.number
        Forward path system $G(s)$.
    sys2 : LinearTimeInvariant | float | int | np.number, optional
        Feedback path system $H(s)$, defaults to 1 (unity feedback).
    sign : int | float, optional
        Feedback sign. Defaults to -1 for standard negative feedback.

    Returns
    -------
    LinearTimeInvariant
        Closed-loop system $T(s)$.
    """
    sys1_obj: LinearTimeInvariant = (
        sys1 if isinstance(sys1, LinearTimeInvariant) else TransferFunction(float(sys1), 1.0)
    )
    if hasattr(sys1_obj, "feedback"):
        result: LinearTimeInvariant = sys1_obj.feedback(sys2, sign=sign)
        return result
    raise TypeError(f"System {type(sys1_obj).__name__} does not support feedback interconnection.")