'''

'''

'''

x = np.asarray(x)

if x.ndim < 1 or x.ndim > 2:

raise ValueError('only 1D or 2D arrays can be used')

if axis+1 > x.ndim:

raise ValueError('axis(=%s) out of bounds' % axis)

xshape = list(x.shape)

xshapetarg = xshape.pop(axis)

if np.iterable(window):

if len(window) != xshapetarg:

raise ValueError('The len(window) must be the same as the shape '

'of x for the chosen axis')

windowVals = window

else:

windowVals = window(np.ones(xshapetarg, dtype=x.dtype))

if x.ndim == 1:

if return_window:

return windowVals * x, windowVals

else:

return windowVals * x

xshapeother = xshape.pop()

otheraxis = (axis+1) % 2

windowValsRep = stride_repeat(windowVals, xshapeother, axis=otheraxis)

if return_window:

return windowValsRep * x, windowVals

else:

'''

if key is None or key in ['constant', 'mean', 'default']:

return detrend(x, key=detrend_mean, axis=axis)

elif key == 'linear':

return detrend(x, key=detrend_linear, axis=axis)

elif key == 'none':

return detrend(x, key=detrend_none, axis=axis)

elif isinstance(key, str):

raise ValueError("Unknown value for key %s, must be one of: "

"'default', 'constant', 'mean', "

"'linear', or a function" % key)

if not callable(key):

raise ValueError("Unknown value for key %s, must be one of: "

"'default', 'constant', 'mean', "

"'linear', or a function" % key)

x = np.asarray(x)

if axis is not None and axis+1 > x.ndim:

raise ValueError('axis(=%s) out of bounds' % axis)

if (axis is None and x.ndim == 0) or (not axis and x.ndim == 1):

return key(x)

# try to use the 'axis' argument if the function supports it,

# otherwise use apply_along_axis to do it

try:

return key(x, axis=axis)

except TypeError:

'''

'''

x = np.asarray(x)

if axis is not None and axis+1 > x.ndim:

raise ValueError('axis(=%s) out of bounds' % axis)

'''

'''

# This is faster than an algorithm based on linalg.lstsq.

y = np.asarray(y)

if y.ndim > 1:

raise ValueError('y cannot have ndim > 1')

# short-circuit 0-D array.

if not y.ndim:

return np.array(0., dtype=y.dtype)

x = np.arange(y.size, dtype=float)

C = np.cov(x, y, bias=1)

b = C[0, 1]/C[0, 0]

a = y.mean() - b*x.mean()

'''

if noverlap is None:

noverlap = 0

if noverlap >= n:

raise ValueError('noverlap must be less than n')

if n < 1:

raise ValueError('n cannot be less than 1')

x = np.asarray(x)

if x.ndim != 1:

raise ValueError('only 1-dimensional arrays can be used')

if n == 1 and noverlap == 0:

if axis == 0:

return x[np.newaxis]

else:

return x[np.newaxis].transpose()

if n > x.size:

raise ValueError('n cannot be greater than the length of x')

# np.lib.stride_tricks.as_strided easily leads to memory corruption for

# non integer shape and strides, i.e. noverlap or n. See #3845.

noverlap = int(noverlap)

n = int(n)

step = n - noverlap

if axis == 0:

shape = (n, (x.shape[-1]-noverlap)//step)

strides = (x.strides[0], step*x.strides[0])

else:

shape = ((x.shape[-1]-noverlap)//step, n)

strides = (step*x.strides[0], x.strides[0])

'''

if axis not in [0, 1]:

raise ValueError('axis must be 0 or 1')

x = np.asarray(x)

if x.ndim != 1:

raise ValueError('only 1-dimensional arrays can be used')

if n == 1:

if axis == 0:

return np.atleast_2d(x)

else:

return np.atleast_2d(x).T

if n < 1:

raise ValueError('n cannot be less than 1')

# np.lib.stride_tricks.as_strided easily leads to memory corruption for

# non integer shape and strides, i.e. n. See #3845.

n = int(n)

if axis == 0:

shape = (n, x.size)

strides = (0, x.strides[0])

else:

shape = (x.size, n)

strides = (x.strides[0], 0)

window=None, noverlap=None, pad_to=None,

sides=None, scale_by_freq=None, mode=None):

