In linear control, especially for mechatronic and robotic systems, we constantly deal with signals that are combinations of exponentials and sinusoids. For a scalar LTI (linear time-invariant) system governed by a constant-coefficient ODE,

\[ a_n \frac{d^n x(t)}{dt^n} + a_{n-1} \frac{d^{n-1} x(t)}{dt^{n-1}} + \cdots + a_1 \frac{dx(t)}{dt} + a_0 x(t) = b_m \frac{d^m u(t)}{dt^m} + \cdots + b_0 u(t), \]

exponential trial solutions of the form \( x(t) = e^{s t} \) naturally lead us to complex numbers when the characteristic polynomial has complex roots. For sinusoidal inputs (e.g. torque ripple in a robot motor, or oscillatory disturbances on a drone), it is mathematically and computationally convenient to use complex exponentials and phasors:

• Complex numbers provide a 2D algebra for amplitude and phase.
• Complex exponentials encode oscillations in a simple multiplicative form.
• Phasors are time-independent complex numbers that summarize sinusoidal signals.

flowchart TD
  A["ODE with constant coefficients"] --> B["Assume x(t) = exp(s t)"]
  B --> C["Characteristic polynomial in s"]
  C --> D["Complex roots: s = sigma + j*omega"]
  D --> E["Time response: exp(sigma t) * cos/sin(omega t)"]
  E --> F["Represent oscillatory part using a phasor (magnitude + angle)"]
        

We write complex numbers using the engineering convention \( j^2 = -1 \) instead of \( i^2 = -1 \). A complex number \( z \) has the rectangular form

\[ z = x + j y, \quad x = \Re\{z\}, \; y = \Im\{z\}, \]

and the polar (or modulus-argument) form

\[ z = r e^{j\theta}, \quad r = |z| = \sqrt{x^2 + y^2}, \quad \theta = \arg(z) = \operatorname{atan2}(y,x). \]

The conjugate of \( z \) is \( \overline{z} = x - j y \), and it satisfies

\[ z \overline{z} = (x + j y)(x - j y) = x^2 + y^2 = |z|^2. \]

Addition is componentwise:

\[ (x_1 + j y_1) + (x_2 + j y_2) = (x_1 + x_2) + j (y_1 + y_2), \]

and multiplication is given by

\[ (x_1 + j y_1)(x_2 + j y_2) = (x_1 x_2 - y_1 y_2) + j(x_1 y_2 + x_2 y_1). \]

In polar form this multiplication law becomes especially simple and extremely useful in control:

\[ z_1 = r_1 e^{j\theta_1},\; z_2 = r_2 e^{j\theta_2} \;\Rightarrow\; z_1 z_2 = (r_1 r_2) e^{j(\theta_1 + \theta_2)}. \]

Thus, complex multiplication corresponds geometrically to scaling by \( r_1 \) and rotating by angle \( \theta_1 \) in the complex plane. This "gain and phase" viewpoint is precisely how we will later interpret controllers and plant dynamics in the frequency domain.

The exponential series

\[ e^{z} = \sum_{k=0}^{\infty} \frac{z^k}{k!} \]

converges for every complex \( z \in \mathbb{C} \). In particular, for purely imaginary arguments \( z = j\theta \) we obtain the fundamental identity

\[ e^{j\theta} = \cos\theta + j\sin\theta, \]

known as Euler's formula. One way to see this is to separate the power series into even and odd indices and compare with the Taylor series of cosine and sine.

For a general complex number \( s = \sigma + j\omega \) (with real \( \sigma,\,\omega \)), we have

\[ e^{s t} = e^{(\sigma + j\omega)t} = e^{\sigma t} e^{j\omega t} = e^{\sigma t}\big( \cos(\omega t) + j\sin(\omega t) \big). \]

This shows that \( e^{s t} \) represents an exponentially scaled sinusoid: \( \sigma \) controls growth or decay, while \( \omega \) controls angular frequency. Complex eigenvalues of dynamical systems lead to such responses, which will be interpreted in the \( s \)-plane in later chapters.

Consider a real sinusoid

\[ x(t) = A\cos(\omega t + \varphi), \]

where \( A > 0 \) is amplitude, \( \omega \) is angular frequency, and \( \varphi \) is phase. Using Euler's formula,

