Consider a causal, LTI, single-input single-output system with zero initial conditions and transfer function \( G(s) = \dfrac{Y(s)}{U(s)} \), where \( U(s) \) and \( Y(s) \) are Laplace transforms of the input and output. For a sinusoidal input at angular frequency \( \omega \), using complex exponentials we write

\[ u(t) = \Re\{ \hat{U} e^{j\omega t} \}, \quad \hat{U} \in \mathbb{C}, \]

where \( \hat{U} \) is a complex amplitude (phasor). The corresponding Laplace transform (for sufficiently small real part of \( s \)) can be written as

\[ U(s) = \mathcal{L}\{u(t)\}(s) = \frac{\hat{U}}{s - j\omega} + \text{(terms analytic at } s=j\omega \text{)}. \]

The output in the Laplace domain is \( Y(s) = G(s) U(s) \). After partial fraction expansion, the term corresponding to the pole at \( s = j\omega \) has residue \( G(j\omega)\hat{U} \). Its inverse Laplace transform is \( \Re\{ G(j\omega)\hat{U} e^{j\omega t} \} \), which does not decay and therefore represents the sinusoidal steady-state component.

Writing the complex frequency response in polar form

\[ G(j\omega) = \lvert G(j\omega) \rvert e^{j\varphi(\omega)}, \quad \varphi(\omega) = \arg G(j\omega), \]

the steady-state output for input amplitude \( U_0 = \lvert \hat{U} \rvert \) and input phase \( \phi_u = \arg \hat{U} \) is

\[ y_{\text{ss}}(t) = \lvert G(j\omega) \rvert U_0 \cos\big( \omega t + \phi_u + \varphi(\omega) \big). \]

Thus, for each real frequency \( \omega \), \( G(j\omega) \) gives a complex gain that scales the sinusoidal amplitude by \( \lvert G(j\omega) \rvert \) and shifts the phase by \( \varphi(\omega) \).

flowchart TD
  A["Transfer function G(s)"] --> B["Choose sinusoidal frequency w"]
  B --> C["Substitute s = j*w"]
  C --> D["Complex value G(j*w)"]
  D --> E["Magnitude |G(j*w)| (gain)"]
  D --> F["Phase arg(G(j*w)) (shift)"]
  E --> G["Steady-state output amplitude"]
  F --> G
        

Most control systems in this course are modeled by real-rational transfer functions of the form

\[ G(s) = \frac{b_m s^m + b_{m-1} s^{m-1} + \dots + b_0}{a_n s^n + a_{n-1} s^{n-1} + \dots + a_0}, \quad a_n \neq 0, \]

or equivalently using poles and zeros:

\[ G(s) = K \frac{\prod_{i=1}^{n_z} (s - z_i)}{\prod_{k=1}^{n_p} (s - p_k)}, \]

where \( z_i \) are zeros, \( p_k \) are poles, \( K \in \mathbb{R} \) is a real gain, \( n_p \) is the number of poles, and \( n_z \) is the number of zeros (counting multiplicities).

The frequency response is defined as the restriction of \( G(s) \) to the imaginary axis:

\[ G(j\omega) \triangleq G(s)\big\lvert_{s = j\omega}, \quad \omega \in \mathbb{R}. \]

Substituting \( s = j\omega \) into the pole-zero form yields

\[ G(j\omega) = K \frac{\prod_{i=1}^{n_z} \big(j\omega - z_i\big)} {\prod_{k=1}^{n_p} \big(j\omega - p_k\big)}. \]

Using basic complex-number properties, the magnitude and phase decompose additively over poles and zeros:

\[ \lvert G(j\omega) \rvert = \lvert K \rvert \frac{\prod_{i=1}^{n_z} \lvert j\omega - z_i \rvert} {\prod_{k=1}^{n_p} \lvert j\omega - p_k \rvert}, \]

