# dsp.CICDecimator

Decimate signal using cascaded integrator-comb (CIC) filter

## Description

The `dsp.CICDecimator`

System object™ decimates an input signal using a cascaded integrator-comb (CIC) decimation
filter. The CIC decimation filter structure consists of *N* sections of
cascaded integrators, followed by a rate change by a factor of *R*, followed
by *N* sections of cascaded comb filters. For details, see Algorithms. The NumSections property specifies *N*, the number of sections in
the CIC filter. The DecimationFactor property
specifies *R*, the decimation factor. The `getFixedPointInfo`

function returns the word lengths and fraction lengths of the fixed-point sections and the
output for the `dsp.CICDecimator`

System object. You can also generate HDL code for this System object using the `generatehdl`

function.

**Note**

This object requires a Fixed-Point Designer™ license.

To decimate a signal using a CIC filter:

Create the

`dsp.CICDecimator`

object and set its properties.Call the object with arguments, as if it were a function.

To learn more about how System objects work, see What Are System Objects?

## Creation

### Syntax

### Description

creates a CIC
decimation System object that applies a CIC decimation filter to the input signal.`cicDecim`

= dsp.CICDecimator

creates a CIC decimation object with the `cicDecim`

= dsp.CICDecimator(`R`

,`M`

,`N`

)`DecimationFactor`

property
set to `R`

, the `DifferentialDelay`

property set to
`M`

, and the `NumSections`

property set to
`N`

.

creates a CIC decimation object with each specified property set to the specified value.
Enclose each property name in single quotes. You can use this syntax with any previous
input argument combination.`cicDecim`

= dsp.CICDecimator(`Name,Value`

)

## Properties

Unless otherwise indicated, properties are *nontunable*, which means you cannot change their
values after calling the object. Objects lock when you call them, and the
`release`

function unlocks them.

If a property is *tunable*, you can change its value at
any time.

For more information on changing property values, see System Design in MATLAB Using System Objects.

`DecimationFactor`

— Decimation factor

`2`

(default) | positive integer

Factor by which the input signal is decimated, specified as a positive integer.

**Data Types: **`single`

| `double`

| `int8`

| `int16`

| `int32`

| `int64`

| `uint8`

| `uint16`

| `uint32`

| `uint64`

`DifferentialDelay`

— Differential delay of filter comb sections

`1`

(default) | positive integer

Differential delay value used in each of the comb sections of the filter, specified
as a positive integer. For details, see Algorithms. If the differential
delay is a built-in integer data type, the decimation factor must be the same integer
data type or `double`

. For example, if the differential delay is an
`int8`

, then the decimation factor must be an `int8`

or `double`

.

**Data Types: **`single`

| `double`

| `int8`

| `int16`

| `int32`

| `int64`

| `uint8`

| `uint16`

| `uint32`

| `uint64`

`NumSections`

— Number of integrator and comb sections

`2`

(default) | positive integer

Number of integrator and comb sections of the CIC filter, specified as a positive integer. This number indicates the number of sections in either the comb part or the integrator part of the filter. The total number of sections in the CIC filter is twice the number of sections given by this property.

**Data Types: **`single`

| `double`

| `int8`

| `int16`

| `int32`

| `int64`

| `uint8`

| `uint16`

| `uint32`

| `uint64`

`FixedPointDataType`

— Fixed-point property designations

`Full precision`

(default) | `Minimum section word lengths`

| `Specify word lengths`

| `Specify word and fraction lengths`

Fixed-point property designations, specified as one of the following:

`Full precision`

– The word length and fraction length of the CIC filter sections and the object output operate in full precision.`Minimum section word lengths`

– Specify the output word length through the OutputWordLength property. The object determines the filter section data type and the output fraction length that give the best possible precision. For details, see`getFixedPointInfo`

and`cicDecimOut`

argument.`Specify word lengths`

– Specify the word lengths of the CIC filter sections and the object output through the SectionWordLengths and OutputWordLength properties. The object determines the corresponding fraction lengths to give the best possible precision. For details, see`getFixedPointInfo`

and the`cicDecimOut`

argument.`Specify word and fraction lengths`

– Specify the word length and fraction length of the CIC filter sections and the object output through the SectionWordLengths, SectionFractionLengths, OutputWordLength, and OutputFractionLength properties.

`SectionWordLengths`

— Fixed-point word lengths for each filter section

`[16 16 16 16]`

(default) | scalar | vector

Fixed-point word lengths to use for each filter section, specified as a scalar or a
row vector of integers. The word length must be greater than or equal to 2. If you
specify a scalar, the value applies to all the sections of the filter. If you specify a
vector, the vector must be of length 2 × `NumSections`

