Throughout Chapter 9 we represent nonlinear dynamics in state-space form as \( \dot{\mathbf{x}} = \mathbf{f}(\mathbf{x},\mathbf{u}) \) with state \( \mathbf{x}\in\mathbb{R}^n \) and input \( \mathbf{u}\in\mathbb{R}^m \). An operating point (equilibrium) \( (\mathbf{x}_0,\mathbf{u}_0) \) satisfies \( \mathbf{f}(\mathbf{x}_0,\mathbf{u}_0)=\mathbf{0} \).

flowchart TD
  S["Start: nonlinear model xdot = f(x,u)"] --> OP["Pick operating point (x0,u0) with f(x0,u0)=0"]
  OP --> P["Define perturbations: dx = x - x0, du = u - u0"]
  P --> J["Compute Jacobians: A = df/dx|0 , B = df/du|0"]
  J --> L["Linearized model: dxdot = A dx + B du"]
  L --> IO["Optional: derive small-signal transfer function(s)"]
  IO --> V["Validate locally: compare nonlinear vs linear for small inputs"]
  V --> E["Use linear model for local behavior + control design later"]
        

Local approximation statement. If \( \mathbf{f} \) is continuously differentiable near \( (\mathbf{x}_0,\mathbf{u}_0) \), then for perturbations \( \delta\mathbf{x}=\mathbf{x}-\mathbf{x}_0 \) and \( \delta\mathbf{u}=\mathbf{u}-\mathbf{u}_0 \) we have

\[ \delta\dot{\mathbf{x}} = \mathbf{A}\,\delta\mathbf{x} + \mathbf{B}\,\delta\mathbf{u} + \mathbf{r}(\delta\mathbf{x},\delta\mathbf{u}), \quad \mathbf{A} \equiv \left.\frac{\partial \mathbf{f}}{\partial \mathbf{x}}\right|_{(\mathbf{x}_0,\mathbf{u}_0)}, \quad \mathbf{B} \equiv \left.\frac{\partial \mathbf{f}}{\partial \mathbf{u}}\right|_{(\mathbf{x}_0,\mathbf{u}_0)} \]

where the remainder satisfies \( \|\mathbf{r}(\delta\mathbf{x},\delta\mathbf{u})\| = \mathcal{O}(\|(\delta\mathbf{x},\delta\mathbf{u})\|^2) \) as \( \|(\delta\mathbf{x},\delta\mathbf{u})\|\to 0 \). The terms \( \mathbf{A}\delta\mathbf{x} \) and \( \mathbf{B}\delta\mathbf{u} \) define the small-signal (local) linear model.

Proof sketch via multivariate Taylor expansion.

For each component \( f_i(\mathbf{x},\mathbf{u}) \), apply the first-order Taylor formula around \( (\mathbf{x}_0,\mathbf{u}_0) \):

\[ f_i(\mathbf{x}_0+\delta\mathbf{x},\mathbf{u}_0+\delta\mathbf{u}) = f_i(\mathbf{x}_0,\mathbf{u}_0) + \left.\nabla_{\mathbf{x}} f_i\right|_0^{\!\top}\delta\mathbf{x} + \left.\nabla_{\mathbf{u}} f_i\right|_0^{\!\top}\delta\mathbf{u} + \rho_i \]

where \( \rho_i \) collects the second- and higher-order terms. Stacking all components yields the matrix form with Jacobians \( \mathbf{A},\mathbf{B} \). If \( \nabla f \) is locally Lipschitz, a standard Taylor remainder bound implies \( \|\mathbf{r}\|\le c\|(\delta\mathbf{x},\delta\mathbf{u})\|^2 \) for sufficiently small perturbations.

Consider a point-mass pendulum of mass \( m \) and length \( \ell \), with viscous rotational damping \( b \), driven by input torque \( u(t)=\tau(t) \). Let \( \theta \) be the angle from the downward vertical (so \( \theta=0 \) is “hanging down”).

Nonlinear equation of motion.

\[ m\ell^2 \ddot{\theta} + b\dot{\theta} + m g \ell \sin\theta = \tau \]

Define state \( x_1=\theta \), \( x_2=\dot{\theta} \). Then \( \mathbf{x}=\begin{bmatrix}x_1& x_2\end{bmatrix}^\top \) and:

