## Quantization

### Represent Partitions

Scalar quantization is a process that maps all inputs within a specified range to a common value. This process maps inputs in a different range of values to a different common value. In effect, scalar quantization digitizes an analog signal. Two parameters determine a quantization: a partition and a codebook.

A quantization partition defines several contiguous, nonoverlapping ranges of
values within the set of real numbers. To specify a partition in the MATLAB^{®} environment, list the distinct endpoints of the different ranges in a
vector.

For example, if the partition separates the real number line into the four sets

{x: x ≤ 0}

{x: 0< x ≤ 1}

{x: 1 < x ≤ 3}

{x: 3 < x}

then you can represent the partition as the three-element vector

partition = [0,1,3];

The length of the partition vector is one less than the number of partition intervals.

### Represent Codebooks

A codebook tells the quantizer which common value to assign to inputs that fall into each range of the partition. Represent a codebook as a vector whose length is the same as the number of partition intervals. For example, the vector

codebook = [-1, 0.5, 2, 3];

is one possible codebook for the partition `[0,1,3]`

.

### Determine Which Interval Each Input Is In

The `quantiz`

function also returns a
vector that tells which interval each input is in. For example, the output below
says that the input entries lie within the intervals labeled 0, 6, and 5,
respectively. Here, the 0th interval consists of real numbers less than or equal to
3; the 6th interval consists of real numbers greater than 8 but less than or equal
to 9; and the 5th interval consists of real numbers greater than 7 but less than or
equal to 8.

partition = [3,4,5,6,7,8,9]; index = quantiz([2 9 8],partition)

The output is

index = 0 6 5

If you continue this example by defining a codebook vector such as

codebook = [3,3,4,5,6,7,8,9];

then the equation below relates the vector `index`

to the
quantized signal `quants`

.

quants = codebook(index+1);

This formula for `quants`

is exactly what the
`quantiz`

function uses if you instead phrase the example more
concisely as below.

partition = [3,4,5,6,7,8,9]; codebook = [3,3,4,5,6,7,8,9]; [index,quants] = quantiz([2 9 8],partition,codebook);

### Optimize Quantization Parameters

#### Section Overview

Quantization distorts a signal. You can reduce distortion by choosing
appropriate partition and codebook parameters. However, testing and selecting
parameters for large signal sets with a fine quantization scheme can be tedious.
One way to produce partition and codebook parameters easily is to optimize them
according to a set of so-called *training data*.

**Note**

The training data you use should be typical of the kinds of signals you will actually be quantizing.

#### Example: Optimizing Quantization Parameters

The `lloyds`

function optimizes the partition and codebook
according to the Lloyd algorithm. The code below optimizes the partition and
codebook for one period of a sinusoidal signal, starting from a rough initial
guess. Then it uses these parameters to quantize the original signal using the
initial guess parameters as well as the optimized parameters. The output shows
that the mean square distortion after quantizing is much less for the optimized
parameters. The `quantiz`

function automatically computes the
mean square distortion and returns it as the third output parameter.

% Start with the setup from 2nd example in "Quantizing a Signal." t = [0:.1:2*pi]; sig = sin(t); partition = [-1:.2:1]; codebook = [-1.2:.2:1]; % Now optimize, using codebook as an initial guess. [partition2,codebook2] = lloyds(sig,codebook); [index,quants,distor] = quantiz(sig,partition,codebook); [index2,quant2,distor2] = quantiz(sig,partition2,codebook2); % Compare mean square distortions from initial and optimized [distor, distor2] % parameters.

The output is

ans = 0.0148 0.0024

### Quantize a Signal

#### Scalar Quantization Example 1

The code below shows how the `quantiz`

function uses
`partition`

and `codebook`

to map a real
vector, `samp`

, to a new vector, `quantized`

,
whose entries are either -1, 0.5, 2, or 3.

partition = [0,1,3]; codebook = [-1, 0.5, 2, 3]; samp = [-2.4, -1, -.2, 0, .2, 1, 1.2, 1.9, 2, 2.9, 3, 3.5, 5]; [index,quantized] = quantiz(samp,partition,codebook); quantized

The output is below.

quantized = Columns 1 through 6 -1.0000 -1.0000 -1.0000 -1.0000 0.5000 0.5000 Columns 7 through 12 2.0000 2.0000 2.0000 2.0000 2.0000 3.0000 Column 13 3.0000

#### Scalar Quantization Example 2

This example illustrates the nature of scalar quantization more clearly. After
quantizing a sampled sine wave, it plots the original and quantized signals. The
plot contrasts the `x`

's that make up the sine curve with the
dots that make up the quantized signal. The vertical coordinate of each dot is a
value in the vector `codebook`

.

t = [0:.1:2*pi]; % Times at which to sample the sine function sig = sin(t); % Original signal, a sine wave partition = [-1:.2:1]; % Length 11, to represent 12 intervals codebook = [-1.2:.2:1]; % Length 12, one entry for each interval [index,quants] = quantiz(sig,partition,codebook); % Quantize. plot(t,sig,'x',t,quants,'.') legend('Original signal','Quantized signal'); axis([-.2 7 -1.2 1.2])