.

**Example: **`32`

**Example: **`[32 32 32 32]`

#### Dependencies

This property applies when you set the `FixedPointDataType`

property to `'Specify word lengths'`

or ```
'Specify word and
fraction lengths'
```

.

**Data Types: **`single`

| `double`

| `int8`

| `int16`

| `int32`

| `int64`

| `uint8`

| `uint16`

| `uint32`

| `uint64`

`SectionFractionLengths`

— Fixed-point fraction lengths for each filter section

`0`

(default) | scalar | vector

Fixed-point fraction lengths to use for each filter section, specified as a scalar
or a row vector of integers. The fraction length can be negative, 0, or positive. If you
specify a scalar, the value applies to all the sections of the filter. If you specify a
vector, the vector must be of length 2 × `NumSections`

.

**Example: **`-2`

**Example: **`[-2 0 5 8]`

#### Dependencies

This property applies when you set the `FixedPointDataType`

property to `'Specify word and fraction lengths'`

.

**Data Types: **`single`

| `double`

| `int8`

| `int16`

| `int32`

| `int64`

| `uint8`

| `uint16`

| `uint32`

| `uint64`

`OutputWordLength`

— Fixed-point word length for filter output

`32`

(default) | scalar integer

Fixed-point word length to use for the filter output, specified as a scalar integer greater than or equal to 2.

#### Dependencies

This property applies when you set the `FixedPointDataType`

property to `'Minimum section word lengths'`

, ```
'Specify word
lengths'
```

, or ```
'Specify word and fraction
lengths'
```

.

**Data Types: **`single`

| `double`

| `int8`

| `int16`

| `int32`

| `int64`

| `uint8`

| `uint16`

| `uint32`

| `uint64`

`OutputFractionLength`

— Fixed-point fraction length for filter output

`0`

(default) | scalar integer

Fixed-point fraction length to use for the filter output, specified as a scalar integer.

#### Dependencies

This property applies when you set `FixedPointDataType`

property to `'Specify word and fraction lengths'`

.

**Data Types: **`single`

| `double`

| `int8`

| `int16`

| `int32`

| `int64`

| `uint8`

| `uint16`

| `uint32`

| `uint64`

## Usage

### Description

decimates the input using a CIC decimator.`cicDecimOut`

= cicDecim(`input`

)

### Input Arguments

`input`

— Data input

vector | matrix

Data input, specified as a vector or matrix. The number of rows in the input must
be a multiple of the DecimationFactor. If the input is of
`single`

or `double`

data type, property settings
related to the fixed-point data types are ignored.

**Data Types: **`single`

| `double`

| `int8`

| `int16`

| `int32`

| `int64`

| `uint8`

| `uint16`

| `uint32`

| `uint64`

| `fi`

**Complex Number Support: **Yes

### Output Arguments

`cicDecimOut`

— CIC decimator output

vector | matrix

Decimated output, returned as a vector or a matrix. The output frame size equals
(1 ∕ `DecimationFactor`

) × input frame size. The complexity of the
output data matches that of the input data. If the input is `single`

or `double`

, the output data type matches the input data type.

If the input is of built-in integer data type or of fixed-point data type, the output word length and fraction length depend on the fixed-point data type setting you choose through the FixedPointDataType property.

**Full precision**

When the `FixedPointDataType`

is set to ```
'Full
precision'
```

, the following relationship applies:

$$\begin{array}{l}W{L}_{\text{output}}=W{L}_{\text{input}}+NumSect\\ F{L}_{\text{output}}=F{L}_{\text{input}}\end{array}$$

where,

*WL*_{output}–– Word length of the output data.*FL*_{output}–– Fraction length of the output data.*WL*_{input}–– Word length of the input data.*FL*_{input}–– Fraction length of the input data.*NumSect*–– Number of sections in the CIC filter specified through the NumSections property.

The *WL*_{input} and
*FL*_{input} are inherited from the data input
you pass to the object algorithm. For built-in integer inputs, the fraction length is
0.

**Minimum section word lengths**

When the `FixedPointDataType`

property is set to
`'Minimum section word lengths'`

, the output word length is the
value you specify in the OutputWordLength property. The output fraction
length, *FL*_{output}, is given by:

$$F{L}_{\text{output}}=W{L}_{\text{output}}-(W{L}_{\text{input}}-F{L}_{\text{input}}+NumSect)$$

**Specify word and fraction lengths**

When the `FixedPointDataType`

property is set to
`'Specify word and fraction lengths'`

, the output word length and
fraction length are the values you specify in the OutputWordLength and OutputFractionLength properties.