\[ \dot{x}_1 = x_2,\qquad \dot{x}_2 = -\frac{b}{m\ell^2}x_2 - \frac{g}{\ell}\sin x_1 + \frac{1}{m\ell^2}\tau \]

Equilibria (operating points).

An equilibrium satisfies \( \dot{x}_1=0 \), \( \dot{x}_2=0 \). Hence \( x_{2,0}=0 \) and

\[ 0 = -\frac{g}{\ell}\sin x_{1,0} + \frac{1}{m\ell^2}\tau_0 \quad\Longrightarrow\quad \tau_0 = m g \ell \sin x_{1,0}. \]

Two important zero-torque equilibria are \( (x_{1,0},x_{2,0},\tau_0)=(0,0,0) \) (downward) and \( (\pi,0,0) \) (upright).

Jacobian linearization.

Let \( \delta\theta = \theta-\theta_0 \), \( \delta\omega = \dot{\theta}-0 \), \( \delta \tau = \tau-\tau_0 \). The Jacobians at \( \theta_0=x_{1,0} \) give:

\[ \delta\dot{\mathbf{x}} = \mathbf{A}\,\delta\mathbf{x} + \mathbf{B}\,\delta \tau, \quad \delta\mathbf{x}= \begin{bmatrix}\delta\theta\\ \delta\omega\end{bmatrix}, \]

\[ \mathbf{A} = \begin{bmatrix} 0 & 1\\ -\frac{g}{\ell}\cos\theta_0 & -\frac{b}{m\ell^2} \end{bmatrix}, \qquad \mathbf{B} = \begin{bmatrix} 0\\ \frac{1}{m\ell^2} \end{bmatrix}. \]

Local stability insight (by characteristic polynomial).

The characteristic polynomial of \( \mathbf{A} \) is

\[ p(s)=\det(s\mathbf{I}-\mathbf{A}) = s^2 + \frac{b}{m\ell^2}s + \frac{g}{\ell}\cos\theta_0. \]

If \( \cos\theta_0 > 0 \) (e.g. \( \theta_0=0 \)) and \( b>0 \), both roots have negative real part, so the equilibrium is locally stable (damped oscillation). If \( \cos\theta_0 < 0 \) (e.g. \( \theta_0=\pi \)), then the constant term is negative and the two roots have opposite signs, implying an unstable saddle equilibrium.

Small-signal transfer function (torque to angle).

\[ \frac{\Delta\Theta(s)}{\Delta \tau(s)} = \frac{\frac{1}{m\ell^2}} {s^2 + \frac{b}{m\ell^2}s + \frac{g}{\ell}\cos\theta_0 }. \]

Remark (connection to small-angle approximation). Around \( \theta_0=0 \), the linearization replaces \( \sin\theta \) by \( \theta \) in the restoring term. The next nonzero Taylor term is cubic, providing an explicit local error scale (used in Problem 4).

A standard armature-controlled DC motor is often linear, but nonlinearities naturally arise from loads. A common theoretical model for fan/pump-type loads is \( \tau_L(\omega)=c\,\omega^2 \), yielding a nonlinear mechanical equation.

Nonlinear state-space model.

Let \( i \) be armature current and \( \omega \) be shaft speed. Input is armature voltage \( v \). Parameters: \( L,R \) (armature inductance/resistance), \( K_e \) (back-EMF constant), \( K_t \) (torque constant), \( J \) (inertia), \( b \) (viscous friction), \( c \) (quadratic load coefficient).

\[ \dot{i} = \frac{1}{L}\Big(v - R i - K_e \omega\Big),\qquad \dot{\omega} = \frac{1}{J}\Big(K_t i - b\omega - c\omega^2\Big). \]

Define \( \mathbf{x}=\begin{bmatrix}i&\omega\end{bmatrix}^\top \), \( u=v \). This is nonlinear due to the \( -c\omega^2 \) term.

Operating point.

An equilibrium \( (i_0,\omega_0,v_0) \) satisfies:

\[ 0 = v_0 - R i_0 - K_e \omega_0,\qquad 0 = K_t i_0 - b\omega_0 - c\omega_0^2. \]

From the second equation: \( i_0 = \frac{b\omega_0 + c\omega_0^2}{K_t} \). Substituting into the first yields the required \( v_0 \).