\[ \varphi(\omega) = \arg G(j\omega) = \arg K + \sum_{i=1}^{n_z} \arg\big(j\omega - z_i\big) - \sum_{k=1}^{n_p} \arg\big(j\omega - p_k\big). \]

Because the coefficients are real, complex poles and zeros appear in conjugate pairs. This implies the important symmetry property

\[ G(-j\omega) = \overline{G(j\omega)}, \quad \lvert G(-j\omega) \rvert = \lvert G(j\omega) \rvert,\quad \varphi(-\omega) = -\varphi(\omega). \]

This even-odd symmetry of magnitude and phase will be used later when we draw frequency-response plots.

A standard first-order low-pass transfer function (for example, the current dynamics in a DC motor driver or a simple RC filter) can be written as

\[ G(s) = \frac{K}{1 + T s}, \]

where \( K \) is the static gain and \( T > 0 \) is a time constant. Evaluating the frequency response:

\[ G(j\omega) = \frac{K}{1 + T j\omega}. \]

Expressing denominator magnitude and phase, \( 1 + T j\omega = 1 + jT\omega \), so

\[ \lvert 1 + jT\omega \rvert = \sqrt{1 + (T\omega)^2}, \quad \arg(1 + jT\omega) = \arctan\big(T\omega\big). \]

Therefore the magnitude and phase of the frequency response are

\[ \lvert G(j\omega) \rvert = \frac{\lvert K \rvert}{\sqrt{1 + (T\omega)^2}}, \]

\[ \varphi(\omega) = - \arctan\big(T\omega\big). \]

Limiting behavior:

• As \( \omega \to 0 \): \( \lvert G(j\omega) \rvert \to \lvert K \rvert \) and \( \varphi(\omega) \to 0 \). Low-frequency sinusoids experience almost no attenuation and negligible phase lag.
• As \( \omega \to \infty \): \( \lvert G(j\omega) \rvert \sim \dfrac{\lvert K \rvert}{T\omega} \) and \( \varphi(\omega) \to -\dfrac{\pi}{2} \). High frequencies are strongly attenuated and lag by about 90 degrees.

For input \( u(t) = U_0 \cos(\omega t) \), the steady-state output is

\[ y_{\text{ss}}(t) = \frac{\lvert K \rvert}{\sqrt{1 + (T\omega)^2}} U_0 \cos\big(\omega t - \arctan(T\omega)\big). \]

This first-order case already shows the typical low-pass behavior that will be crucial in understanding more complex robotic actuators and filters.

A standard second-order transfer function (such as a lightly damped robot joint with inertia and viscous friction) is

\[ G(s) = \frac{\omega_n^2}{s^2 + 2\zeta\omega_n s + \omega_n^2}, \quad \omega_n > 0,\; \zeta \ge 0, \]

where \( \omega_n \) is the natural frequency and \( \zeta \) is the damping ratio. Evaluate the frequency response:

\[ G(j\omega) = \frac{\omega_n^2}{(j\omega)^2 + 2\zeta\omega_n (j\omega) + \omega_n^2} = \frac{\omega_n^2}{\omega_n^2 - \omega^2 + j\,2\zeta\omega_n \omega }. \]

The magnitude and phase are therefore

\[ \lvert G(j\omega) \rvert = \frac{\omega_n^2} {\sqrt{\big(\omega_n^2 - \omega^2\big)^2 + \big(2\zeta\omega_n\omega\big)^2 }}, \]

\[ \varphi(\omega) = -\arctan\!\left( \frac{2\zeta\omega_n\omega}{\omega_n^2 - \omega^2} \right). \]

Qualitatively, when \( \zeta \) is small, the magnitude \( \lvert G(j\omega) \rvert \) may show a peak near \( \omega \approx \omega_n \) (resonant behavior), and the phase transitions from 0 degrees at very low frequency to approximately \( -180^\circ \) at very high frequency.

These formulas form the basis for understanding resonant peaks and bandwidth in the next lesson, where we will explore their design implications in detail.