'''

if y is None:

# if y is None use x for y

same_data = True

else:

# The checks for if y is x are so that we can use the same function to

# implement the core of psd(), csd(), and spectrogram() without doing

# extra calculations. We return the unaveraged Pxy, freqs, and t.

same_data = y is x

if Fs is None:

Fs = 2

if noverlap is None:

noverlap = 0

if detrend_func is None:

detrend_func = detrend_none

if window is None:

window = window_hanning

# if NFFT is set to None use the whole signal

if NFFT is None:

NFFT = 256

if mode is None or mode == 'default':

mode = 'psd'

elif mode not in ['psd', 'complex', 'magnitude', 'angle', 'phase']:

raise ValueError("Unknown value for mode %s, must be one of: "

"'default', 'psd', 'complex', "

"'magnitude', 'angle', 'phase'" % mode)

if not same_data and mode != 'psd':

raise ValueError("x and y must be equal if mode is not 'psd'")

# Make sure we're dealing with a numpy array. If y and x were the same

# object to start with, keep them that way

x = np.asarray(x)

if not same_data:

y = np.asarray(y)

if sides is None or sides == 'default':

if np.iscomplexobj(x):

sides = 'twosided'

else:

sides = 'onesided'

elif sides not in ['onesided', 'twosided']:

raise ValueError("Unknown value for sides %s, must be one of: "

"'default', 'onesided', or 'twosided'" % sides)

# zero pad x and y up to NFFT if they are shorter than NFFT

if len(x) < NFFT:

n = len(x)

x = np.resize(x, NFFT)

x[n:] = 0

if not same_data and len(y) < NFFT:

n = len(y)

y = np.resize(y, NFFT)

y[n:] = 0

if pad_to is None:

pad_to = NFFT

if mode != 'psd':

scale_by_freq = False

elif scale_by_freq is None:

scale_by_freq = True

# For real x, ignore the negative frequencies unless told otherwise

if sides == 'twosided':

numFreqs = pad_to

if pad_to % 2:

freqcenter = (pad_to - 1)//2 + 1

else:

freqcenter = pad_to//2

scaling_factor = 1.

elif sides == 'onesided':

if pad_to % 2:

numFreqs = (pad_to + 1)//2

else:

numFreqs = pad_to//2 + 1

scaling_factor = 2.

if not np.iterable(window):

window = window(np.ones(NFFT, x.dtype))

if len(window) != NFFT:

raise ValueError(

"The window length must match the data's first dimension")

result = stride_windows(x, NFFT, noverlap, axis=0)

result = detrend(result, detrend_func, axis=0)

result = result * window.reshape((-1, 1))

result = np.fft.fft(result, n=pad_to, axis=0)[:numFreqs, :]

freqs = np.fft.fftfreq(pad_to, 1/Fs)[:numFreqs]

if not same_data:

# if same_data is False, mode must be 'psd'

resultY = stride_windows(y, NFFT, noverlap)

resultY = detrend(resultY, detrend_func, axis=0)

resultY = resultY * window.reshape((-1, 1))

resultY = np.fft.fft(resultY, n=pad_to, axis=0)[:numFreqs, :]

result = np.conj(result) * resultY

elif mode == 'psd':

result = np.conj(result) * result

elif mode == 'magnitude':

result = np.abs(result) / np.abs(window).sum()

elif mode == 'angle' or mode == 'phase':

# we unwrap the phase later to handle the onesided vs. twosided case

result = np.angle(result)

elif mode == 'complex':

result /= np.abs(window).sum()

if mode == 'psd':

# Also include scaling factors for one-sided densities and dividing by

# the sampling frequency, if desired. Scale everything, except the DC

# component and the NFFT/2 component:

# if we have a even number of frequencies, don't scale NFFT/2

if not NFFT % 2:

slc = slice(1, -1, None)

# if we have an odd number, just don't scale DC

else:

slc = slice(1, None, None)

result[slc] *= scaling_factor

# MATLAB divides by the sampling frequency so that density function

# has units of dB/Hz and can be integrated by the plotted frequency

# values. Perform the same scaling here.

if scale_by_freq:

result /= Fs

# Scale the spectrum by the norm of the window to compensate for

# windowing loss; see Bendat & Piersol Sec 11.5.2.

result /= (np.abs(window)**2).sum()

else:

# In this case, preserve power in the segment, not amplitude

result /= np.abs(window).sum()**2

t = np.arange(NFFT/2, len(x) - NFFT/2 + 1, NFFT - noverlap)/Fs

if sides == 'twosided':

# center the frequency range at zero

freqs = np.concatenate((freqs[freqcenter:], freqs[:freqcenter]))

result = np.concatenate((result[freqcenter:, :],

result[:freqcenter, :]), 0)

elif not pad_to % 2:

# get the last value correctly, it is negative otherwise

freqs[-1] *= -1

# we unwrap the phase here to handle the onesided vs. twosided case

if mode == 'phase':

result = np.unwrap(result, axis=0)

sides=None):

'''

if mode is None or mode == 'psd' or mode == 'default':

raise ValueError('_single_spectrum_helper does not work with %s mode'

% mode)

if pad_to is None:

pad_to = len(x)

spec, freqs, _ = _spectral_helper(x=x, y=None, NFFT=len(x), Fs=Fs,

detrend_func=detrend_none, window=window,

noverlap=0, pad_to=pad_to,

sides=sides,

scale_by_freq=False,

mode=mode)

if mode != 'complex':

spec = spec.real

if spec.ndim == 2 and spec.shape[1] == 1:

spec = spec[:, 0]

noverlap=None, pad_to=None, sides=None, scale_by_freq=None):

r"""

Pxx, freqs = csd(x=x, y=None, NFFT=NFFT, Fs=Fs, detrend=detrend,

window=window, noverlap=noverlap, pad_to=pad_to,

sides=sides, scale_by_freq=scale_by_freq)

noverlap=None, pad_to=None, sides=None, scale_by_freq=None):

"""

if NFFT is None:

NFFT = 256

Pxy, freqs, _ = _spectral_helper(x=x, y=y, NFFT=NFFT, Fs=Fs,

detrend_func=detrend, window=window,

noverlap=noverlap, pad_to=pad_to,

sides=sides, scale_by_freq=scale_by_freq,

mode='psd')

if Pxy.ndim == 2:

if Pxy.shape[1] > 1:

Pxy = Pxy.mean(axis=1)

else:

Pxy = Pxy[:, 0]

sides=None):

"""

return _single_spectrum_helper(x=x, Fs=Fs, window=window, pad_to=pad_to,

sides=None):

"""

return _single_spectrum_helper(x=x, Fs=Fs, window=window, pad_to=pad_to,

sides=None):

"""

return _single_spectrum_helper(x=x, Fs=Fs, window=window, pad_to=pad_to,

sides=None):

"""

return _single_spectrum_helper(x=x, Fs=Fs, window=window, pad_to=pad_to,

noverlap=None, pad_to=None, sides=None, scale_by_freq=None,

mode=None):

"""