Linearization around \( (i_0,\omega_0) \).

Let \( \delta i=i-i_0 \), \( \delta\omega=\omega-\omega_0 \), \( \delta v = v-v_0 \). The Jacobians give:

\[ \begin{bmatrix}\delta\dot{i}\\ \delta\dot{\omega}\end{bmatrix} = \underbrace{ \begin{bmatrix} -\frac{R}{L} & -\frac{K_e}{L}\\ \frac{K_t}{J} & -\frac{b+2c\omega_0}{J} \end{bmatrix}}_{\mathbf{A}} \begin{bmatrix}\delta i\\ \delta\omega\end{bmatrix} + \underbrace{ \begin{bmatrix}\frac{1}{L}\\ 0\end{bmatrix}}_{\mathbf{B}} \delta v. \]

The effect of the nonlinear load appears as an operating-point-dependent effective damping term \( b_{\mathrm{eff}}=b+2c\omega_0 \). Hence, the same motor is “more damped” at higher speeds if \( c>0 \).

Small-signal transfer function \( \Delta V \to \Delta \Omega \).

Eliminating \( \delta i \) in Laplace domain gives:

\[ \frac{\Delta\Omega(s)}{\Delta V(s)} = \frac{\frac{K_t}{JL}} {s^2 + \left(\frac{R}{L}+\frac{b+2c\omega_0}{J}\right)s + \frac{R(b+2c\omega_0)+K_eK_t}{JL}}. \]

This is a second-order small-signal model whose coefficients depend on \( \omega_0 \). This dependency is exactly what motivates linearizing “about a chosen operating speed.”

Consider a tank of constant cross-sectional area \( A_t \) with inflow \( q_{in}(t) \) and outflow through an orifice. A common theoretical outflow law is \( q_{out}(h)=a\sqrt{2gh} \), where \( h(t) \) is the fluid height, \( g \) gravity, and \( a \) aggregates discharge/orifice effects.

Nonlinear mass balance.

\[ A_t \dot{h} = q_{in} - a\sqrt{2gh}. \]

Take state \( x=h \) and input \( u=q_{in} \):

\[ \dot{h} = f(h,u) = \frac{1}{A_t}\Big(u - a\sqrt{2gh}\Big). \]

Operating point.

At equilibrium \( \dot{h}=0 \), so \( u_0 = a\sqrt{2g h_0} \).

Linearization.

Let \( \delta h=h-h_0 \), \( \delta u=u-u_0 \). Compute partial derivatives:

\[ \frac{\partial f}{\partial u} = \frac{1}{A_t},\qquad \frac{\partial f}{\partial h} = -\frac{a}{A_t}\frac{\mathrm{d}}{\mathrm{d}h}\sqrt{2gh} = -\frac{a}{A_t}\frac{g}{\sqrt{2gh}}. \]

Evaluated at \( h_0 \), the small-signal model is first order:

\[ \delta\dot{h} = -k_h\,\delta h + \frac{1}{A_t}\delta u, \qquad k_h \equiv \frac{a g}{A_t\sqrt{2g h_0}}. \]

Small-signal transfer function.

\[ \frac{\Delta H(s)}{\Delta Q_{in}(s)} = \frac{\frac{1}{A_t}}{s+k_h}. \]

The time constant is \( T = \frac{1}{k_h} \), which depends on \( h_0 \). Larger operating height increases \( \sqrt{h_0} \), decreases \( k_h \), and therefore increases the time constant—i.e., the tank level responds more slowly around higher operating levels for fixed geometry.

Linearization is only guaranteed to approximate the nonlinear dynamics in a neighborhood of the operating point. A practical way to verify “small enough” is to compare trajectories driven by the same small input perturbation. Define the approximation error: \( \mathbf{e}(t)=\mathbf{x}_{nl}(t)-(\mathbf{x}_0+\delta\mathbf{x}_{lin}(t)) \).

If the remainder term is quadratic, then for sufficiently small perturbations, a typical bound is of the form \( \|\mathbf{e}(t)\|\le C\epsilon^2 \) over a finite time horizon, where \( \epsilon \) scales the perturbation magnitude.

