# Documentation

### This is machine translation

Translated by
Mouseover text to see original. Click the button below to return to the English verison of the page.

# smoothdata

Smooth noisy data

## Syntax

``B = smoothdata(A)``
``B = smoothdata(A,dim)``
``B = smoothdata(___,method)``
``B = smoothdata(___,method,window)``
``B = smoothdata(___,nanflag)``
``B = smoothdata(___,Name,Value)``
``````[B,window] = smoothdata(___)``````

## Description

example

````B = smoothdata(A)` returns a moving average of the elements of a vector using a fixed window length that is determined heuristically. The window slides down the length of the vector, computing an average over the elements within each window. If `A` is a matrix, then `smoothdata` computes the moving average down each column.If `A` is a multidimensional array, then `smoothdata` operates along the first dimension whose size does not equal 1.If `A` is a table or timetable with numeric variables, then `smoothdata` operates on each variable separately. ```

example

````B = smoothdata(A,dim)` operates along the dimension `dim` of `A`. For example, if `A` is a matrix, then `smoothdata(A,2)` smooths the data in each row of `A`.```

example

````B = smoothdata(___,method)` specifies the smoothing method for either of the previous syntaxes. For example, ```B = smoothdata(A,'sgolay')``` uses a Savitzky-Golay filter to smooth the data in `A`.```

example

````B = smoothdata(___,method,window)` specifies the length of the window used by the smoothing method. For example, `smoothdata(A,'movmedian',5)` smooths the data in `A` by taking the median over a five-element sliding window.```

example

````B = smoothdata(___,nanflag)` specifies how `NaN` values are treated for any of the previous syntaxes. `'omitnan'` ignores `NaN` values and `'includenan'` includes them when computing within each window.```

example

````B = smoothdata(___,Name,Value)` specifies additional parameters for smoothing using one or more name-value pair arguments. For example, if `t` is a vector of time values, then `smoothdata(A,'SamplePoints',t)` smooths the data in `A` relative to the times in `t`.```

example

``````[B,window] = smoothdata(___)``` also returns the moving window length.```

## Examples

collapse all

Create a vector containing noisy data, and smooth the data with a moving average. Plot the original and smoothed data.

```x = 1:100; A = cos(2*pi*0.05*x+2*pi*rand) + 0.5*randn(1,100); B = smoothdata(A); plot(x,A,'-o',x,B,'-x') legend('Original Data','Smoothed Data')```

Create a matrix whose rows represent three noisy signals. Smooth the three signals using a moving average, and plot the smoothed data.

```x = 1:100; s1 = cos(2*pi*0.03*x+2*pi*rand) + 0.5*randn(1,100); s2 = cos(2*pi*0.04*x+2*pi*rand) + 0.4*randn(1,100) + 5; s3 = cos(2*pi*0.05*x+2*pi*rand) + 0.3*randn(1,100) - 5; A = [s1; s2; s3]; B = smoothdata(A,2); plot(x,B(1,:),x,B(2,:),x,B(3,:))```

Smooth a vector of noisy data with a Gaussian-weighted moving average filter. Display the window length used by the filter.

```x = 1:100; A = cos(2*pi*0.05*x+2*pi*rand) + 0.5*randn(1,100); [B, window] = smoothdata(A,'gaussian'); window```
```window = 4 ```

Smooth the original data with a larger window of length 20. Plot the smoothed data for both window lengths.

```C = smoothdata(A,'gaussian',20); plot(x,B,'-o',x,C,'-x') legend('Small Window','Large Window')```

Create a noisy vector containing `NaN` values, and smooth the data ignoring `NaN`, which is the default.

```A = [NaN randn(1,48) NaN randn(1,49) NaN]; B = smoothdata(A);```

Smooth the data including `NaN` values. The average in a window containing `NaN` is `NaN`.

`C = smoothdata(A,'includenan');`

Plot the smoothed data in `B` and `C`.

```plot(1:100,B,'-o',1:100,C,'-x') legend('Ignore NaN','Include NaN')```

Create a vector of noisy data that corresponds to a time vector `t`. Smooth the data relative to the times in `t`, and plot the original data and the smoothed data.

```x = 1:100; A = cos(2*pi*0.05*x+2*pi*rand) + 0.5*randn(1,100); t = datetime(2017,1,1,0,0,0) + hours(0:99); B = smoothdata(A,'SamplePoints',t); plot(t,A,'-o',t,B,'-x') legend('Original Data','Smoothed Data')```

## Input Arguments

collapse all