\[ \cos(\omega t + \varphi) = \Re\{ e^{j(\omega t + \varphi)} \} = \Re\{ e^{j\varphi} e^{j\omega t} \}, \]

we can write

\[ x(t) = \Re\{ A e^{j\varphi} e^{j\omega t} \}. \]

The time-varying factor is \( e^{j\omega t} \); the time-independent factor \( X = A e^{j\varphi} \) is called the phasor associated with \( x(t) \). We can summarize:

\[ x(t) = \Re\{ X e^{j\omega t} \}, \quad X = A e^{j\varphi}. \]

Differentiation and integration act very simply on complex exponentials:

\[ \frac{d}{dt} e^{j\omega t} = j\omega e^{j\omega t}, \qquad \int e^{j\omega t}\, dt = \frac{1}{j\omega} e^{j\omega t} + C. \]

Combining with \( x(t) = \Re\{ X e^{j\omega t} \} \) we obtain, for example,

\[ \frac{d}{dt} x(t) = \frac{d}{dt} \Re\{ X e^{j\omega t} \} = \Re\{ j\omega X e^{j\omega t} \}. \]

In phasor notation, "differentiate with respect to time" becomes "multiply the phasor by \( j\omega \)". This simplification is the key idea behind sinusoidal steady-state analysis.

Let us consider a simple first-order ODE that appears in many robotic actuators and sensors (e.g. DC motor current dynamics, simple RC filters in sensor conditioning):

\[ \tau \frac{dy(t)}{dt} + y(t) = u(t), \]

where \( \tau > 0 \) is a time constant. Suppose we excite the system by a sinusoidal input

\[ u(t) = U\cos(\omega t + \varphi_u) = \Re\{ U e^{j\varphi_u} e^{j\omega t} \} = \Re\{ U^{\star} e^{j\omega t} \}, \]

with input phasor \( U^{\star} = U e^{j\varphi_u} \). We look for a sinusoidal steady-state output of the form

\[ y(t) = \Re\{ Y^{\star} e^{j\omega t} \}, \]

where \( Y^{\star} \) is the output phasor to be determined. Substituting into the ODE and using the differentiation rule for phasors,

\[ \tau \frac{d}{dt} y(t) + y(t) = \Re\{ \tau (j\omega Y^{\star}) e^{j\omega t} + Y^{\star} e^{j\omega t} \} = \Re\{ (\tau j\omega + 1) Y^{\star} e^{j\omega t} \}. \]

Since \( u(t) = \Re\{ U^{\star} e^{j\omega t} \} \) and equality of real parts of equal complex exponentials implies equality of coefficients, we obtain the algebraic relation

\[ (\tau j\omega + 1)\, Y^{\star} = U^{\star}, \quad\Longrightarrow\quad Y^{\star} = \frac{1}{1 + \tau j\omega}\, U^{\star}. \]

The complex factor \( H(j\omega) = \dfrac{1}{1 + \tau j\omega} \) is a frequency-dependent complex gain. Its magnitude and argument give the steady-state amplitude ratio and phase shift:

\[ |H(j\omega)| = \frac{1}{\sqrt{1 + (\tau\omega)^2}}, \qquad \arg H(j\omega) = -\arctan(\tau\omega). \]

Thus, the output sinusoid is

\[ y(t) = |H(j\omega)| U \cos\big(\omega t + \varphi_u + \arg H(j\omega)\big). \]

This "phasor pipeline" can be summarized as:

flowchart TD
  Xtime["Input: x(t) = A cos(omega t + phi)"] --> P["Phasor: X = A * exp(j*phi)"]
  P --> H["Multiply by complex gain H(j*omega)"]
  H --> YP["Output phasor: Y = H(j*omega) * X"]
  YP --> Ytime["Back to time domain: y(t) = |Y| cos(omega t + angle(Y))"]
        

Later frequency-response and Bode-plot techniques formalize this further, but the essential mathematics is already present in complex numbers, exponentials and phasors.

Python has native support for complex numbers and is widely used in robotics and control via libraries such as numpy, scipy, and the python-control toolbox. Below we:

1. Represent a sinusoid as a phasor.
2. Apply a first-order complex gain \( H(j\omega) \).
3. Reconstruct the output signal.