flowchart TD
  A["Choose (x0,u0)"] --> B["Pick small test input du(t)"]
  B --> C["Simulate nonlinear: x_nl(t)"]
  B --> D["Simulate linear: \ndx_lin(t) with dxdot = A dx + B du"]
  C --> E["Compute error: \ne(t) = x_nl(t) - (x0 + dx_lin(t))"]
  E --> F["If error too large: \nreduce input magnitude or reselect operating point"]
  F --> B
        

Recommended libraries: sympy (symbolic Jacobians), numpy, scipy (numerical integration), and control (state-space / transfer functions).

import numpy as np
import sympy as sp

# ---------- (A) Pendulum linearization ----------
m, l, b, g = sp.symbols('m l b g', positive=True)
theta, omega, tau = sp.symbols('theta omega tau', real=True)

f_p = sp.Matrix([
    omega,
    -(b/(m*l**2))*omega - (g/l)*sp.sin(theta) + (1/(m*l**2))*tau
])

x_p = sp.Matrix([theta, omega])
u_p = sp.Matrix([tau])

A_p = f_p.jacobian(x_p)
B_p = f_p.jacobian(u_p)

# Operating point: theta0 = 0 or pi, omega0 = 0, tau0 = m g l sin(theta0)
theta0 = 0
A_p0 = sp.simplify(A_p.subs({theta: theta0, omega: 0}))
B_p0 = sp.simplify(B_p.subs({theta: theta0, omega: 0}))

print("Pendulum A(theta0):")
sp.pprint(A_p0)
print("Pendulum B:")
sp.pprint(B_p0)

# ---------- (B) DC motor with quadratic load ----------
L, R, Ke, Kt, J, c = sp.symbols('L R Ke Kt J c', positive=True)
i, w, v = sp.symbols('i w v', real=True)

f_m = sp.Matrix([
    (1/L)*(v - R*i - Ke*w),
    (1/J)*(Kt*i - b*w - c*w**2)
])
x_m = sp.Matrix([i, w])
u_m = sp.Matrix([v])

A_m = sp.simplify(f_m.jacobian(x_m))
B_m = sp.simplify(f_m.jacobian(u_m))

# Substitute an operating speed w0; compute i0 from equilibrium (second equation)
w0 = sp.symbols('w0', real=True)
i0_expr = (b*w0 + c*w0**2)/Kt

A_m0 = sp.simplify(A_m.subs({i: i0_expr, w: w0}))
B_m0 = sp.simplify(B_m.subs({i: i0_expr, w: w0}))

print("\nMotor A(w0):")
sp.pprint(A_m0)
print("Motor B:")
sp.pprint(B_m0)

# ---------- (C) Tank linearization ----------
At, a = sp.symbols('At a', positive=True)
h, qin = sp.symbols('h qin', real=True)

f_t = sp.Matrix([(1/At)*(qin - a*sp.sqrt(2*g*h))])
x_t = sp.Matrix([h])
u_t = sp.Matrix([qin])

A_t = sp.simplify(f_t.jacobian(x_t)[0])
B_t = sp.simplify(f_t.jacobian(u_t)[0])

h0 = sp.symbols('h0', positive=True)
A_t0 = sp.simplify(A_t.subs({h: h0}))
B_t0 = sp.simplify(B_t)

print("\nTank A(h0) = df/dh:")
sp.pprint(A_t0)
print("Tank B = df/du:")
sp.pprint(B_t0)
      

To validate locally, simulate the nonlinear model and its linearization under a small input perturbation and compare trajectories (Section 5). Use scipy.integrate.solve_ivp for nonlinear dynamics and linear state-space propagation for the linear model.

Recommended libraries: Eigen for linear algebra. Below is a minimal RK4 integrator for the nonlinear pendulum and construction of \( \mathbf{A},\mathbf{B} \) at \( \theta_0=0 \).

#include <iostream>
#include <Eigen/Dense>
#include <cmath>

struct Params {
  double m, l, b, g;
};

Eigen::Vector2d pendulum_f(const Eigen::Vector2d& x, double tau, const Params& p) {
  // x = [theta, omega]
  double theta = x(0), omega = x(1);
  Eigen::Vector2d dx;
  dx(0) = omega;
  dx(1) = -(p.b/(p.m*p.l*p.l))*omega - (p.g/p.l)*std::sin(theta) + (1.0/(p.m*p.l*p.l))*tau;
  return dx;
}