**Specify word lengths**

When the `FixedPointDataType`

property is set to
`'Specify word lengths'`

, the output word length is the value you
specify in the `OutputWordLength`

property. The output fraction
length, *FL*_{output}, is given by:

$$F{L}_{\text{output}}=W{L}_{\text{output}}-(W{L}_{\text{input}}-F{L}_{\text{input}}+NumSect)$$

**Data Types: **`single`

| `double`

| `int8`

| `int16`

| `int32`

| `int64`

| `uint8`

| `uint16`

| `uint32`

| `uint64`

| `fi`

**Complex Number Support: **Yes

## Object Functions

To use an object function, specify the
System object as the first input argument. For
example, to release system resources of a System object named `obj`

, use
this syntax:

release(obj)

### Specific to dsp.CICDecimator

`generatehdl` | Generate HDL code for quantized DSP filter (requires Filter Design HDL Coder) |

`impz` | Impulse response of discrete-time filter System object |

`freqz` | Frequency response of discrete-time filter System object |

`phasez` | Phase response of discrete-time filter System object (unwrapped) |

`fvtool` | Visualize frequency response of DSP filters |

`gain` | Gain of CIC filter System object |

`getFixedPointInfo` | Get fixed-point word and fraction lengths |

`info` | Information about filter System object |

For a list of filter analysis methods this object supports, type
`dsp.CICDecimator.helpFilterAnalysis`

in the MATLAB^{®} command prompt. For the corresponding function reference pages, see Analysis Methods for Filter System Objects.

## Examples

### Decimate a Signal Using a CICDecimator Object

**Note**: If you are using R2016a or an earlier release, replace each call to the object with the equivalent step syntax. For example, `obj(x)`

becomes `step(obj,x)`

.

Create a `dsp.CICDecimator`

System object™ with `DecimationFactor`

set to 4. Decimate a signal from 44.1 kHz to 11.025 kHz.

```
cicdec = dsp.CICDecimator(4);
cicdec.FixedPointDataType = 'Minimum section word lengths';
cicdec.OutputWordLength = 16;
```

Create a fixed-point sinusoidal input signal of 1024 samples, with a sampling frequency of 44.1e3 Hz.

```
Fs = 44.1e3;
% 0.0232 sec signal
n = (0:1023)';
x = fi(sin(2*pi*1e3/Fs*n),true,16,15);
```

Create a `dsp.SignalSource`

object.

src = dsp.SignalSource(x,64);

Decimate the output with 16 samples per frame.

y = zeros(16,16); for ii = 1:16 y(ii,:) = cicdec(src()); end

Plot the first frame of the original and decimated signals. Output latency is 2 samples.

D = cicdec.DecimationFactor; diffDelay = cicdec.DifferentialDelay; NumSect = cicdec.NumSections; gainCIC = ... (D*diffDelay)^NumSect; stem(n(1:56)/Fs,double(x(4:59))) hold on; stem(n(1:14)/(Fs/D),double(y(1,3:end))/gainCIC,... 'r','filled') xlabel('Time (sec)') ylabel('Signal Amplitude') legend('Original signal',... 'Decimated signal',... 'Location','north') hold off;

Using the `info`

method in `'long'`

format, obtain the word lengths and fraction lengths of the fixed-point filter sections and the filter output.

`info(cicdec,'long')`

ans = 'Discrete-Time FIR Multirate Filter (real) ----------------------------------------- Filter Structure : Cascaded Integrator-Comb Decimator Decimation Factor : 4 Differential Delay : 1 Number of Sections : 2 Stable : Yes Linear Phase : Yes (Type 1) Implementation Cost Number of Multipliers : 0 Number of Adders : 4 Number of States : 4 Multiplications per Input Sample : 0 Additions per Input Sample : 2.5 Fixed-Point Info Section word lengths : 20 19 19 18 Section fraction lengths : 15 14 14 13 Output word length : 16 Output fraction length : 11 '

### Determine the Section and Output Word Lengths and Fraction Lengths

Using the `getFixedPointInfo`

function, you can determine the word lengths and fraction lengths of the fixed-point sections and the output of the `dsp.CICDecimator`

and `dsp.CICInterpolator`

System objects. The data types of the filter sections and the output depend on the `FixedPointDataType`

property of the filter System object™.

**Full precision**

Create a `dsp.CICDecimator`

object. The default value of the `NumSections`

property is 2. This value indicates that there are two integrator and comb sections. The WLs and FLs vectors returned by the `getFixedPointInfo`

function contain five elements each. The first two elements represent the two integrator sections. The third and fourth elements represent the two comb sections. The last element represents the filter output.