For implementation on a computer, it is convenient to work directly with polynomial coefficients. Suppose

\[ G(s) = \frac{b_0 + b_1 s + \dots + b_m s^m} {a_0 + a_1 s + \dots + a_n s^n}, \]

where \( a_0, \dots, a_n \) and \( b_0, \dots, b_m \) are real. For each frequency \( \omega_k \) in a chosen grid \( \{\omega_k\}_{k=1}^N \):

1. Set \( s_k = j\omega_k \).
2. Evaluate the numerator polynomial \( N(s_k) = b_0 + b_1 s_k + \dots + b_m s_k^m \).
3. Evaluate the denominator polynomial \( D(s_k) = a_0 + a_1 s_k + \dots + a_n s_k^n \).
4. Compute \( G(j\omega_k) = N(s_k) / D(s_k) \).
5. Store \( \lvert G(j\omega_k) \rvert = \sqrt{\Re^2 + \Im^2} \) and \( \varphi(\omega_k) = \arctan2(\Im, \Re) \).

This basic algorithm underlies the frequency-response computation in most control libraries and can be implemented efficiently using vectorized operations or complex arithmetic in any language.

flowchart TD
  P["Physical or robot model"] --> Q["Derive linear G(s)"]
  Q --> R["Choose frequency grid w_k"]
  R --> S["Compute G(j*w_k) using complex arithmetic"]
  S --> T["Extract |G| and phase for analysis or controller tuning"]
        

In Python, we can implement frequency-response computations both from scratch and via control libraries frequently used in robotics, such as python-control. Below we illustrate both for a first-order actuator model \( G(s) = \dfrac{K}{1 + T s} \).

6.1 From-Scratch Numerical Evaluation

import numpy as np

# First-order low-pass: G(s) = K / (1 + T s)
K = 2.0
T = 0.1

def G_of_s(s: complex) -> complex:
    """Evaluate G(s) = K / (1 + T s) at complex s."""
    return K / (1.0 + T * s)

# Frequency grid (rad/s)
omega = np.logspace(-1, 3, 200)  # 0.1 to 1000 rad/s
s = 1j * omega

Gjw = np.array([G_of_s(sk) for sk in s])
mag = np.abs(Gjw)
phase = np.angle(Gjw)  # radians

for w, m, p in zip(omega[::50], mag[::50], phase[::50]):
    print(f"w = {w:7.3f} rad/s, |G(jw)| = {m:7.3f}, phase = {p:7.3f} rad")
      

6.2 Using python-control for Robotic Plants

The python-control library offers a high-level interface to transfer functions and frequency response. Consider a simple robot joint model \( G(s) = \dfrac{K}{J s + B} \), where \( J \) is inertia and \( B \) is viscous friction.

import numpy as np
import control as ct  # python-control

# Joint model parameters (example)
J = 0.01   # inertia
B = 0.1    # damping
K = 0.5    # torque-to-position static gain (simplified)

# G(s) = K / (J s + B)
num = [K]
den = [J, B]
G = ct.TransferFunction(num, den)

# Frequency grid
omega = np.logspace(-1, 3, 300)  # rad/s

# Frequency response
# freqresp returns a complex array Gjw of shape (outputs, inputs, len(omega))
Gjw = ct.freqresp(G, omega)[0][0, 0, :]  # SISO: extract scalar response

mag = np.abs(Gjw)
phase = np.angle(Gjw)

# Example: print a few values
for w, m, p in zip(omega[::60], mag[::60], phase[::60]):
    print(f"w = {w:7.3f}, |G(jw)| = {m:7.3f}, phase = {p:7.3f} rad")
      

Such tools are routinely combined with robotics frameworks (e.g., ROS-based robots) to analyze actuator frequency response, tune PID gains, and understand sensor/actuator bandwidth limitations.