Eigen::Vector2d rk4_step(const Eigen::Vector2d& x, double u, double dt, const Params& p) {
  Eigen::Vector2d k1 = pendulum_f(x, u, p);
  Eigen::Vector2d k2 = pendulum_f(x + 0.5*dt*k1, u, p);
  Eigen::Vector2d k3 = pendulum_f(x + 0.5*dt*k2, u, p);
  Eigen::Vector2d k4 = pendulum_f(x + dt*k3, u, p);
  return x + (dt/6.0)*(k1 + 2.0*k2 + 2.0*k3 + k4);
}

int main() {
  Params p{1.0, 0.5, 0.05, 9.81};

  // Linearization at theta0 = 0, omega0 = 0
  double theta0 = 0.0;
  Eigen::Matrix2d A;
  A << 0.0, 1.0,
       -(p.g/p.l)*std::cos(theta0), -(p.b/(p.m*p.l*p.l));
  Eigen::Vector2d B;
  B << 0.0, 1.0/(p.m*p.l*p.l);

  std::cout << "A =\n" << A << "\nB =\n" << B << "\n";

  // Nonlinear simulation with small torque pulse
  double dt = 1e-3;
  int N = 5000;
  Eigen::Vector2d x; x << 0.05, 0.0; // small initial angle
  for (int k=0; k<N; ++k) {
    double t = k*dt;
    double tau = (t < 0.2) ? 0.01 : 0.0;
    x = rk4_step(x, tau, dt, p);
    if (k % 500 == 0) {
      std::cout << "t=" << t << " theta=" << x(0) << " omega=" << x(1) << "\n";
    }
  }
  return 0;
}
      

Recommended libraries: EJML (matrices) and Apache Commons Math (ODE solvers). Below is a compact example for the tank linearization and a nonlinear simulation.

import org.ejml.simple.SimpleMatrix;
import org.apache.commons.math3.ode.FirstOrderDifferentialEquations;
import org.apache.commons.math3.ode.nonstiff.DormandPrince853Integrator;

public class TankLinearization {
  static class TankODE implements FirstOrderDifferentialEquations {
    final double At, a, g;
    final double qin;
    TankODE(double At, double a, double g, double qin) { this.At=At; this.a=a; this.g=g; this.qin=qin; }
    public int getDimension() { return 1; }
    public void computeDerivatives(double t, double[] x, double[] xDot) {
      double h = x[0];
      double qout = a * Math.sqrt(2.0*g*Math.max(h, 0.0));
      xDot[0] = (1.0/At) * (qin - qout);
    }
  }

  public static void main(String[] args) {
    double At = 0.05, a = 1.0e-4, g = 9.81;
    double h0 = 0.20;

    // Operating inflow: q0 = a*sqrt(2 g h0)
    double q0 = a*Math.sqrt(2.0*g*h0);

    // Linearization: dhdot = A*dh + B*dq
    double k_h = (a*g)/(At*Math.sqrt(2.0*g*h0));
    double A = -k_h;
    double B = 1.0/At;

    SimpleMatrix Amat = new SimpleMatrix(1,1, true, new double[]{A});
    SimpleMatrix Bmat = new SimpleMatrix(1,1, true, new double[]{B});

    System.out.println("A = " + Amat);
    System.out.println("B = " + Bmat);

    // Nonlinear simulation with small step in inflow
    double dq = 0.1*q0;
    double qin = q0 + dq;

    DormandPrince853Integrator integrator =
        new DormandPrince853Integrator(1e-6, 0.05, 1e-9, 1e-9);
    FirstOrderDifferentialEquations ode = new TankODE(At, a, g, qin);

    double[] x = new double[]{h0};
    integrator.integrate(ode, 0.0, x, 5.0, x);

    System.out.println("Nonlinear h(5s) = " + x[0]);
  }
}
      

MATLAB can compute Jacobians symbolically (Symbolic Math Toolbox) or numerically (finite differences). Below we show symbolic linearization for the DC motor with quadratic load and construction of the small-signal transfer function.

% ---------- DC motor with quadratic load: symbolic linearization ----------
syms i w v L R Ke Kt J b c w0 real
assumeAlso([L R Ke Kt J b c] > 0)

f1 = (1/L)*(v - R*i - Ke*w);
f2 = (1/J)*(Kt*i - b*w - c*w^2);

