Skip to content
LumenaryAcademy
Signals 65 min

The Laplace transform and stability

Transfer functions, poles in the s-plane, and how to tell at a glance whether a circuit rings, settles or runs away.

Code tested · 6AI-draftedAwaiting review by an electrical engineer

Your guides: Chloe · The Physicist, Margaret · The Bench Engineer, Gideon · The Design Reviewer

MotivationH

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 ete^{t} has no Fourier transform at all.

The Laplace transform fixes both problems by multiplying the signal by a decaying exponential e−σte^{-\sigma t} before taking its Fourier transform, and by starting the clock at t=0t = 0. In return it gives three things. Differential equations become algebraic equations, with initial conditions built in. Circuits can be analysed with impedances RR, sLsL and 1/(sC)1/(sC), 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.

DefinitionsH

The Laplace transform

Definition— Laplace transform

The (unilateral) Laplace transform of a signal x(t)x(t) is the function of a complex variable s=σ+jωs = \sigma + j\omega X(s)=∫0−∞x(t) e−st dt,X(s) = \int_{0^-}^{\infty} x(t)\, e^{-st}\, dt, defined for the values of ss where the integral converges, the region of convergence (ROC). For the signals engineers meet, which grow no faster than some exponential eσ0te^{\sigma_0 t}, the ROC is a half-plane Re(s)>σ0\mathrm{Re}(s) > \sigma_0. The lower limit 0−0^- means the integral includes anything happening exactly at t=0t = 0, such as an impulse.

For example, for x(t)=e−atu(t)x(t) = e^{-at}u(t), X(s)=∫0∞e−(s+a)t dt=[−e−(s+a)ts+a]0∞=1s+a,Re(s)>−a,X(s) = \int_0^\infty e^{-(s+a)t}\, dt = \left[\frac{-e^{-(s+a)t}}{s+a}\right]_0^\infty = \frac{1}{s+a}, \qquad \mathrm{Re}(s) > -a, because e−(s+a)t→0e^{-(s+a)t} \to 0 exactly when Re(s+a)>0\mathrm{Re}(s + a) > 0. This works for any real aa, including negative ones: the growing exponential e2tu(t)e^{2t}u(t) has transform 1/(s−2)1/(s - 2) with ROC Re(s)>2\mathrm{Re}(s) > 2. If the ROC includes the imaginary axis, setting s=jωs = j\omega gives back the Fourier transform: X(jω)X(j\omega), the notation used in the last two lessons on purpose.

Signal (t≥0t \ge 0)TransformPole(s)
δ(t)\delta(t)11none
u(t)u(t)1/s1/s00
tt1/s21/s^200 (double)
e−ate^{-at}1/(s+a)1/(s+a)−a-a
t e−att\,e^{-at}1/(s+a)21/(s+a)^2−a-a (double)
sin⁡(ω0t)\sin(\omega_0 t)ω0/(s2+ω02)\omega_0/(s^2 + \omega_0^2)±jω0\pm j\omega_0
cos⁡(ω0t)\cos(\omega_0 t)s/(s2+ω02)s/(s^2 + \omega_0^2)±jω0\pm j\omega_0
e−atsin⁡(ω0t)e^{-at}\sin(\omega_0 t)ω0/((s+a)2+ω02)\omega_0/((s+a)^2 + \omega_0^2)−a±jω0-a \pm j\omega_0

The properties that make the transform useful:

PropertyTime domains-domain
Linearityax1+bx2a x_1 + b x_2aX1+bX2a X_1 + b X_2
Differentiationx′(t)x'(t)sX(s)−x(0−)sX(s) - x(0^-)
Integration∫0−tx(τ) dτ\int_{0^-}^{t} x(\tau)\,d\tauX(s)/sX(s)/s
Delay by T≥0T \ge 0x(t−T)u(t−T)x(t - T)u(t - T)e−sTX(s)e^{-sT}X(s)
Exponential weightinge−atx(t)e^{-at}x(t)X(s+a)X(s + a)
Convolution(x∗h)(t)(x * h)(t)X(s)H(s)X(s)H(s)