cicD = dsp.CICDecimator

cicD = dsp.CICDecimator with properties: DecimationFactor: 2 DifferentialDelay: 1 NumSections: 2 FixedPointDataType: 'Full precision'

By default, the `FixedPointDataType`

property of the object is set to `'Full precision'`

. Calling the `getFixedPointInfo`

function on this object with the input numeric type, `nt`

, yields the following word length and fraction length vectors.

nt = numerictype(1,16,15)

nt = DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 16 FractionLength: 15

`[WLs,FLs] = getFixedPointInfo(cicD,nt) %#ok`

`WLs = `*1×5*
18 18 18 18 18

`FLs = `*1×5*
15 15 15 15 15

For details on how the word lengths and fraction lengths are computed, see the description for *Output Arguments.*

If you lock the `cicD`

object by passing an input to its algorithm, you do not need to pass the `nt`

argument to the `getFixedPointInfo`

function.

input = int64(randn(8,1))

`input = `*8x1 int64 column vector*
1
2
-2
1
0
-1
0
0

output = cicD(input)

output = 0 1 3 0 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 66 FractionLength: 0

`[WLs,FLs] = getFixedPointInfo(cicD) %#ok`

`WLs = `*1×5*
66 66 66 66 66

`FLs = `*1×5*
0 0 0 0 0

The output and section word lengths are the sum of input word length, 64 in this case, and the number of sections, 2. The output and section fraction lengths are 0 since the input is a built-in integer.

**Minimum section word lengths**

Release the object and change the `FixedPointDataType`

property to `'Minimum section word lengths'`

. Determine the section and output fixed-point information when the input is fixed-point data, `fi(randn(8,2),1,24,15)`

.

```
release(cicD);
cicD.FixedPointDataType = 'Minimum section word lengths'
```

cicD = dsp.CICDecimator with properties: DecimationFactor: 2 DifferentialDelay: 1 NumSections: 2 FixedPointDataType: 'Minimum section word lengths' OutputWordLength: 32

inputF = fi(randn(8,2),1,24,15)

inputF = 3.5784 -0.1241 2.7694 1.4897 -1.3499 1.4090 3.0349 1.4172 0.7254 0.6715 -0.0630 -1.2075 0.7148 0.7172 -0.2050 1.6302 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 24 FractionLength: 15

`[WLs, FLs] = getFixedPointInfo(cicD,numerictype(inputF)) %#ok`

`WLs = `*1×5*
26 26 26 26 32

`FLs = `*1×5*
15 15 15 15 21

**Specify word and fraction lengths**

Change the `FixedPointDataType`

property to `'Specify word and fraction lengths'`

. Determine the fixed-point information using the `getFixedPointInfo`

function.

`cicD.FixedPointDataType = 'Specify word and fraction lengths'`

cicD = dsp.CICDecimator with properties: DecimationFactor: 2 DifferentialDelay: 1 NumSections: 2 FixedPointDataType: 'Specify word and fraction lengths' SectionWordLengths: [16 16 16 16] SectionFractionLengths: 0 OutputWordLength: 32 OutputFractionLength: 0

`[WLs, FLs] = getFixedPointInfo(cicD,numerictype(inputF)) %#ok`

`WLs = `*1×5*
16 16 16 16 32

`FLs = `*1×5*
0 0 0 0 0

The section and output word lengths and fraction lengths are assigned as per the respective fixed-point properties of the `cicD`

object. These values are not determined by the input numeric type. To confirm, call the `getFixedPointInfo`

function without passing the `numerictype`

input argument.

`[WLs, FLs] = getFixedPointInfo(cicD) %#ok`

`WLs = `*1×5*
16 16 16 16 32

`FLs = `*1×5*
0 0 0 0 0

**Specify word lengths**

To specify the word lengths of the filter section and output, set the `FixedPointDataType`

property to `'Specify word lengths'`

.

`cicD.FixedPointDataType = 'Specify word lengths'`

cicD = dsp.CICDecimator with properties: DecimationFactor: 2 DifferentialDelay: 1 NumSections: 2 FixedPointDataType: 'Specify word lengths' SectionWordLengths: [16 16 16 16] OutputWordLength: 32

The `getFixedPointInfo`

function requires the input numeric type because that information is used to compute the section and word fraction lengths.

[WLs, FLs] = getFixedPointInfo(cicD,numerictype(inputF))

`WLs = `*1×5*
16 16 16 16 32

`FLs = `*1×5*
5 5 5 5 21

For more details on how the function computes the word and fraction lengths, see the description for *Output Arguments*.

## More About

### CIC Filter