x = [i; w];
u = v;

A = jacobian([f1; f2], x);
B = jacobian([f1; f2], u);

% Equilibrium current for operating speed w0: 0 = Kt*i0 - b*w0 - c*w0^2
i0 = (b*w0 + c*w0^2)/Kt;

A0 = simplify(subs(A, {i,w}, {i0,w0}));
B0 = simplify(subs(B, {i,w}, {i0,w0}));

disp('A0 ='); disp(A0);
disp('B0 ='); disp(B0);

% Build state-space (symbolic to numeric requires substituting parameter values)
% Example numeric substitution:
par = struct('L',0.5,'R',2,'Ke',0.1,'Kt',0.1,'J',0.02,'b',0.01,'c',0.002,'w0',50);

A_num = double(subs(A0, [L R Ke Kt J b c w0], [par.L par.R par.Ke par.Kt par.J par.b par.c par.w0]));
B_num = double(subs(B0, [L R Ke Kt J b c w0], [par.L par.R par.Ke par.Kt par.J par.b par.c par.w0]));
C_num = [0 1];  % output = omega
D_num = 0;

sys = ss(A_num, B_num, C_num, D_num);
Gvw = tf(sys);  % small-signal transfer function DeltaV -> DeltaOmega
disp(Gvw);

% ---------- Simulink note ----------
% In Simulink, implement the nonlinear equations with Integrator blocks,
% then use an Operating Point (trim) and linearize using:
%   op = operpoint('your_model_name');
%   linsys = linearize('your_model_name', op);
      

The Simulink workflow is conceptually identical to Section 1: build a nonlinear model, select/compute an operating point, and linearize to obtain \( \mathbf{A},\mathbf{B},\mathbf{C},\mathbf{D} \).

Mathematica can compute Jacobians directly with D, and can simulate nonlinear ODEs with NDSolve.

(* ---------- Pendulum linearization ---------- *)
ClearAll[m, l, b, g, tau, th, om];
f = {
  om,
  -(b/(m l^2)) om - (g/l) Sin[th] + (1/(m l^2)) tau
};
x = {th, om};
u = {tau};

A = D[f, {x}];
B = D[f, {u}];

theta0 = 0;  (* or Pi *)
A0 = Simplify[A /. {th -> theta0, om -> 0}];
B0 = Simplify[B /. {th -> theta0, om -> 0}];

A0 // MatrixForm
B0 // MatrixForm

(* ---------- Nonlinear simulation (small torque pulse) ---------- *)
params = {m -> 1.0, l -> 0.5, b -> 0.05, g -> 9.81};
tauIn[t_] := Piecewise[{ {0.01, t < 0.2} }, 0.0];

sol = NDSolve[
  {
    th'[t] == om[t],
    om'[t] == (-(b/(m l^2)) om[t] - (g/l) Sin[th[t]] + (1/(m l^2)) tauIn[t]) /. params,
    th[0] == 0.05, om[0] == 0
  },
  {th, om}, {t, 0, 5}
];

(* th[t] /. sol gives the nonlinear trajectory *)
      

Problem 1 (Pendulum Jacobian and equilibrium type): For the torque-driven pendulum \( m\ell^2\ddot{\theta}+b\dot{\theta}+mg\ell\sin\theta=\tau \), define \( x_1=\theta \), \( x_2=\dot{\theta} \). (a) Compute the Jacobians \( \mathbf{A},\mathbf{B} \) about an equilibrium \( (\theta_0,0,\tau_0) \). (b) Using the characteristic polynomial, classify local behavior for \( \theta_0=0 \) and \( \theta_0=\pi \) when \( b>0 \).

Solution:

(a) The state model is \( \dot{x}_1=x_2 \), \( \dot{x}_2=-(b/(m\ell^2))x_2-(g/\ell)\sin x_1+(1/(m\ell^2))\tau \). Therefore:

\[ \mathbf{A}= \begin{bmatrix} 0 & 1\\ -\frac{g}{\ell}\cos\theta_0 & -\frac{b}{m\ell^2} \end{bmatrix},\qquad \mathbf{B}= \begin{bmatrix} 0\\ \frac{1}{m\ell^2} \end{bmatrix}. \]