In C++, the standard library <complex> provides complex arithmetic suitable for implementing \( G(j\omega) \). The following example evaluates the frequency response of \( G(s) = \dfrac{K}{1 + T s} \). This logic can be embedded in a ROS node for online analysis of robot actuators.

#include <iostream>
#include <complex>
#include <vector>

int main() {
    double K = 2.0;
    double T = 0.1;
    std::vector<double> omega = {0.1, 1.0, 10.0, 100.0}; // rad/s

    std::complex<double> j(0.0, 1.0);

    auto G_of_s = [&](std::complex<double> s) {
        return K / (1.0 + T * s);
    };

    for (double w : omega) {
        std::complex<double> s = j * w;
        std::complex<double> G = G_of_s(s);

        double mag = std::abs(G);
        double phase = std::arg(G); // radians

        std::cout << "w = " << w
                  << " rad/s, |G(jw)| = " << mag
                  << ", phase = " << phase
                  << " rad" << std::endl;
    }

    return 0;
}
      

In robotics applications, one typically derives \( G(s) \) from the mechanical parameters of a joint or link, then wraps this computation into reusable functions or classes (often together with linear algebra libraries such as Eigen) to study the closed-loop frequency response with controllers.

Java does not have a built-in complex type, but widely used libraries such as Apache Commons Math provide Complex classes. Below is an example using org.apache.commons.math3.complex.Complex to compute \( G(j\omega) \).

import org.apache.commons.math3.complex.Complex;

public class FrequencyResponseExample {
    // G(s) = K / (1 + T s)
    private static double K = 2.0;
    private static double T = 0.1;

    public static Complex GofS(Complex s) {
        return new Complex(K, 0.0).divide(
                new Complex(1.0, 0.0).add(s.multiply(T)));
    }

    public static void main(String[] args) {
        double[] omega = {0.1, 1.0, 10.0, 100.0}; // rad/s
        Complex j = new Complex(0.0, 1.0);

        for (double w : omega) {
            Complex s = j.multiply(w);
            Complex G = GofS(s);

            double mag = G.abs();
            double phase = G.getArgument(); // radians

            System.out.printf("w = %7.3f rad/s, |G(jw)| = %7.3f, phase = %7.3f rad%n",
                              w, mag, phase);
        }
    }
}
      

In many mobile-robot and autonomous-systems software stacks implemented in Java (for example, FIRST Robotics libraries such as WPILib), transfer-function and state-space utilities are provided. These can be combined with code similar to the above for systematic frequency-domain analysis of drivetrain and arm dynamics.

MATLAB includes a Control System Toolbox that represents transfer functions and provides high-level functions for frequency response. Consider again the joint model \( G(s) = \dfrac{K}{J s + B} \).

% Parameters
J = 0.01;   % inertia
B = 0.1;    % viscous friction
K = 0.5;    % gain

s = tf('s');
G = K / (J * s + B);   % Transfer function object

% Frequency grid (rad/s)
w = logspace(-1, 3, 300);

% Frequency response
[mag, phase, wout] = bode(G, w);   % mag, phase are 3-D arrays
mag = squeeze(mag);                % convert to column vectors
phase = squeeze(phase);

% Example: display a few points
for k = 1:50:length(wout)
    fprintf('w = %7.3f rad/s, |G(jw)| = %7.3f, phase = %7.3f deg\n', ...
            wout(k), mag(k), phase(k));
end
      

In Simulink, the same frequency response can be studied by connecting a Transfer Fcn block implementing \( G(s) \) to a sinusoidal input (e.g., Sine Wave block) and observing the steady-state output amplitude and phase shift as the input frequency is varied. Robotics-oriented toolboxes such as Robotics System Toolbox integrate these models with kinematic and dynamic robot descriptions.

Wolfram Mathematica provides symbolic manipulation and control-system functions that are convenient for both closed-form and numeric frequency-response analysis. The snippet below constructs a first-order transfer function and plots \( \lvert G(j\omega) \rvert \) and \( \varphi(\omega) \).

