Chris Impey is a writer based in New York City. He's interested in all things tech, science, and photography related, and likes to yo-yo in his free time.


Follow him [on Twitter](https://twitter.com/chris-impey).

Chris Impey

Emma Hazel is a writer based in New York City. He's interested in all things tech, science, and photography related, and likes to yo-yo in his free time.


Follow him [on Twitter](https://twitter.com/emma-hazel).

Emma Hazel

Thomas Macaulay is a writer based in New York City. He's interested in all things tech, science, and photography related, and likes to yo-yo in his free time.


Follow him [on Twitter](https://twitter.com/thomas-macaulay).

Thomas Macaulay


In this post, I explain the concepts of LCC (linear constant-coefficient) systems , impulses, impulse responses and LCCDEs (Linear Constant-Coefficient Difference Equations), working toward an intuitive understanding of convolution.

This isn't a comprehensive theoretical treatment — rather, it's a practical introduction aimed at building intuition through grounded examples and relatable analogies.

# Igor the Robot

Let’s say a robot (we will call him Igor) reports its position $x[k]$ every $T=0.1s$. That is a sampling rate of 10Hz.

Suppose we want to estimate Igo’s velocity using only its position data $x[k]$. 

A simple way to do this is to approximate the derivative using a simple backward difference (fancy term for derivative):

 

$
y[k] = \frac{x[k] - x[k-1]}{T}
$

This is our discrete-time system: it takes two samples and computes a scaled difference — essentially, a numerical derivative.

Before talking about impulse response, convolution (in a latter post), there is 2 proprieties worth defining, mainly, linearity and Time in-variance. 

### Linearity and Time-Invariance

Our system is Linear and Time Invariant **(LTI)** because: 

1. If you double the input, the output doubles (linearity)
2. Delaying the inputs, delays the output by the same amount (time in-variance)

Together, this makes it an **LTI system** (Linear Time-Invariant), and LTI systems have a powerful property:

> They can be fully characterized by their response to a single impulse response.
> 

But, before talking about impulse response, Its worth looking at what a normal system response looks like.  

### A system’s response

From our velocity estimator, 

$$
y[k] = \frac{x[k] - x[k-1]}{T} = \frac{x[k] - x[k-1]}{0.1} = 10x[k] -10x[k-1]\\ 
$$

This tells us how the system responds to any arbitrary input signal $x[k]$ Notice the constant coefficients). 

Suppose we read the  following data for what the robot moved. Remember x[k] is the position we read.

$$
x = [0, 0.5,1.1,1.6,2.0]
$$

| k | $x[k] (m)$ | $x[k−1] (m)$ | $y[k] (m/s)$ |
| --- | --- | --- | --- |
| 0 | 0.0 | — | undefined or 0 |
| 1 | 0.5 | 0.0 | 10(0.5) - 10(0.0) = 10 |
| 2 | 1.1 | 0.5 | 10(1.1) - 10(0.5) = 6 |
| 3 | 1.6 | 1.1 | 5 |
| 4 | 2.0 | 1.6 | 4 |

So, the output sequence is:

$$
y[k]=\set{0, 5,6,5,4,...} (m/s)
$$

This gives the instantaneous velocity estimate between samples — a discrete approximation of Igor's speed.

# What’s an Impulse?

Imagine you tap a system very briefly and then watch how it reacts.

- Like striking a bell once (input) and listening to how it rings (response).
- Like snapping your fingers (input) and measuring the sound that follows (response).
- In physics, a hammer hit (impulse) causes vibration (response).
- In electronics, a voltage spike shows how a circuit handles sudden changes.

Mathematically we represent the impulse as as: 

$$
x[k] = \delta[k] = 
\begin{cases}
1, & k =0 \\
0, & \text{otherwise}
\end{cases}
$$

This is the simplest possible input.

# Impulse response

Now, let’s feed this impulse into our system and observe the output.

Given 

$$
y[k] = 10x[k] - 10x[k-1]
$$

Let $x[k] = \delta[k]$

| k | Position `$x[k]$`  | Previous Position $x[k−1]$ | $y[k] =10x[k] - 10x[k]$ |
| --- | --- | --- | --- |
| -1 | — | — | 0 |
| 0 | 1 | 0 | $(1 - 0)/0.1 = 10$ |
| 1 | 0 | 1 | $(0 - 1)/0.1 = -10$ |
| 2+ | 0 | 0 | 0 |

So the output (i.e. impulse response) is 

Thus, the **impulse response** is:

$$
h[k] = \set{\frac{1}{T}, -\frac{1}{T}, 0} =  \set{10,-10}
$$

or more generally:

$$
h[k] = \frac{1}{T}\delta[k] - \frac{1}{T}\delta[k-1] = 10\delta[k] - 10\delta[k-1]
$$

In essence, an impulse response $h[k]$ is the response $y[k]$ when $x[k] = \delta[k]$.

### Why care?

The impulse response is an important idea in Time Domain Analysis is that: 

> If you know how a system responds to an impulse, you can predict its output to **any** signal by using **convolution**
> 

$$
y[k] = x[k] * h[k] 
$$

Here’s how the system might be implemented in code:

```matlab
float h[2] = {10.0, -10.0}; // coefficients
float y = h[0]*x[k] + h[1]*x[k-1];

```

### LCCDEs

A Linear Constant Coefficient Difference Equation is an **equation** that **describes** a discrete-time an LTI system. This equation models how a system behaves over time. That is how current inputs and past ouputs/input determine the present output. LCCDEs are particular useful to us when it comes to actual implementation of systems like filters. 

For example, our velocity estimator is characterized by the equation

$$
y[k] = x[k] - x[k-1]
$$

This is the discrete equivalent of a derivative. More generally, LCCDEs serve the same role in DSP as differential equations do in continuous systems.

Solving an LCCDE with the impulse input $x[k] = \delta[k]$ yields the **impulse response** h[k]h[k]h[k]. Once you have $h[k]$, you can compute the output for *any* input using convolution:

$$
⁍
$$

This is the foundation of **time-domain DSP**.

# Connecting All Together

Let’s connect the dots:

The **impulse** $\delta[k]$ probes how the system behaves.

The system’s response, $h[k]$, **characterizes it fully**.

To compute the output for **any** input $x[k]$, we convolve it with $y[k]=x[k]∗h[k]$

Essentially, once you know $h[k]$, you can fully simulate, analyze, and implement the system.

An intuitive guide to how linear time-invariant systems respond to impulses, with practical examples from signal processing.

Understanding Impulse Responses in Discrete-Time Systems