The differentiation rule (integrate by parts) is the one that turns differential equations into algebra, and its −x(0−)-x(0^-) term is how initial conditions enter. The convolution rule means that for an LTI system starting at rest, Y(s)=H(s)X(s)Y(s) = H(s)X(s), where the transfer function H(s)H(s) is the Laplace transform of the impulse response.

Worked examplesH

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: v=Riv = Ri becomes V(s)=R I(s)V(s) = R\,I(s);
  • inductor: v=L di/dtv = L\,di/dt becomes V(s)=sL I(s)V(s) = sL\,I(s);
  • capacitor: i=C dv/dti = C\,dv/dt becomes V(s)=1sC I(s)V(s) = \frac{1}{sC}\,I(s).

These are the phasor impedances jωLj\omega L and 1/(jωC)1/(j\omega C) with jωj\omega replaced by ss. 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 i(0)i(0) becomes the impedance sLsL in series with a source L i(0)L\,i(0).)

+−x(t)RLC+y(t)−
A series RLC circuit, input voltage x(t), output across the capacitor.

Example— The series RLC low-pass

By the voltage divider, H(s)=Y(s)X(s)=1/(sC)R+sL+1/(sC)=1LCs2+RCs+1=ω02s2+2ζω0s+ω02,H(s) = \frac{Y(s)}{X(s)} = \frac{1/(sC)}{R + sL + 1/(sC)} = \frac{1}{LCs^2 + RCs + 1} = \frac{\omega_0^2}{s^2 + 2\zeta\omega_0 s + \omega_0^2}, with the natural frequency ω0=1/LC\omega_0 = 1/\sqrt{LC} and the damping ratio ζ=R2C/L\zeta = \frac{R}{2}\sqrt{C/L}. Its poles are the roots of s2+2ζω0s+ω02s^2 + 2\zeta\omega_0 s + \omega_0^2: p=−ζω0±ω0ζ2−1.p = -\zeta\omega_0 \pm \omega_0\sqrt{\zeta^2 - 1}. For ζ<1\zeta < 1 they are complex, −ζω0±jω01−ζ2-\zeta\omega_0 \pm j\omega_0\sqrt{1 - \zeta^2}, and the response rings; for ζ>1\zeta > 1 they are real and the response creeps up without overshoot. With L=10L = 10 mH and C=1 μC = 1\ \muF, ω0=10,000\omega_0 = 10{,}000 rad/s (about 1.6 kHz) and ζ=R/200 Ω\zeta = R/200\ \Omega. 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 ω0\omega_0 and ζ\zeta.

ComputationC

Poles and what they mean for the step response

Suppose H(s)=N(s)/D(s)H(s) = N(s)/D(s) is a ratio of polynomials. The roots of DD are the poles and the roots of NN the zeros. Expanding H(s)H(s) in partial fractions (the next section shows how) writes the impulse response as a sum of terms, one per pole: h(t)=∑krk epkt(t≥0, distinct poles).h(t) = \sum_k r_k\, e^{p_k t} \qquad (t \ge 0,\ \text{distinct poles}). 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 p=σ+jωp = \sigma + j\omega:

  • σ\sigma, the real part, sets the growth or decay: the mode is multiplied by eσte^{\sigma t}, so it decays with time constant 1/∣σ∣1/|\sigma| if σ<0\sigma < 0 and grows if σ>0\sigma > 0.
  • ω\omega, the imaginary part, sets the oscillation: complex poles come in conjugate pairs σ±jω\sigma \pm j\omega, whose two modes combine into eσtcos⁡(ωt+ϕ)e^{\sigma t}\cos(\omega t + \phi).