(* Parameters *)
K = 2.0;
T = 0.1;

(* Transfer function model: G(s) = K / (1 + T s) *)
s =. ; (* clear s if defined *)
G = TransferFunctionModel[{K}, {T, 1}, s];

(* Frequency-response plots over [0.1, 100] rad/s *)
magPlot = BodePlot[G, {10^-1, 10^2},
  PlotLayout -> "Magnitude",
  GridLines -> Automatic,
  FrameLabel -> {"w (rad/s)", "|G(j w)|"}];

phasePlot = BodePlot[G, {10^-1, 10^2},
  PlotLayout -> "Phase",
  GridLines -> Automatic,
  FrameLabel -> {"w (rad/s)", "phase(G(j w))"}];

Show[magPlot]
Show[phasePlot]

(* Direct numeric evaluation of G(j w) *)
wList = Table[10^x, {x, -1, 2, 0.5}];
Gjw = { #, Evaluate[TransferFunctionResponse[G, I #]] } & /@ wList
      

Symbolic capabilities are useful, for example, to derive exact expressions for \( \lvert G(j\omega) \rvert \) of higher-order systems before approximating or simplifying them for controller design.

Problem 1 (Frequency Response of a Second-Order System): Consider the standard second-order system

\[ G(s) = \frac{\omega_n^2}{s^2 + 2\zeta\omega_n s + \omega_n^2}, \quad \omega_n > 0, \; \zeta \ge 0. \]

Derive \( G(j\omega) \) and expressions for \( \lvert G(j\omega) \rvert \) and \( \varphi(\omega) \).

Solution:

Substitute \( s = j\omega \):

\[ G(j\omega) = \frac{\omega_n^2}{(j\omega)^2 + 2\zeta\omega_n (j\omega) + \omega_n^2} = \frac{\omega_n^2}{\omega_n^2 - \omega^2 + j\,2\zeta\omega_n\omega}. \]

Real and imaginary parts of the denominator are \( \omega_n^2 - \omega^2 \) and \( 2\zeta\omega_n\omega \), respectively, hence

\[ \lvert G(j\omega) \rvert = \frac{\omega_n^2} {\sqrt{\big(\omega_n^2 - \omega^2\big)^2 + \big(2\zeta\omega_n\omega\big)^2}}, \]

\[ \varphi(\omega) = -\arctan\!\left( \frac{2\zeta\omega_n\omega}{\omega_n^2 - \omega^2} \right). \]

This matches the derivation in Section 4.

Problem 2 (Conjugate Symmetry of Frequency Response): Let \( G(s) \) be real-rational with no poles on the imaginary axis. Show that \( G(-j\omega) = \overline{G(j\omega)} \).

Solution:

Write \( G(s) = N(s)/D(s) \), where \( N(s) \) and \( D(s) \) have real coefficients. For any complex number \( z \), since the coefficients are real, \( \overline{N(z)} = N(\overline{z}) \) and \( \overline{D(z)} = D(\overline{z}) \). Take \( z = j\omega \), then

\[ \overline{G(j\omega)} = \overline{\frac{N(j\omega)}{D(j\omega)}} = \frac{\overline{N(j\omega)}}{\overline{D(j\omega)}} = \frac{N(-j\omega)}{D(-j\omega)} = G(-j\omega). \]

Consequently, \( \lvert G(j\omega) \rvert \) is even in \( \omega \) and \( \varphi(\omega) \) is odd.

Problem 3 (Monotonic Magnitude of First-Order Low-Pass): For the first-order low-pass transfer function \( G(s) = \dfrac{K}{1 + T s} \) with \( K > 0 \) and \( T > 0 \), show that \( \lvert G(j\omega) \rvert \) is strictly decreasing in \( \omega > 0 \).

Solution:

From Section 3, \( \lvert G(j\omega) \rvert = \dfrac{K}{\sqrt{1 + (T\omega)^2}} \). Consider

\[ f(\omega) = \lvert G(j\omega) \rvert = \frac{K}{\sqrt{1 + T^2\omega^2}}, \quad \omega > 0. \]

Differentiate with respect to \( \omega \):

\[ f'(\omega) = K \cdot \left(-\tfrac{1}{2}\right) (1 + T^2\omega^2)^{-3/2} (2 T^2 \omega) = - \frac{K T^2 \omega}{(1 + T^2\omega^2)^{3/2}}. \]

For \( K > 0, T > 0, \omega > 0 \), we have \( f'(\omega) < 0 \). Hence \( \lvert G(j\omega) \rvert \) is strictly decreasing on \( \omega > 0 \), confirming the low-pass nature.

Problem 4 (Low- and High-Frequency Limits of a Robot Joint Model): Consider the joint model \( G(s) = \dfrac{K}{J s + B} \) with \( J > 0 \), \( B > 0 \), \( K > 0 \). Compute \( \lim_{\omega \to 0} G(j\omega) \) and \( \lim_{\omega \to \infty} G(j\omega) \), and interpret the result.

Solution:

Frequency response: \( G(j\omega) = \dfrac{K}{B + jJ\omega} \).

• As \( \omega \to 0 \): \( G(j\omega) \to \dfrac{K}{B} \) (pure real). The DC gain is \( K/B \), so constant inputs are amplified by this factor.
• As \( \omega \to \infty \): \( G(j\omega) \sim \dfrac{K}{jJ\omega} \), so \( \lvert G(j\omega) \rvert \sim \dfrac{K}{J\omega} \) tends to 0, and the phase tends to \( -\dfrac{\pi}{2} \). Very fast sinusoidal inputs are strongly attenuated and lag the torque command by 90 degrees.

This explains why actuators with inertia cannot follow arbitrarily fast reference trajectories.

Problem 5 (Algorithm for Polynomial Transfer Functions): Let

\[ G(s) = \frac{b_0 + b_1 s + b_2 s^2}{a_0 + a_1 s + a_2 s^2}, \]

with real coefficients and \( a_0 a_2 \neq 0 \). Describe an algorithm to compute \( \lvert G(j\omega_k) \rvert \) and \( \varphi(\omega_k) \) for a set of frequencies \( \{\omega_k\} \), and explain why complex arithmetic is convenient.

Solution:

For each \( \omega_k \):

1. Set \( s_k = j\omega_k \).
2. Compute \( N_k = b_0 + b_1 s_k + b_2 s_k^2 \), \( D_k = a_0 + a_1 s_k + a_2 s_k^2 \).
3. Compute \( G_k = N_k / D_k \).
4. Set \( \lvert G(j\omega_k) \rvert = \sqrt{\Re(G_k)^2 + \Im(G_k)^2} \) and \( \varphi(\omega_k) = \arctan2(\Im(G_k), \Re(G_k)) \).

Complex arithmetic is convenient because polynomial evaluation and division are expressed with the same formulas as in the real case, but with complex numbers. The language runtime (Python, C++, Java, MATLAB, Mathematica) handles the algebra of real and imaginary parts internally, simplifying implementation.

In this lesson we connected the Laplace-domain transfer function \( G(s) \) with the sinusoidal steady-state response via the complex frequency response \( G(j\omega) \). We showed that for rational transfer functions with real coefficients, \( G(j\omega) \) is obtained by substituting \( s = j\omega \), and its magnitude and phase decompose into contributions from poles and zeros. We derived explicit formulas for first- and second-order systems, highlighting low-pass behavior and resonant characteristics that are central to control of robotic actuators.

Numerically, frequency response is computed by evaluating polynomials at complex points using standard complex arithmetic, an approach implemented consistently across Python, C++, Java, MATLAB/Simulink, and Mathematica. These concepts set the stage for the next lessons, where we quantify resonant peaks, bandwidth, and damping and eventually develop graphical tools such as Bode and Nyquist plots.