import numpy as np
import matplotlib.pyplot as plt

# Parameters (can correspond to a simple filtered sensor signal on a robot)
A = 1.0          # input amplitude
phi_u = np.deg2rad(30.0)  # input phase [rad]
omega = 10.0     # angular frequency [rad/s]
tau = 0.05       # time constant [s]

# Time vector
t = np.linspace(0.0, 0.5, 2000)

# 1) Build input phasor and time signal
U_phasor = A * np.exp(1j * phi_u)         # U* = A e^{j phi}
u_t = np.real(U_phasor * np.exp(1j * omega * t))

# 2) First-order complex gain H(j omega)
H_jw = 1.0 / (1.0 + 1j * tau * omega)     # H(j omega) = 1 / (1 + j tau omega)
magH = np.abs(H_jw)
phaseH = np.angle(H_jw)

# 3) Output phasor and time signal
Y_phasor = H_jw * U_phasor
y_t = np.real(Y_phasor * np.exp(1j * omega * t))

print("H(j omega) magnitude:", magH)
print("H(j omega) phase [deg]:", np.rad2deg(phaseH))

# Plot input and output
plt.figure()
plt.plot(t, u_t, label="input u(t)")
plt.plot(t, y_t, label="output y(t)")
plt.xlabel("t [s]")
plt.ylabel("signal")
plt.legend()
plt.title("Sinusoidal steady-state via phasors")
plt.grid(True)
plt.show()

# Robotics/control note:
# The 'python-control' library can model robot joint actuators and evaluate their
# frequency response. Phasor-based reasoning underlies Bode plots and resonance
# analysis used in robotic servo-loop tuning.
      

In robotic applications, the same pattern is used when examining how joint actuators or sensor conditioning filters respond to periodic disturbances (gearbox ripple, rotor imbalance, periodic measurement noise, etc.).

C++ is a primary language in many robotics frameworks (e.g. ROS/ROS 2). Complex arithmetic is provided by <complex>, and high-level linear algebra is often handled by Eigen. The snippet below mirrors the Python example using std::complex<double>.

#include <iostream>
#include <complex>
#include <cmath>

int main() {
    using cd = std::complex<double>;

    double A = 1.0;
    double phi_u_deg = 30.0;
    double phi_u = phi_u_deg * M_PI / 180.0;
    double omega = 10.0;
    double tau = 0.05;

    // Input phasor U* = A e^{j phi}
    cd U_phasor = A * std::exp(cd(0.0, phi_u));

    // Complex gain H(j omega) = 1 / (1 + j tau omega)
    cd H_jw = cd(1.0, 0.0) / (cd(1.0, tau * omega)); // 1 / (1 + j tau omega)

    cd Y_phasor = H_jw * U_phasor;

    double magH = std::abs(H_jw);
    double phaseH = std::arg(H_jw); // radians

    std::cout << "H(j omega) magnitude: " << magH << "\n";
    std::cout << "H(j omega) phase [deg]: "
              << (phaseH * 180.0 / M_PI) << "\n";

    // Example: reconstruct y(t) at a single time instant
    double t = 0.1;
    cd y_complex = Y_phasor * std::exp(cd(0.0, omega * t));
    double y_t = std::real(y_complex);

    std::cout << "y(" << t << ") = " << y_t << "\n";

    return 0;
}
      

In more advanced robotic control software, Eigen::MatrixXcd (matrices of complex numbers) can be used to represent complex modal matrices or frequency-response data for multi-DOF robot arms, while std::complex handles scalar phasors such as single-axis servo transfer characteristics.

Java does not have built-in complex numbers, but robotics libraries on the JVM (for example team libraries in mobile robotics or Java-based FRC control code) often implement their own Complex or use math libraries such as Apache Commons Math. Below is a minimal implementation and a phasor demonstration.

public final class Complex {
    public final double re;
    public final double im;

    public Complex(double re, double im) {
        this.re = re;
        this.im = im;
    }

    public double abs() {
        return Math.hypot(re, im);
    }

    public double arg() {
        return Math.atan2(im, re);
    }

    public Complex times(Complex other) {
        return new Complex(
            re * other.re - im * other.im,
            re * other.im + im * other.re
        );
    }

    public Complex scale(double k) {
        return new Complex(k * re, k * im);
    }