σ = Re sjω = Im sleft half-plane: stableright half-plane: unstable
The s-plane. Each small graph shows the response of a pole (or conjugate pair) at that position: decaying in the shaded left half-plane, sustained on the imaginary axis, growing in the right half-plane. Further from the real axis means faster oscillation; further from the imaginary axis means faster decay or growth.

The program simulates the series RLC circuit for six values of RR, 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 ζ<1\zeta < 1 it also checks the overshoot against the textbook formula Mp=e−πζ/1−ζ2M_p = e^{-\pi\zeta/\sqrt{1-\zeta^2}}.

python
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")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

Read the table from top to bottom as the poles move. At R=20 ΩR = 20\ \Omega (ζ=0.1\zeta = 0.1) the poles sit close to the imaginary axis, at −1000±9950j-1000 \pm 9950j: the circuit rings at nearly ω0\omega_0, overshoots by 72.9%, and takes 3.84 ms to settle, consistent with the rule of thumb ts≈4/(ζω0)=4/∣σ∣=4t_s \approx 4/(\zeta\omega_0) = 4/|\sigma| = 4 ms. Increasing RR pulls the poles left along a circle of radius ω0\omega_0, so the oscillation dies faster and the overshoot falls: 37.2%, 16.3%, then 4.3% at ζ=0.707\zeta = 0.707, where the poles sit at 45°. At ζ=1\zeta = 1 (critical damping) the two poles meet at −10,000-10{,}000 and there is no overshoot; this is the fastest-settling response that never overshoots. Beyond that, at ζ=2\zeta = 2, they split along the real axis, one fast (−37,321-37{,}321) and one slow (−2679-2679), and the slow one dominates: the response is sluggish, with a rise time of 823 μs against 132 μs at ζ=0.3\zeta = 0.3.

This is why ζ≈0.7\zeta \approx 0.7 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 ζ=0.3\zeta = 0.3 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 R=60 ΩR = 60\ \Omega and measures the peak output.

spice
* 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
.end

ngspice 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, π/ωd\pi/\omega_d, with ωd=9539\omega_d = 9539 rad/s, which is 329 μs.

DefinitionsH

BIBO stability

Theorem— Pole condition for stability

A causal LTI system whose transfer function H(s)H(s) 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, Re(pk)<0\mathrm{Re}(p_k) < 0.

Proof

By partial fractions, h(t)h(t) is a possible impulse at t=0t = 0 (when the degrees are equal) plus a sum of terms c tmepktc\,t^m e^{p_k t}, where mm is less than the multiplicity of pkp_k. If every Re(pk)<0\mathrm{Re}(p_k) < 0, each term is absolutely integrable over [0,∞)[0, \infty) (an exponential decay beats any power of tt), so ∫∣h∣<∞\int |h| < \infty and the system is stable by the criterion of Signals, systems and convolution. If some pole has Re(pk)≥0\mathrm{Re}(p_k) \ge 0, its term does not decay, h(t)h(t) does not tend to zero, and ∫∣h∣\int |h| 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, H(s)=1/sH(s) = 1/s, turns a bounded step into an unbounded ramp. An undamped LC circuit, H(s)=ω02/(s2+ω02)H(s) = \omega_0^2/(s^2 + \omega_0^2), driven by a bounded sinusoid at exactly ω0\omega_0 responds with an oscillation whose amplitude grows like tt: resonance.
  • Improper transfer functions, with more zeros than poles, are not BIBO stable either: an ideal differentiator H(s)=sH(s) = s 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 H(s)H(s), 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 a3s3+a2s2+a1s+a0a_3 s^3 + a_2 s^2 + a_1 s + a_0 with positive coefficients, the extra condition is a2a1>a3a0a_2 a_1 > a_3 a_0, which one of the exercises asks you to test.

Worked examplesH

Partial fractions, and the initial- and final-value theorems