(b) The characteristic polynomial is \( p(s)=s^2+(b/(m\ell^2))s+(g/\ell)\cos\theta_0 \). For \( \theta_0=0 \), \( \cos\theta_0=1 \) and the constant term is positive; with \( b>0 \), both roots have negative real part (damped oscillatory stability). For \( \theta_0=\pi \), \( \cos\theta_0=-1 \), so the constant term is negative, implying one positive and one negative real root (unstable saddle).

Problem 2 (Motor small-signal coefficients depend on \( \omega_0 \)): For the DC motor \( \dot{i}=(1/L)(v-Ri-K_e\omega) \), \( \dot{\omega}=(1/J)(K_t i-b\omega-c\omega^2) \), compute the linearized model at operating speed \( \omega_0 \). Show explicitly how the effective damping term depends on \( \omega_0 \).

Solution:

The Jacobian entries are \( \partial \dot{i}/\partial i=-R/L \), \( \partial \dot{i}/\partial \omega=-K_e/L \), \( \partial \dot{\omega}/\partial i=K_t/J \), and \( \partial \dot{\omega}/\partial \omega=-(b+2c\omega)/J \). Evaluating at \( \omega=\omega_0 \) gives:

\[ \mathbf{A}(\omega_0)= \begin{bmatrix} -\frac{R}{L} & -\frac{K_e}{L}\\ \frac{K_t}{J} & -\frac{b+2c\omega_0}{J} \end{bmatrix}, \quad \mathbf{B}= \begin{bmatrix} \frac{1}{L}\\ 0 \end{bmatrix}. \]

The term \( b+2c\omega_0 \) is the operating-point-dependent effective viscous damping (a linearization of \( c\omega^2 \)).

Problem 3 (Tank time constant and DC gain): For the tank \( A_t\dot{h}=q_{in}-a\sqrt{2gh} \), linearize around \( h_0>0 \). Compute (a) the time constant \( T \) and (b) the DC gain \( \lim_{s\to 0}\Delta H(s)/\Delta Q_{in}(s) \).

Solution:

The linearization is \( \delta\dot{h}=-k_h\delta h+(1/A_t)\delta q_{in} \) with

\[ k_h=\frac{a g}{A_t\sqrt{2g h_0}}. \]

(a) The time constant is \( T=\frac{1}{k_h}=\frac{A_t\sqrt{2g h_0}}{a g} \). (b) The transfer function is \( \Delta H/\Delta Q_{in}=(1/A_t)/(s+k_h) \), so DC gain:

\[ \lim_{s\to 0}\frac{\Delta H(s)}{\Delta Q_{in}(s)}=\frac{1/A_t}{k_h} = \frac{\sqrt{2g h_0}}{a g}. \]

Problem 4 (Explicit bound for small-angle approximation error): Show that for sufficiently small \( \theta \), the error \( \sin\theta-\theta \) is cubic order. Provide an explicit bound using Taylor’s theorem with remainder for \( |\theta| < 1 \).

Solution:

The Taylor expansion about 0 is \( \sin\theta = \theta - \theta^3/6 + R_5(\theta) \), where the remainder can be written (Lagrange form) as:

\[ R_5(\theta)=\frac{\sin(\xi)}{120}\theta^5 \quad\text{for some }\xi\text{ between }0\text{ and }\theta. \]

Hence for \( |\theta| < 1 \) we have \( |\sin(\xi)|\le 1 \), so:

\[ |\sin\theta-\theta| = \left|-\frac{\theta^3}{6}+R_5(\theta)\right| \le \frac{|\theta|^3}{6}+\frac{|\theta|^5}{120} \le \left(\frac{1}{6}+\frac{1}{120}\right)|\theta|^3 = \frac{21}{120}|\theta|^3. \]

Therefore \( \sin\theta-\theta = \mathcal{O}(|\theta|^3) \) near 0, quantifying why the linearized pendulum is accurate only locally.

We constructed three small-signal linear models by (i) selecting equilibria, (ii) computing Jacobians to obtain \( \mathbf{A},\mathbf{B} \), and (iii) deriving local transfer functions. The pendulum illustrates how equilibrium choice changes stability (downward vs upright). The DC motor example shows operating-point-dependent linear dynamics when the load is nonlinear. The tank example shows how a square-root outflow yields a first-order model with time constant depending on the operating level.