CIC filters are an optimized class of linear phase FIR filters composed of a comb part and an integrator part.

The CIC decimation filter is conceptually given by a single rate CIC filter,
*H(z)* which is a lowpass anti-imaging filter, followed by a
downsampler. The CIC decimation filter decreases the sample rate of an input signal by
an integer factor using a cascaded integrator-comb (CIC) filter.

In a more efficient implementation, the single rate CIC filter *H(z)* is
factorized this way:

$$H(z)={\left[{\displaystyle \sum _{k=0}^{RM-1}{z}^{-k}}\right]}^{N}=\frac{{\left(1-{z}^{-RM}\right)}^{N}}{{\left(1-{z}^{-1}\right)}^{N}}=\frac{1}{{\left(1-{z}^{-1}\right)}^{N}}\xb7\frac{{\left(1-{z}^{-RM}\right)}^{N}}{1}={H}_{\text{I}}{}^{N}(z)\xb7{H}_{\text{c}}{}^{N}(z)$$

where,

*H*_{I}is the transfer function of the integrator part of the filter containing*N*stages of integrators.*H*_{C}is the transfer function of the*N*sections of the cascaded comb filters, each with a width of*RM*.*N*is the number of sections. The number of sections in a CIC filter is defined as the number of sections in either the comb part*or*the integrator part of the filter. This value does not represent the total number of sections throughout the entire filter.*R*is the decimation factor.*M*is the differential delay.

In the overall multirate realization, the algorithm applies the noble identity for decimation
and moves the rate change factor, *R*, to follow after the
*N* sections of the cascaded integrators. The transfer function of
the resulting filter is given by the following equation:

$$H(z)=\frac{{\left(1-{z}^{-M}\right)}^{N}}{{\left(1-{z}^{-1}\right)}^{N}}.$$

For a block diagram that shows the multirate implementation, see Algorithms.

## Algorithms

### CIC Decimation Filter

The CIC decimation filter in More About is realized as a
cascade of *N* sections of the integrators followed by a rate change
factor of *R*, followed by *N* sections of comb
filters.

This diagram shows two sections of cascaded integrators and two sections of cascaded comb filters. The unit delay in the integrator portion of the CIC filter can be located in either the feedforward or the feedback path. These two configurations yield identical filter frequency response. However, the numerical outputs from these two configurations are different due to the latency. This block puts the unit delay in the feedforward path of the integrator because it is a preferred configuration for HDL implementation.

## References

[1] Hogenauer, E.B. "An Economical
Class of Digital Filters for Decimation and Interpolation." *IEEE Transactions on
Acoustics, Speech and Signal Processing*. Volume 29, Number 2, 1981,
155–162.

[2] Meyer-Baese, U. *Digital Signal Processing with Field Programmable Gate
Arrays*. New York: Springer, 2001.

[3] Harris, Fredric J.
*Multirate Signal Processing for Communication Systems*. Indianapolis,
IN: Prentice Hall PTR, 2004.

## Extended Capabilities

### C/C++ Code Generation

Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

See System Objects in MATLAB Code Generation (MATLAB Coder).

### HDL Code Generation

Generate Verilog and VHDL code for FPGA and ASIC designs using HDL Coder™.

This object supports HDL code generation with the Filter Design HDL Coder™ product. For workflows and limitations, see Generate HDL Code for Filter System Objects (Filter Design HDL Coder).

### Fixed-Point Conversion

Design and simulate fixed-point systems using Fixed-Point Designer™.

The fixed-point signal diagram shows the data types that the
`dsp.CICDecimator`

object uses for fixed-point signals.

where,

`secNT = numerictype(1,secWL,secFL)`

`outNT = numertictype(1,outWL,outFL)`

*secWL*is the section word length you specify through the SectionWordLengths property.*secFL*is the section fraction length you specify through the SectionFractionLengths property.*outWL*is the output word length you specify through the OutputWordLength property.*outFL*is the output fraction length you specify through the OutputFractionLength property.

The value of `NumSections`

in this diagram is 2.

## See Also

### Functions

`generatehdl`

|`impz`

|`freqz`

|`phasez`

|`fvtool`

|`gain`

|`getFixedPointInfo`

|`info`

### Objects

### Blocks

**Introduced in R2012a**

## Open Example

You have a modified version of this example. Do you want to open this example with your edits?

## MATLAB Command

You clicked a link that corresponds to this MATLAB command:

Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.

# Select a Web Site

Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .

You can also select a web site from the following list:

## How to Get Best Site Performance

Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.

### Americas

- América Latina (Español)
- Canada (English)
- United States (English)

### Europe

- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)

- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- United Kingdom (English)