scipy.signal.

# resample#

scipy.signal.resample(x, num, t=None, axis=0, window=None, domain='time')[source]#

Resample x to num samples using Fourier method along the given axis.

The resampled signal starts at the same value as x but is sampled with a spacing of `len(x) / num * (spacing of x)`. Because a Fourier method is used, the signal is assumed to be periodic.

Parameters:
xarray_like

The data to be resampled.

numint

The number of samples in the resampled signal.

tarray_like, optional

If t is given, it is assumed to be the equally spaced sample positions associated with the signal data in x.

axisint, optional

The axis of x that is resampled. Default is 0.

windowarray_like, callable, string, float, or tuple, optional

Specifies the window applied to the signal in the Fourier domain. See below for details.

domainstring, optional

A string indicating the domain of the input x: `time` Consider the input x as time-domain (Default), `freq` Consider the input x as frequency-domain.

Returns:
resampled_x or (resampled_x, resampled_t)

Either the resampled array, or, if t was given, a tuple containing the resampled array and the corresponding resampled positions.

`decimate`

Downsample the signal after applying an FIR or IIR filter.

`resample_poly`

Resample using polyphase filtering and an FIR filter.

Notes

The argument window controls a Fourier-domain window that tapers the Fourier spectrum before zero-padding to alleviate ringing in the resampled values for sampled signals you didn’t intend to be interpreted as band-limited.

If window is a function, then it is called with a vector of inputs indicating the frequency bins (i.e. fftfreq(x.shape[axis]) ).

If window is an array of the same length as x.shape[axis] it is assumed to be the window to be applied directly in the Fourier domain (with dc and low-frequency first).

For any other type of window, the function `scipy.signal.get_window` is called to generate the window.

The first sample of the returned vector is the same as the first sample of the input vector. The spacing between samples is changed from `dx` to `dx * len(x) / num`.

If t is not None, then it is used solely to calculate the resampled positions resampled_t

As noted, `resample` uses FFT transformations, which can be very slow if the number of input or output samples is large and prime; see `fft`. In such cases, it can be faster to first downsample a signal of length `n` with `resample_poly` by a factor of `n//num` before using `resample`. Note that this approach changes the characteristics of the antialiasing filter.

Examples

Note that the end of the resampled data rises to meet the first sample of the next cycle:

```>>> import numpy as np
>>> from scipy import signal
```
```>>> x = np.linspace(0, 10, 20, endpoint=False)
>>> y = np.cos(-x**2/6.0)
>>> f = signal.resample(y, 100)
>>> xnew = np.linspace(0, 10, 100, endpoint=False)
```
```>>> import matplotlib.pyplot as plt
>>> plt.plot(x, y, 'go-', xnew, f, '.-', 10, y[0], 'ro')
>>> plt.legend(['data', 'resampled'], loc='best')
>>> plt.show()
```

Consider the following signal `y` where `len(y)` is a large prime number:

```>>> N = 55949
>>> freq = 100
>>> x = np.linspace(0, 1, N)
>>> y = np.cos(2 * np.pi * freq * x)
```

Due to `N` being prime,

```>>> num = 5000
>>> f = signal.resample(signal.resample_poly(y, 1, N // num), num)
```

runs significantly faster than

```>>> f = signal.resample(y, num)
```