Input array, specified as a vector, matrix, multidimensional array, table, or timetable. If `A` is a table or timetable, then either the variables must be numeric, or you must use the `'DataVariables'` name-value pair to list numeric variables explicitly. Specifying variables is useful when you are working with a table that also contains non-numeric variables.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64` | `logical` | `table` | `timetable`

Complex Number Support: Yes

Dimension to operate along, specified as a positive integer scalar. If no value is specified, then the default is the first array dimension whose size does not equal 1.

Consider a matrix `A`.

`B = smoothdata(A,1)` smooths the data in each column of `A`.

`B = smoothdata(A,2)` smooths the data in each row of `A`.

When `A` is a table or timetable, `dim` is not supported. `smoothdata` operates along each table or timetable variable separately.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

Smoothing method, specified as one of the following:

• `'movmean'` — Moving average over each window of `A`. This method is useful for reducing periodic trends in data.

• `'movmedian'` — Moving median over each window of `A`. This method is useful for reducing periodic trends in data when outliers are present.

• `'gaussian'` — Gaussian-weighted moving average over each window of `A`.

• `'lowess'` — Linear regression over each window of `A`. This method can be computationally expensive, but results in fewer discontinuities.

• `'loess'` — Quadratic regression over each window of `A`. This method is slightly more computationally expensive than `'lowess'`.

• `'rlowess'` — Robust linear regression over each window of `A`. This method is a more computationally expensive version of the method `'lowess'`, but it is more robust to outliers.

• `'rloess'` — Robust quadratic regression over each window of `A`. This method is a more computationally expensive version of the method `'loess'`, but it is more robust to outliers.

• `'sgolay'` — Savitzky-Golay filter, which smooths according to a quadratic polynomial that is fitted over each window of `A`. This method can be more effective than other methods when the data varies rapidly.

Window length, specified as a positive integer scalar, a two-element vector of positive integers, a positive duration scalar, or a two-element vector of positive durations.

When `window` is a positive integer scalar, then the window is centered about the current element and contains `window-1` neighboring elements. If `window` is even, then the window is centered about the current and previous elements. If `window` is a two-element vector of positive integers `[b f]`, then the window contains the current element, `b` elements backward, and `f` elements forward.

When `A` is a timetable or when `'SamplePoints'` is specified as a `datetime` or `duration` vector, `window` must be of type `duration`, and the window is computed relative to the sample points.

When the window length is also specified as an output argument, the output value matches the input value.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64` | `duration`

`NaN` condition, specified as one of the following values:

• `'omitnan'` — Ignore `NaN` values in the input. If a window contains all `NaN` values, then `smoothdata` returns `NaN`.

• `'includenan'` — Include `NaN` values when computing within each window, resulting in `NaN`.

### Name-Value Pair Arguments

Specify optional comma-separated pairs of `Name,Value` arguments. `Name` is the argument name and `Value` is the corresponding value. `Name` must appear inside single quotes (`' '`). You can specify several name and value pair arguments in any order as `Name1,Value1,...,NameN,ValueN`.

Example: `smoothdata(A,'SmoothingFactor',0.5)`

collapse all

Window size factor, specified as the comma-separated pair consisting of `'SmoothingFactor'` and a scalar ranging from 0 to 1. The value of `'SmoothingFactor'` adjusts the level of smoothing by scaling the heuristic window size. Values near 0 produce smaller moving window lengths, resulting in less smoothing. Values near 1 produce larger moving window lengths, resulting in more smoothing.

`'SmoothingFactor'` is 0.25 by default and can only be specified when `window` is not specified.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

Sample points, specified as the comma-separated pair consisting of `'SamplePoints'` and a vector. The sample points represent the location of the data in `A`. Sample points do not need to be uniformly sampled. By default, the sample points vector is `[1 2 3 ...]`.

Moving windows are defined relative to the sample points, which must be sorted and contain unique elements. For example, if `t` is a vector of times corresponding to the input data, then `smoothdata(rand(1,10),3,'SamplePoints',t)` has a window that represents the time interval between `t(i)-1.5` and `t(i)+1.5`.

When the sample points vector has data type `datetime` or `duration`, then the moving window length must have type `duration`.

If the sample points are nonuniformly spaced and the `'Endpoints'` name-value pair is specified, then its value must be `'shrink'`.

This name-value pair is not supported when the input data is a timetable.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64` | `datetime` | `duration`

Table variables, specified as the comma-separated pair consisting of `'DataVariables'` and a variable name, a cell array of variable names, a numeric vector, a logical vector, or a function handle. The `'DataVariables'` value indicates which columns of the input table to smooth, and can be one of the following:

• A character vector specifying a single table variable name

• A cell array of character vectors where each element is a table variable name

• A vector of table variable indices

• A logical vector whose elements each correspond to a table variable, where `true` includes the corresponding variable and `false` excludes it

• A function handle that takes the table as input and returns a logical scalar

Example: `'Age'`

Example: `{'Height','Weight'}`

Example: `@isnumeric`

Data Types: `char` | `cell` | `double` | `single` | `logical` | `function_handle`

Savitzky-Golay degree, specified as the comma-separated pair consisting of `'Degree'` and a nonnegative integer. This name-value pair can only be specified when `'sgolay'` is the specified smoothing method. The value of `'Degree'` corresponds to the degree of the polynomial in the Savitzky-Golay filter that fits the data within each window, which is 2 by default.

The value of `'Degree'` must be less than the window length for uniform sample points. For nonuniform sample points, the value must be less than the maximum number of points in any window.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

## Output Arguments

collapse all

Output array, returned as a vector, matrix, or multidimensional array. `B` is the same size and type as `A`.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64` | `logical` | `table` | `timetable`

Window length, returned as a positive integer scalar, a two-element vector of positive integers, a positive duration scalar, or a two-element vector of positive durations.

When `window` is specified as an input argument, the output value matches the input value. When `window` is not specified as an input argument, then its value is the scalar heuristically determined by `smoothdata` based on the input data.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64` | `duration`

## Algorithms

When the window size for the smoothing method is not specified, `smoothdata` computes a default window size based on a heuristic. For a smoothing factor τ, the heuristic estimates a moving average window size that attenuates approximately 100*τ percent of the energy of the input data.