    public static Complex expi(double theta) {
        return new Complex(Math.cos(theta), Math.sin(theta));
    }

    @Override
    public String toString() {
        return String.format("(%.4f %+ .4fj)", re, im);
    }
}

// Usage example in some robotics-oriented control code:
public class PhasorDemo {
    public static void main(String[] args) {
        double A = 1.0;
        double phiUdeg = 30.0;
        double phiU = Math.toRadians(phiUdeg);
        double omega = 10.0;
        double tau = 0.05;

        Complex U = Complex.expi(phiU).scale(A); // U* = A e^{j phi}

        // H(j omega) = 1 / (1 + j tau omega)
        Complex denom = new Complex(1.0, tau * omega);
        double denomAbsSq = denom.abs() * denom.abs();
        Complex H = new Complex(denom.re / denomAbsSq, -denom.im / denomAbsSq);

        Complex Y = H.times(U);

        System.out.println("H(j omega) = " + H);
        System.out.println("Y* = " + Y);
        System.out.println("Gain |H| = " + H.abs());
        System.out.println("Phase(H) [deg] = " + Math.toDegrees(H.arg()));
    }
}
      

In Java-based robotics frameworks, similar classes are used internally to represent frequency-response data, encoder signal processing chains, or vibration models for robot mechanisms.

MATLAB (and Simulink) are standard in control and robotics. MATLAB supports complex numbers natively and offers Control System Toolbox as well as Robotics System Toolbox. Here we focus purely on complex exponentials and phasors.

% Parameters
A = 1.0;
phi_u = deg2rad(30);   % rad
omega = 10.0;          % rad/s
tau = 0.05;            % s

% Input and output phasors
U = A * exp(1j * phi_u);      % U* = A e^{j phi}
H = 1 ./ (1 + 1j * tau * omega);
Y = H .* U;

magH = abs(H);
phaseH = angle(H);

fprintf("H(j omega) magnitude = %.4f\n", magH);
fprintf("H(j omega) phase [deg] = %.2f\n", rad2deg(phaseH));

% Time-domain reconstruction
t = linspace(0, 0.5, 2000);
u_t = real(U * exp(1j * omega * t));
y_t = real(Y * exp(1j * omega * t));

plot(t, u_t, t, y_t);
xlabel("t [s]"); ylabel("signal");
legend("u(t)", "y(t)");
grid on;
title("Sinusoidal steady-state via phasors");

% Simulink note:
% In Simulink, a Sine Wave block feeding a first-order transfer block (e.g. 1/(tau s + 1))
% will produce the same amplitude ratio and phase shift predicted by |H(j omega)| and angle(H).
      

Wolfram Mathematica also provides first-class complex arithmetic and symbolic capabilities, which are useful for analytical derivations of frequency-response expressions relevant to robot dynamics.

(* Parameters *)
A = 1.0;
phiU = 30 Degree;
omega = 10.0;
tau = 0.05;

U = A Exp[I phiU];
H[om_] := 1/(1 + I tau om);
Y = H[omega] U // FullSimplify;

(* Magnitude and phase *)
magH = Abs[H[omega]];
phaseH = Arg[H[omega]];

Print["H(j omega) magnitude = ", magH];
Print["H(j omega) phase [deg] = ", N[phaseH * 180 / Pi]];

(* Time-domain expression for y(t) *)
y[t_] := Re[Y Exp[I omega t]] // FullSimplify
      

Symbolic tools like Mathematica are valuable when deriving closed-form expressions for complex gains of robotic subsystems and for verifying numerical implementations in Python, C++, or MATLAB.

In this lesson we revisited complex numbers from both algebraic and geometric viewpoints, derived Euler's formula and its consequences, and formalized the representation of sinusoids via complex exponentials and phasors. We saw how sinusoidal steady-state analysis of simple linear ODEs becomes a matter of complex algebra: differentiation corresponds to multiplication by \( j\omega \), and first-order systems induce frequency-dependent complex gains.

These ideas are foundational for upcoming topics: Laplace transforms, frequency response, stability margins, and controller design for robotic and mechatronic systems. In subsequent lessons, we will systematically connect the \( s \)-domain and \( j\omega \)-axis viewpoints used throughout linear control.