To find a time response, write Y(s)=H(s)X(s)Y(s) = H(s)X(s) as a sum of simple terms from the table and invert each. For a proper rational function with distinct poles, Y(s)=N(s)D(s)=∑krks−pk,rk=lim⁡s→pk(s−pk) Y(s)=N(pk)D′(pk),Y(s) = \frac{N(s)}{D(s)} = \sum_k \frac{r_k}{s - p_k}, \qquad r_k = \lim_{s \to p_k}(s - p_k)\,Y(s) = \frac{N(p_k)}{D'(p_k)}, so y(t)=∑krkepkty(t) = \sum_k r_k e^{p_k t}. The residue formula is the cover-up rule: to find rkr_k, cover up the factor (s−pk)(s - p_k) in the denominator and evaluate what is left at s=pks = p_k.

Example— A step response by partial fractions

Find the step response of H(s)=s+3(s+1)(s+2)H(s) = \dfrac{s + 3}{(s + 1)(s + 2)}. The step has transform 1/s1/s, so Y(s)=s+3s(s+1)(s+2)=r0s+r1s+1+r2s+2.Y(s) = \frac{s + 3}{s(s + 1)(s + 2)} = \frac{r_0}{s} + \frac{r_1}{s + 1} + \frac{r_2}{s + 2}. Cover up and evaluate: r0=3(1)(2)=32r_0 = \frac{3}{(1)(2)} = \frac32; r1=−1+3(−1)(−1+2)=−2r_1 = \frac{-1 + 3}{(-1)(-1 + 2)} = -2; r2=−2+3(−2)(−2+1)=12r_2 = \frac{-2 + 3}{(-2)(-2 + 1)} = \frac12. So y(t)=32−2e−t+12e−2t,t≥0.y(t) = \tfrac32 - 2e^{-t} + \tfrac12 e^{-2t}, \qquad t \ge 0 . Check: y(0)=32−2+12=0y(0) = \tfrac32 - 2 + \tfrac12 = 0, as it must be for a system starting at rest, and y(∞)=32=H(0)y(\infty) = \tfrac32 = H(0), the DC gain.

Complex-conjugate poles give conjugate residues, which combine into a damped sinusoid; a repeated pole (s−p)2(s - p)^2 contributes a term t eptt\,e^{pt}. 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.

python
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)))
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

The initial- and final-value theorems

Two limits give the ends of a response straight from the transform, without inverting it: x(0+)=lim⁡s→∞sX(s),lim⁡t→∞x(t)=lim⁡s→0sX(s).x(0^+) = \lim_{s \to \infty} sX(s), \qquad \lim_{t \to \infty} x(t) = \lim_{s \to 0} sX(s). The first holds when X(s)X(s) is strictly proper (no impulse at t=0t = 0). The second holds only if x(t)x(t) actually settles, which means every pole of sX(s)sX(s) is in the open left half-plane. Applied to a step response of a stable system, Y(s)=H(s)/sY(s) = H(s)/s, the final-value theorem gives y(∞)=H(0)y(\infty) = H(0): the final value of a step response is the DC gain, which is how engineers compute steady-state errors in the next lesson.

ComputationC

From the s-plane to the z-plane

Sampling connects this lesson to Digital filters. Sample a mode epte^{pt} every TT seconds and you get epnT=(epT)ne^{pnT} = (e^{pT})^n, a geometric sequence, which is the mode of a discrete-time pole at z=epT.z = e^{pT}. So the map z=esTz = e^{sT} carries continuous-time poles to discrete-time ones, and it carries the geometry with it. Writing s=σ+jωs = \sigma + j\omega gives ∣z∣=eσT|z| = e^{\sigma T} and ∠z=ωT\angle z = \omega T:

  • the left half-plane (σ<0\sigma < 0) goes inside the unit circle (∣z∣<1|z| < 1), so stable stays stable;
  • the imaginary axis (σ=0\sigma = 0) goes onto the unit circle, with frequency ω\omega becoming the angle ωT=2πf/fs\omega T = 2\pi f/f_s;
  • lines of constant decay rate become circles, and s=0s = 0 goes to z=1z = 1.

