Why another transform?
The Fourier transform of the last lessons describes signals as eternal sinusoids. That is ideal for steady states, but engineers also need to know what happens when a switch closes, when a motor starts, or when a feedback loop is disturbed: transients that begin at a definite time, from definite initial conditions. And some of the most important questions are about signals that grow: will this amplifier oscillate, will this power supply's output run away? A growing exponential has no Fourier transform at all.
The Laplace transform fixes both problems by multiplying the signal by a decaying exponential before taking its Fourier transform, and by starting the clock at . In return it gives three things. Differential equations become algebraic equations, with initial conditions built in. Circuits can be analysed with impedances , and , exactly as in AC and phasors but for any input, not just sinusoids. And every linear system gets a transfer function whose poles, a few points in the complex plane, tell you at a glance how the system responds and whether it is stable. That last idea is the backbone of Feedback control, the next lesson.
The Laplace transform
Definition— Laplace transform
The (unilateral) Laplace transform of a signal is the function of a complex variable defined for the values of where the integral converges, the region of convergence (ROC). For the signals engineers meet, which grow no faster than some exponential , the ROC is a half-plane . The lower limit means the integral includes anything happening exactly at , such as an impulse.
For example, for , because exactly when . This works for any real , including negative ones: the growing exponential has transform with ROC . If the ROC includes the imaginary axis, setting gives back the Fourier transform: , the notation used in the last two lessons on purpose.
| Signal () | Transform | Pole(s) |
|---|---|---|
| none | ||
| (double) | ||
| (double) | ||
The properties that make the transform useful:
| Property | Time domain | s-domain |
|---|---|---|
| Linearity | ||
| Differentiation | ||
| Integration | ||
| Delay by | ||
| Exponential weighting | ||
| Convolution |
The differentiation rule (integrate by parts) is the one that turns differential equations into algebra, and its term is how initial conditions enter. The convolution rule means that for an LTI system starting at rest, , where the transfer function is the Laplace transform of the impulse response.
Transfer functions of circuits
For a circuit starting at rest (capacitors uncharged, inductors carrying no current), the Laplace transform turns each component law into an impedance:
- resistor: becomes ;
- inductor: becomes ;
- capacitor: becomes .
These are the phasor impedances and with replaced by . So Kirchhoff's laws, voltage dividers, nodal analysis and every other tool of the Circuits level work unchanged in the s-domain, and they now give the response to any input. (Non-zero initial conditions appear as extra sources: an inductor carrying becomes the impedance in series with a source .)
Example— The series RLC low-pass
By the voltage divider, with the natural frequency and the damping ratio . Its poles are the roots of : For they are complex, , and the response rings; for they are real and the response creeps up without overshoot. With mH and F, rad/s (about 1.6 kHz) and . You met these regimes in RLC circuits, by solving the differential equation; here they come out of a quadratic.
This standard second-order form appears far beyond circuits: a car's suspension, a loudspeaker cone, a building swaying in the wind and a motor with a speed controller are all described, at least approximately, by the same two numbers and .
Poles and what they mean for the step response
Suppose is a ratio of polynomials. The roots of are the poles and the roots of the zeros. Expanding in partial fractions (the next section shows how) writes the impulse response as a sum of terms, one per pole: So each pole is a natural mode of the system, a way it likes to move, and its position in the complex plane says everything about that mode. Write :
- , the real part, sets the growth or decay: the mode is multiplied by , so it decays with time constant if and grows if .
- , the imaginary part, sets the oscillation: complex poles come in conjugate pairs , whose two modes combine into .
The program simulates the series RLC circuit for six values of , computes the poles, and measures the step response: the overshoot (how far the output rises above its final value, as a percentage), the 10–90% rise time, and the 2% settling time (after which the output stays within 2% of its final value). For it also checks the overshoot against the textbook formula .
import numpy as np
# Series RLC driven by a 1 V step; output across C. H(s) = 1 / (LC s^2 + RC s + 1).
L, C = 10e-3, 1e-6 # 10 mH and 1 uF: w0 = 1/sqrt(LC) = 10,000 rad/s
w0 = 1 / np.sqrt(L * C)
R = np.array([20.0, 60.0, 100.0, 141.4, 200.0, 400.0]) # zeta = (R/2) sqrt(C/L) = R / 200
zeta = R / 2 * np.sqrt(C / L)
# Simulate all six circuits at once with 4th-order Runge-Kutta.
# State: capacitor voltage v and inductor current i. L di/dt = 1 - R i - v, C dv/dt = i.
def deriv(state):
v, i = state
return np.array([i / C, (1.0 - R * i - v) / L])
dt, steps = 1e-6, 8000 # 8 ms in 1 microsecond steps
state = np.zeros((2, len(R)))
t = np.arange(steps + 1) * dt
v = np.zeros((steps + 1, len(R)))
for k in range(steps):
k1 = deriv(state)
k2 = deriv(state + dt / 2 * k1)
k3 = deriv(state + dt / 2 * k2)
k4 = deriv(state + dt * k3)
state = state + dt / 6 * (k1 + 2 * k2 + 2 * k3 + k4)
v[k + 1] = state[0]
print(" R (ohm) zeta poles (1/s) overshoot formula 10-90% rise 2% settling")
for j in range(len(R)):
p = np.roots([L * C, R[j] * C, 1.0])
p = p[np.argsort(p.imag)][::-1]
y = v[:, j]
over = 100 * max(y.max() - 1, 0)
formula = 100 * np.exp(-np.pi * zeta[j] / np.sqrt(1 - zeta[j] ** 2)) if zeta[j] < 1 else 0.0
rise = t[np.argmax(y >= 0.9)] - t[np.argmax(y >= 0.1)]
outside = np.nonzero(np.abs(y - 1) > 0.02)[0]
settle = t[outside[-1] + 1]
pole_txt = ", ".join(f"{z.real:.0f}{z.imag:+.0f}j" if abs(z.imag) > 1e-3 * w0 else f"{z.real:.0f}" for z in p)
print(f"{R[j]:8.1f} {zeta[j]:.3f} {pole_txt:26} {over:6.1f} % {formula:5.1f} % {rise * 1e6:6.0f} us {settle * 1e3:5.2f} ms")Read the table from top to bottom as the poles move. At () the poles sit close to the imaginary axis, at : the circuit rings at nearly , overshoots by 72.9%, and takes 3.84 ms to settle, consistent with the rule of thumb ms. Increasing pulls the poles left along a circle of radius , so the oscillation dies faster and the overshoot falls: 37.2%, 16.3%, then 4.3% at , where the poles sit at 45°. At (critical damping) the two poles meet at and there is no overshoot; this is the fastest-settling response that never overshoots. Beyond that, at , they split along the real axis, one fast () and one slow (), and the slow one dominates: the response is sluggish, with a rise time of 823 μs against 132 μs at .
This is why is such a popular design target in filters and control: it overshoots by only about 4%, rises much faster than the critically damped case (215 μs against 335 μs), and settles almost as soon (0.60 ms against 0.58 ms). Zeros shape the response too, by changing how much each mode contributes, but they do not change the modes themselves. One warning case: a zero in the right half-plane makes the step response start off in the wrong direction (undershoot), a real effect in boost converters and in steering a bicycle, and a fundamental limit on how fast such systems can be controlled.
The same circuit in SPICE
The table's row can be checked with a circuit simulator, completely independently of the Laplace transform. This netlist applies a 1 V step to the series RLC circuit with and measures the peak output.
* Series RLC step response: R = 60 ohm, L = 10 mH, C = 1 uF (zeta = 0.3)
V1 in 0 PULSE(0 1 0 1n 1n 1 2)
R1 in a 60
L1 a out 10m
C1 out 0 1u
.control
tran 1u 6m
meas tran vpeak MAX v(out)
meas tran tpeak WHEN v(out)=vpeak
let overshoot_pct = (vpeak - 1) * 100
print overshoot_pct
meas tran vfinal FIND v(out) AT=6m
.endc
.endngspice reports a peak of 1.3723 V at 329 μs, an overshoot of 37.23%, matching the table. The peak time also matches theory: the first peak of an underdamped response comes half a period of the ringing after the step, , with rad/s, which is 329 μs.
BIBO stability
Theorem— Pole condition for stability
A causal LTI system whose transfer function is a proper rational function (numerator degree at most denominator degree, with common factors cancelled) is BIBO stable if and only if every pole lies in the open left half-plane, .
Proof
By partial fractions, is a possible impulse at (when the degrees are equal) plus a sum of terms , where is less than the multiplicity of . If every , each term is absolutely integrable over (an exponential decay beats any power of ), so and the system is stable by the criterion of Signals, systems and convolution. If some pole has , its term does not decay, does not tend to zero, and is infinite, so the system is not stable.
∎
The borderline deserves care, because it is where real designs fail.
- Poles on the imaginary axis give modes that neither grow nor decay. The system is called marginally stable, but it is not BIBO stable. An integrator, , turns a bounded step into an unbounded ramp. An undamped LC circuit, , driven by a bounded sinusoid at exactly responds with an oscillation whose amplitude grows like : resonance.
- Improper transfer functions, with more zeros than poles, are not BIBO stable either: an ideal differentiator turns a bounded but ever-faster wiggle into an unbounded output. Real differentiators always have extra poles.
- Cancellation hides things. If an unstable pole is cancelled by a zero in , the input–output map may look stable while an internal signal grows. Control engineers insist on internal stability for this reason.
For polynomials of high degree, you can decide whether all roots lie in the left half-plane without computing them, using the Routh–Hurwitz criterion. A necessary condition is easy to remember: all coefficients of the denominator must be non-zero and have the same sign. For a quadratic that is also sufficient; for a cubic with positive coefficients, the extra condition is , which one of the exercises asks you to test.
Partial fractions, and the initial- and final-value theorems
To find a time response, write as a sum of simple terms from the table and invert each. For a proper rational function with distinct poles, so . The residue formula is the cover-up rule: to find , cover up the factor in the denominator and evaluate what is left at .
Example— A step response by partial fractions
Find the step response of . The step has transform , so Cover up and evaluate: ; ; . So Check: , as it must be for a system starting at rest, and , the DC gain.
Complex-conjugate poles give conjugate residues, which combine into a damped sinusoid; a repeated pole contributes a term . In practice a computer algebra system does the bookkeeping. The program checks the cover-up residues numerically, then asks SymPy for the partial fractions and the inverse transform.
import numpy as np
import sympy as sp
s, t = sp.symbols("s t")
# Step response of H(s) = (s + 3) / ((s + 1)(s + 2)): Y(s) = H(s) / s.
Y = (s + 3) / ((s + 1) * (s + 2) * s)
# 1. By hand (cover-up rule), checked numerically: residue at a simple pole p is N(p) / D'(p).
num = np.array([1.0, 3.0]) # s + 3
den = np.poly([0.0, -1.0, -2.0]) # s (s + 1)(s + 2) = s^3 + 3 s^2 + 2 s
dden = np.polyder(den)
for p in (0.0, -1.0, -2.0):
print(f"residue at s = {p:+.0f}: {np.polyval(num, p) / np.polyval(dden, p):+.4f}")
# 2. With sympy: partial fractions, inverse transform, and the two limit theorems.
print("\npartial fractions:", sp.apart(Y, s))
y = sp.inverse_laplace_transform(Y, s, t)
y = sp.expand(sp.simplify(y).subs(sp.Heaviside(t), 1)) # for t > 0
print("y(t) =", y, " for t > 0")
print("initial value lim s->oo of s Y(s):", sp.limit(s * Y, s, sp.oo), " y(0+) =", y.subs(t, 0))
print("final value lim s->0 of s Y(s):", sp.limit(s * Y, s, 0), " y(oo) =", sp.limit(y, t, sp.oo))
# 3. A warning: the final-value theorem applied to an unstable system gives nonsense.
Y_bad = 1 / (s * (s - 1)) # step into H(s) = 1/(s - 1), pole at +1
print("\nunstable case: lim s->0 of s Y(s) =", sp.limit(s * Y_bad, s, 0),
" but y(t) =", sp.expand(sp.inverse_laplace_transform(Y_bad, s, t).subs(sp.Heaviside(t), 1)))The initial- and final-value theorems
Two limits give the ends of a response straight from the transform, without inverting it: The first holds when is strictly proper (no impulse at ). The second holds only if actually settles, which means every pole of is in the open left half-plane. Applied to a step response of a stable system, , the final-value theorem gives : the final value of a step response is the DC gain, which is how engineers compute steady-state errors in the next lesson.
From the s-plane to the z-plane
Sampling connects this lesson to Digital filters. Sample a mode every seconds and you get , a geometric sequence, which is the mode of a discrete-time pole at So the map carries continuous-time poles to discrete-time ones, and it carries the geometry with it. Writing gives and :
- the left half-plane () goes inside the unit circle (), so stable stays stable;
- the imaginary axis () goes onto the unit circle, with frequency becoming the angle ;
- lines of constant decay rate become circles, and goes to .
The map wraps the s-plane round and round: and land on the same . That is aliasing once again, now as a statement about poles: frequencies differing by a multiple of are indistinguishable after sampling. The program maps the RLC circuit's poles to the z-plane at kHz, builds a two-pole recursion with exactly those poles, and checks that it reproduces the sampled impulse response of the circuit.
import numpy as np
# The underdamped RLC from before (R = 60 ohm, zeta = 0.3): poles of H(s) = w0^2 / (s^2 + 2 zeta w0 s + w0^2).
w0, zeta = 10_000.0, 0.3
p = np.roots([1.0, 2 * zeta * w0, w0 ** 2])
fs = 50_000.0 # sample at 50 kHz
T = 1 / fs
z = np.exp(p * T) # each s-plane pole maps to z = e^{sT}
print("s-plane pole z-plane pole |z| angle")
for ps, pz in sorted(zip(p, z), key=lambda q: -q[0].imag):
print(f"{ps.real:8.0f} {ps.imag:+9.1f}j {pz.real:+.5f} {pz.imag:+.5f}j {abs(pz):.5f} {np.degrees(np.angle(pz)):+7.2f} deg")
print(f"predicted |z| = exp(-zeta w0 T) = {np.exp(-zeta * w0 * T):.5f}")
# A digital filter with exactly these poles has an impulse response made of the same
# exponentials, sampled: check against the continuous impulse response h(t) at t = nT.
wd = w0 * np.sqrt(1 - zeta ** 2)
def h(t): # impulse response of the RLC, from partial fractions
return w0 ** 2 / wd * np.exp(-zeta * w0 * t) * np.sin(wd * t)
a1, a2 = -2 * np.real(z[0]), abs(z[0]) ** 2 # denominator 1 + a1 z^-1 + a2 z^-2
y = np.zeros(12)
y[1] = T * h(T) # start the recursion from two samples of h
for n in range(2, 12):
y[n] = -a1 * y[n - 1] - a2 * y[n - 2]
print("\n n T*h(nT) recursion")
for n in range(1, 12, 2):
print(f"{n:2} {T * h(n * T):+.6f} {y[n]:+.6f}")
print("\nwhere a few s-plane points land (fs = 50 kHz):")
for label, sp_ in [("s = 0 (DC)", 0j), ("s = -5000", -5000 + 0j), ("s = +5000 (unstable)", 5000 + 0j),
("s = j 2 pi 12.5 kHz", 2j * np.pi * 12_500), ("s = j 2 pi 20 kHz", 2j * np.pi * 20_000)]:
zz = np.exp(sp_ * T)
print(f" {label:22} -> |z| = {abs(zz):.4f}, angle {np.degrees(np.angle(zz)):+7.2f} deg")The poles at land at radius and angle (which is radians). A two-coefficient recursion with these poles reproduces the circuit's impulse response at every sample: this design method, called impulse invariance, is the alternative to the bilinear transform of the previous lesson. It preserves the time response exactly at the samples but, unlike the bilinear transform, it suffers from aliasing of the frequency response, so it is used mainly for systems that are already strongly low-pass.
Poles and zeros in engineering practice
- Power supplies. A switching regulator's output filter and control loop have poles and zeros that the designer places deliberately, adding compensation networks of resistors and capacitors (often called type II or type III compensators) to keep the loop stable over every load and input voltage. Manufacturers' design tools and application notes are written in this language.
- Filter design. Classic analogue filters are defined by their poles: a Butterworth filter puts them on a semicircle for the flattest passband, a Chebyshev filter on an ellipse for a sharper cut-off with ripple, and an elliptic filter adds zeros on the imaginary axis for the sharpest transition. The digital filters of the previous lesson often start from these.
- Power systems. Large interconnected grids have slow electromechanical oscillation modes, typically between about 0.1 and 2 Hz, in which groups of generators swing against each other. Operators monitor their damping with synchronised measurements across the network, and a mode drifting towards the imaginary axis is a warning sign; The power grid returns to this.
- Mechanical systems. Vibration engineers identify the poles of a structure (its modes, with natural frequencies and damping ratios) from measurements, for bridges, aircraft wings and hard-disk actuators alike.
In software, SPICE simulators perform transient and AC analysis and can compute poles and zeros directly; the Python Control Systems Library and commercial tools build transfer functions, find poles and plot step responses. In state-space form, , the poles are the eigenvalues of , the starting point of Lumenary Robotics' state space and LQR.
Common misconceptions
Misconception
"A pole on the imaginary axis is stable, because its response does not grow." Its impulse response does not grow, but it does not decay either, so is infinite and some bounded input (a step for an integrator, a sinusoid at the right frequency for an undamped resonator) produces an unbounded output.
Misconception
"Zeros decide stability too." Stability is decided by the poles alone. Zeros change how much each mode contributes to the response, and right-half-plane zeros cause undershoot and limit how fast a feedback loop can be, but they never make a system unstable by themselves.
Misconception
"The final-value theorem always gives the final value." Only when the response actually settles, that is, when all poles of are in the open left half-plane. Otherwise it returns a number that means nothing.
Misconception
"More damping is always better." Beyond the response gets slower, not better: at the RLC circuit took 1.49 ms to settle against 0.60 ms at . Design is a trade-off between speed and overshoot.
Misconception
"The Laplace transform is just the Fourier transform with instead of ." On the imaginary axis they agree, when the ROC includes it. But the Laplace transform also exists for growing signals, handles initial conditions, and its poles off the axis carry the information about transients and stability that the Fourier transform cannot see.
A short history
Pierre-Simon Laplace used integrals of this kind in the 1780s in his work on probability. The engineering use began with Oliver Heaviside, who in the 1880s and 1890s solved telegraph and circuit equations by treating as an algebraic symbol , getting correct answers by methods his contemporaries considered unjustified. Thomas Bromwich and others justified Heaviside's rules with complex analysis around 1916, and Gustav Doetsch's work in the 1930s and 1940s made the Laplace transform the standard tool it is today. Stability came earlier: James Clerk Maxwell analysed the stability of steam-engine governors in 1868, Edward Routh gave his criterion in 1877, and Adolf Hurwitz an equivalent one in 1895.
Exercises
1. The Laplace transform and stability
Warm-upHumanAn RC low-pass filter has and nF, so . Where is its pole on the real axis of the s-plane, in units of 1/s?
2. The Laplace transform and stability
Warm-upHumanA stable system has transfer function . A unit step is applied at . What value does the output settle to?
3. The Laplace transform and stability
CoreHumanA second-order system has damping ratio . By what percentage does its step response overshoot its final value? Give the nearest whole number.
4. The Laplace transform and stability
CoreHumanWhich of these transfer functions are BIBO stable? Select all that apply.
5. The Laplace transform and stability
CoreHumanA continuous-time pole at (in s⁻¹) is mapped to discrete time with at kHz. Where does it land?
6. The Laplace transform and stability
CoreComputationalWrite step_response(num, den, t): the step response of (coefficient lists, highest power first), computed by partial fractions of . Assume is strictly proper and stable with distinct poles. Find the poles of (those of plus ), compute each residue with the cover-up rule , and return (its real part) at the times t.
7. The Laplace transform and stability
StretchComputationalDecide stability without computing roots. Write cubic_is_stable(a3, a2, a1, a0) returning True exactly when every root of (with ) has a negative real part. The starter checks only that the coefficients are positive, which is necessary but not sufficient. The tests compare with the roots on 300 random cubics (and block np.roots).
Further reading and resources
- MIT OpenCourseWare 6.003: Signals and Systems · Dennis Freeman · 2011Lecture notes on the Laplace and z-transforms, poles and zeros, and feedback.
- ngspiceThe open-source circuit simulator that runs this lesson's netlist; its manual describes transient and pole-zero analysis.
- Python Control Systems LibraryAn open-source library for transfer functions, poles, step responses and frequency responses in Python.
- SymPyThe symbolic mathematics library used here for partial fractions and inverse Laplace transforms.