The map wraps the s-plane round and round: ss and s+j2πfss + j2\pi f_s land on the same zz. That is aliasing once again, now as a statement about poles: frequencies differing by a multiple of fsf_s are indistinguishable after sampling. The program maps the RLC circuit's ζ=0.3\zeta = 0.3 poles to the z-plane at fs=50f_s = 50 kHz, builds a two-pole recursion with exactly those poles, and checks that it reproduces the sampled impulse response of the circuit.

python
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")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

The poles at −3000±9539j-3000 \pm 9539j land at radius e−3000/50,000=0.94176e^{-3000/50{,}000} = 0.94176 and angle ±10.93°\pm 10.93° (which is 9539/50,0009539/50{,}000 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.

ExplanationH

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, x˙=Ax+Bu\dot{\mathbf x} = A\mathbf x + B u, the poles are the eigenvalues of AA, the starting point of Lumenary Robotics' state space and LQR.

Common misconceptionsH

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 ∫∣h∣\int|h| 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 sY(s)sY(s) are in the open left half-plane. Otherwise it returns a number that means nothing.

Misconception

"More damping is always better." Beyond ζ=1\zeta = 1 the response gets slower, not better: at ζ=2\zeta = 2 the RLC circuit took 1.49 ms to settle against 0.60 ms at ζ=0.707\zeta = 0.707. Design is a trade-off between speed and overshoot.

Misconception

"The Laplace transform is just the Fourier transform with ss instead of jωj\omega." 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.

History & global context

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 d/dtd/dt as an algebraic symbol pp, 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

Exercises

1. The Laplace transform and stability

Warm-upHuman

An RC low-pass filter has R=10 kΩR = 10\ \mathrm{k\Omega} and C=100C = 100 nF, so H(s)=1/(1+sRC)H(s) = 1/(1 + sRC). Where is its pole on the real axis of the s-plane, in units of 1/s?

2. The Laplace transform and stability

Warm-upHuman

A stable system has transfer function H(s)=10s2+3s+2H(s) = \dfrac{10}{s^2 + 3s + 2}. A unit step is applied at t=0t = 0. What value does the output settle to?

3. The Laplace transform and stability

CoreHuman

A second-order system ω02/(s2+2ζω0s+ω02)\omega_0^2/(s^2 + 2\zeta\omega_0 s + \omega_0^2) has damping ratio ζ=0.5\zeta = 0.5. By what percentage does its step response overshoot its final value? Give the nearest whole number.

4. The Laplace transform and stability

CoreHuman

Which of these transfer functions are BIBO stable? Select all that apply.

Choose all that apply

5. The Laplace transform and stability

CoreHuman

A continuous-time pole at s=−1000+j 2π⋅1000s = -1000 + j\,2\pi \cdot 1000 (in s⁻¹) is mapped to discrete time with z=esTz = e^{sT} at fs=10f_s = 10 kHz. Where does it land?

Choose one

6. The Laplace transform and stability

CoreComputational

Write step_response(num, den, t): the step response of H(s)=N(s)/D(s)H(s) = N(s)/D(s) (coefficient lists, highest power first), computed by partial fractions of Y(s)=H(s)/sY(s) = H(s)/s. Assume HH is strictly proper and stable with distinct poles. Find the poles of YY (those of HH plus s=0s = 0), compute each residue with the cover-up rule r=N(p)/DY′(p)r = N(p)/D_Y'(p), and return ∑r ept\sum r\,e^{pt} (its real part) at the times t.

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

7. The Laplace transform and stability

StretchComputational

Decide stability without computing roots. Write cubic_is_stable(a3, a2, a1, a0) returning True exactly when every root of a3s3+a2s2+a1s+a0a_3 s^3 + a_2 s^2 + a_1 s + a_0 (with a3>0a_3 > 0) 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).

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

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.