INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
r AIC order - selection using eigen values | def aic_eigen(s, N):
r"""AIC order-selection using eigen values
:param s: a list of `p` sorted eigen values
:param N: the size of the input data. To be defined precisely.
:return:
* an array containing the AIC values
Given :math:`n` sorted eigen values :math:`\lambda_i` with
:math:`0 ... |
r MDL order - selection using eigen values | def mdl_eigen(s, N):
r"""MDL order-selection using eigen values
:param s: a list of `p` sorted eigen values
:param N: the size of the input data. To be defined precisely.
:return:
* an array containing the AIC values
.. math:: MDL(k) = (n-k)N \ln \frac{g(k)}{a(k)} + 0.5k(2n-k) log(N)
... |
Generate the Main examples gallery reStructuredText | def generate_gallery_rst(app):
"""Generate the Main examples gallery reStructuredText
Start the sphinx-gallery configuration and recursively scan the examples
directories in order to populate the examples gallery
"""
try:
plot_gallery = eval(app.builder.config.plot_gallery)
except TypeE... |
Setup sphinx - gallery sphinx extension | def setup(app):
"""Setup sphinx-gallery sphinx extension"""
app.add_config_value('plot_gallery', True, 'html')
app.add_config_value('abort_on_example_error', False, 'html')
app.add_config_value('sphinx_gallery_conf', gallery_conf, 'html')
app.add_stylesheet('gallery.css')
app.connect('builder-i... |
r Correlation function | def CORRELATION(x, y=None, maxlags=None, norm='unbiased'):
r"""Correlation function
This function should give the same results as :func:`xcorr` but it
returns the positive lags only. Moreover the algorithm does not use
FFT as compared to other algorithms.
:param array x: first data array of length... |
Cross - correlation using numpy. correlate | def xcorr(x, y=None, maxlags=None, norm='biased'):
"""Cross-correlation using numpy.correlate
Estimates the cross-correlation (and autocorrelation) sequence of a random
process of length N. By default, there is no normalisation and the output
sequence of the cross-correlation has a length 2*N+1.
:... |
Finds the minimum eigenvalue of a Hermitian Toeplitz matrix | def MINEIGVAL(T0, T, TOL):
"""Finds the minimum eigenvalue of a Hermitian Toeplitz matrix
The classical power method is used together with a fast Toeplitz
equation solution routine. The eigenvector is normalized to unit length.
:param T0: Scalar corresponding to real matrix element t(0)
:param ... |
r Generate the Morlet waveform | def morlet(lb, ub, n):
r"""Generate the Morlet waveform
The Morlet waveform is defined as follows:
.. math:: w[x] = \cos{5x} \exp^{-x^2/2}
:param lb: lower bound
:param ub: upper bound
:param int n: waveform data samples
.. plot::
:include-source:
:width: 80%
... |
r Evaluate a chirp signal at time t. | def chirp(t, f0=0., t1=1., f1=100., form='linear', phase=0):
r"""Evaluate a chirp signal at time t.
A chirp signal is a frequency swept cosine wave.
.. math:: a = \pi (f_1 - f_0) / t_1
.. math:: b = 2 \pi f_0
.. math:: y = \cos\left( \pi\frac{f_1-f_0}{t_1} t^2 + 2\pi f_0 t + \rm{phase} \right)... |
r Generate the mexican hat wavelet | def mexican(lb, ub, n):
r"""Generate the mexican hat wavelet
The Mexican wavelet is:
.. math:: w[x] = \cos{5x} \exp^{-x^2/2}
:param lb: lower bound
:param ub: upper bound
:param int n: waveform data samples
:return: the waveform
.. plot::
:include-source:
:width: 80%... |
Convert autocorrelation sequence to prediction polynomial | def ac2poly(data):
"""Convert autocorrelation sequence to prediction polynomial
:param array data: input data (list or numpy.array)
:return:
* AR parameters
* noise variance
This is an alias to::
a, e, c = LEVINSON(data)
:Example:
.. doctest::
>>> from sp... |
convert reflection coefficients to prediction filter polynomial | def rc2poly(kr, r0=None):
"""convert reflection coefficients to prediction filter polynomial
:param k: reflection coefficients
"""
# Initialize the recursion
from .levinson import levup
p = len(kr) #% p is the order of the prediction polynomial.
a = numpy.array([1, kr[0]]) ... |
Convert reflection coefficients to autocorrelation sequence. | def rc2ac(k, R0):
"""Convert reflection coefficients to autocorrelation sequence.
:param k: reflection coefficients
:param R0: zero-lag autocorrelation
:returns: the autocorrelation sequence
.. seealso:: :func:`ac2rc`, :func:`poly2rc`, :func:`ac2poly`, :func:`poly2rc`, :func:`rc2poly`.
"""
... |
Convert reflection coefficients to inverse sine parameters. | def rc2is(k):
"""Convert reflection coefficients to inverse sine parameters.
:param k: reflection coefficients
:return: inverse sine parameters
.. seealso:: :func:`is2rc`, :func:`rc2poly`, :func:`rc2acC`, :func:`rc2lar`.
Reference: J.R. Deller, J.G. Proakis, J.H.L. Hansen, "Discrete-Time
P... |
Convert reflection coefficients to log area ratios. | def rc2lar(k):
"""Convert reflection coefficients to log area ratios.
:param k: reflection coefficients
:return: inverse sine parameters
The log area ratio is defined by G = log((1+k)/(1-k)) , where the K
parameter is the reflection coefficient.
.. seealso:: :func:`lar2rc`, :func:`rc2poly`, :... |
Convert log area ratios to reflection coefficients. | def lar2rc(g):
"""Convert log area ratios to reflection coefficients.
:param g: log area ratios
:returns: the reflection coefficients
.. seealso: :func:`rc2lar`, :func:`poly2rc`, :func:`ac2rc`, :func:`is2rc`.
:References:
[1] J. Makhoul, "Linear Prediction: A Tutorial Review," Proc. IEEE,... |
Convert line spectral frequencies to prediction filter coefficients | def lsf2poly(lsf):
"""Convert line spectral frequencies to prediction filter coefficients
returns a vector a containing the prediction filter coefficients from a vector lsf of line spectral frequencies.
.. doctest::
>>> from spectrum import lsf2poly
>>> lsf = [0.7842 , 1.5605 , 1.8776... |
Prediction polynomial to line spectral frequencies. | def poly2lsf(a):
"""Prediction polynomial to line spectral frequencies.
converts the prediction polynomial specified by A,
into the corresponding line spectral frequencies, LSF.
normalizes the prediction polynomial by A(1).
.. doctest::
>>> from spectrum import poly2lsf
>>> a = [1... |
todo is it really useful ? | def _swapsides(data):
"""todo is it really useful ?
Swap sides
.. doctest::
>>> from spectrum import swapsides
>>> x = [-2, -1, 1, 2]
>>> swapsides(x)
array([ 2, -2, -1])
"""
N = len(data)
return np.concatenate((data[N//2+1:], data[0:N//2])) |
Convert a one - sided PSD to a twosided PSD | def twosided_2_onesided(data):
"""Convert a one-sided PSD to a twosided PSD
In order to keep the power in the onesided PSD the same
as in the twosided version, the onesided values are twice
as much as in the input data (except for the zero-lag value).
::
>>> twosided_2_onesided([10, 2,3,3... |
Convert a two - sided PSD to a one - sided PSD | def onesided_2_twosided(data):
"""Convert a two-sided PSD to a one-sided PSD
In order to keep the power in the twosided PSD the same
as in the onesided version, the twosided values are 2 times
lower than the input data (except for the zero-lag and N-lag
values).
::
>>> twosided_2_ones... |
Convert a two - sided PSD to a center - dc PSD | def twosided_2_centerdc(data):
"""Convert a two-sided PSD to a center-dc PSD"""
N = len(data)
# could us int() or // in python 3
newpsd = np.concatenate((cshift(data[N//2:], 1), data[0:N//2]))
newpsd[0] = data[-1]
return newpsd |
Convert a center - dc PSD to a twosided PSD | def centerdc_2_twosided(data):
"""Convert a center-dc PSD to a twosided PSD"""
N = len(data)
newpsd = np.concatenate((data[N//2:], (cshift(data[0:N//2], -1))))
return newpsd |
Build a symmetric vector out of stricly positive lag vector and zero - lag | def _twosided_zerolag(data, zerolag):
"""Build a symmetric vector out of stricly positive lag vector and zero-lag
.. doctest::
>>> data = [3,2,1]
>>> zerolag = 4
>>> twosided_zerolag(data, zerolag)
array([1, 2, 3, 4, 3, 2, 1])
.. seealso:: Same behaviour as :func:`twosided... |
Circular shift to the right ( within an array ) by a given offset | def cshift(data, offset):
"""Circular shift to the right (within an array) by a given offset
:param array data: input data (list or numpy.array)
:param int offset: shift the array with the offset
.. doctest::
>>> from spectrum import cshift
>>> cshift([0, 1, 2, 3, -2, -1], 2)
... |
r Return a noisy cosine at a given frequency. | def data_cosine(N=1024, A=0.1, sampling=1024., freq=200):
r"""Return a noisy cosine at a given frequency.
:param N: the final data size
:param A: the strength of the noise
:param float sampling: sampling frequency of the input :attr:`data`.
:param float freq: the frequency :mat... |
A simple test example with two close frequencies | def data_two_freqs(N=200):
"""A simple test example with two close frequencies
"""
nn = arange(N)
xx = cos(0.257*pi*nn) + sin(0.2*pi*nn) + 0.01*randn(nn.size)
return xx |
Simple utilities to retrieve data sets from | def spectrum_data(filename):
"""Simple utilities to retrieve data sets from """
import os
import pkg_resources
info = pkg_resources.get_distribution('spectrum')
location = info.location
# first try develop mode
share = os.sep.join([location, "spectrum", 'data'])
filename2 = os.sep.join(... |
Plot the data set using the sampling information to set the x - axis correctly. | def plot(self, **kargs):
"""Plot the data set, using the sampling information to set the x-axis
correctly."""
from pylab import plot, linspace, xlabel, ylabel, grid
time = linspace(1*self.dt, self.N*self.dt, self.N)
plot(time, self.data, **kargs)
xlabel('Time')
yl... |
Read a WAV file and returns the data and sample rate | def readwav(filename):
"""Read a WAV file and returns the data and sample rate
::
from spectrum.io import readwav
readwav()
"""
from scipy.io.wavfile import read as readwav
samplerate, signal = readwav(filename)
return signal, samplerate |
Multitapering spectral estimation | def pmtm(x, NW=None, k=None, NFFT=None, e=None, v=None, method='adapt', show=False):
"""Multitapering spectral estimation
:param array x: the data
:param float NW: The time half bandwidth parameter (typical values are
2.5,3,3.5,4). Must be provided otherwise the tapering windows and
eigen v... |
r Discrete prolate spheroidal ( Slepian ) sequences | def dpss(N, NW=None, k=None):
r"""Discrete prolate spheroidal (Slepian) sequences
Calculation of the Discrete Prolate Spheroidal Sequences also known as the
slepian sequences, and the corresponding eigenvalues.
:param int N: desired window length
:param float NW: The time half bandwidth parameter ... |
Returns the Discrete Prolate Spheroidal Sequences of orders [ 0 Kmax - 1 ] for a given frequency - spacing multiple NW and sequence length N. | def _other_dpss_method(N, NW, Kmax):
"""Returns the Discrete Prolate Spheroidal Sequences of orders [0,Kmax-1]
for a given frequency-spacing multiple NW and sequence length N.
See dpss function that is the official version. This version is indepedant
of the C code and relies on Scipy function. However,... |
Returns the autocovariance of signal s at all lags. | def _autocov(s, **kwargs):
"""Returns the autocovariance of signal s at all lags.
Adheres to the definition
sxx[k] = E{S[n]S[n+k]} = cov{S[n],S[n+k]}
where E{} is the expectation operator, and S is a zero mean process
"""
# only remove the mean once, if needed
debias = kwargs.pop('debias', ... |
Returns the crosscovariance sequence between two ndarrays. This is performed by calling fftconvolve on x y [:: - 1 ] | def _crosscov(x, y, axis=-1, all_lags=False, debias=True):
"""Returns the crosscovariance sequence between two ndarrays.
This is performed by calling fftconvolve on x, y[::-1]
Parameters
x: ndarray
y: ndarray
axis: time axis
all_lags: {True/False}
whether to return all nonzero lags, ... |
Returns the crosscorrelation sequence between two ndarrays. This is performed by calling fftconvolve on x y [:: - 1 ] | def _crosscorr(x, y, **kwargs):
"""
Returns the crosscorrelation sequence between two ndarrays.
This is performed by calling fftconvolve on x, y[::-1]
Parameters
x: ndarray
y: ndarray
axis: time axis
all_lags: {True/False}
whether to return all nonzero lags, or to clip the length ... |
Subtracts an estimate of the mean from signal x at axis | def _remove_bias(x, axis):
"Subtracts an estimate of the mean from signal x at axis"
padded_slice = [slice(d) for d in x.shape]
padded_slice[axis] = np.newaxis
mn = np.mean(x, axis=axis)
return x - mn[tuple(padded_slice)] |
Separate filename content between docstring and the rest | def get_docstring_and_rest(filename):
"""Separate `filename` content between docstring and the rest
Strongly inspired from ast.get_docstring.
Returns
-------
docstring: str
docstring of `filename`
rest: str
`filename` content without the docstring
"""
with open(filename... |
Return list with source file separated into code and text blocks. | def split_code_and_text_blocks(source_file):
"""Return list with source file separated into code and text blocks.
Returns
-------
blocks : list of (label, content)
List where each element is a tuple with the label ('text' or 'code'),
and content string of block.
"""
docstring, r... |
Return reStructuredText code block from code string | def codestr2rst(codestr, lang='python'):
"""Return reStructuredText code block from code string"""
code_directive = "\n.. code-block:: {0}\n\n".format(lang)
indented_block = indent(codestr, ' ' * 4)
return code_directive + indented_block |
Extract the first paragraph of module - level docstring. max: 95 char | def extract_intro(filename):
""" Extract the first paragraph of module-level docstring. max:95 char"""
docstring, _ = get_docstring_and_rest(filename)
# lstrip is just in case docstring has a '\n\n' at the beginning
paragraphs = docstring.lstrip().split('\n\n')
if len(paragraphs) > 1:
firs... |
Returns md5sum of file | def get_md5sum(src_file):
"""Returns md5sum of file"""
with open(src_file, 'r') as src_data:
src_content = src_data.read()
# data needs to be encoded in python3 before hashing
if sys.version_info[0] == 3:
src_content = src_content.encode('utf-8')
src_md5 = hashlib.... |
Returns True if src_file has a different md5sum | def check_md5sum_change(src_file):
"""Returns True if src_file has a different md5sum"""
src_md5 = get_md5sum(src_file)
src_md5_file = src_file + '.md5'
src_file_changed = True
if os.path.exists(src_md5_file):
with open(src_md5_file, 'r') as file_checksum:
ref_md5 = file_checks... |
Test existence of image file and no change in md5sum of example | def _plots_are_current(src_file, image_file):
"""Test existence of image file and no change in md5sum of
example"""
first_image_file = image_file.format(1)
has_image = os.path.exists(first_image_file)
src_file_changed = check_md5sum_change(src_file)
return has_image and not src_file_changed |
Save all open matplotlib figures of the example code - block | def save_figures(image_path, fig_count, gallery_conf):
"""Save all open matplotlib figures of the example code-block
Parameters
----------
image_path : str
Path where plots are saved (format string which accepts figure number)
fig_count : int
Previous figure number count. Figure num... |
Scales an image with the same aspect ratio centered in an image with a given max_width and max_height if in_fname == out_fname the image can only be scaled down | def scale_image(in_fname, out_fname, max_width, max_height):
"""Scales an image with the same aspect ratio centered in an
image with a given max_width and max_height
if in_fname == out_fname the image can only be scaled down
"""
# local import to avoid testing dependency on PIL:
try:
... |
Save the thumbnail image | def save_thumbnail(image_path, base_image_name, gallery_conf):
"""Save the thumbnail image"""
first_image_file = image_path.format(1)
thumb_dir = os.path.join(os.path.dirname(first_image_file), 'thumb')
if not os.path.exists(thumb_dir):
os.makedirs(thumb_dir)
thumb_file = os.path.join(thumb... |
Generate the gallery reStructuredText for an example directory | def generate_dir_rst(src_dir, target_dir, gallery_conf, seen_backrefs):
"""Generate the gallery reStructuredText for an example directory"""
if not os.path.exists(os.path.join(src_dir, 'README.txt')):
print(80 * '_')
print('Example directory %s does not have a README.txt file' %
sr... |
Executes the code block of the example file | def execute_script(code_block, example_globals, image_path, fig_count,
src_file, gallery_conf):
"""Executes the code block of the example file"""
time_elapsed = 0
stdout = ''
# We need to execute the code
print('plotting code blocks in %s' % src_file)
plt.close('all')
cw... |
Generate the rst file for a given example. | def generate_file_rst(fname, target_dir, src_dir, gallery_conf):
""" Generate the rst file for a given example.
Returns the amout of code (in characters) of the corresponding
files.
"""
src_file = os.path.join(src_dir, fname)
example_file = os.path.join(target_dir, fname)
shutil.co... |
This version is 10 times faster than arburg but the output rho is not correct. | def _arburg2(X, order):
"""This version is 10 times faster than arburg, but the output rho is not correct.
returns [1 a0,a1, an-1]
"""
x = np.array(X)
N = len(x)
if order <= 0.:
raise ValueError("order must be > 0")
# Initialisation
# ------ rho, den
rho = sum(abs(x)**2.... |
r Estimate the complex autoregressive parameters by the Burg algorithm. | def arburg(X, order, criteria=None):
r"""Estimate the complex autoregressive parameters by the Burg algorithm.
.. math:: x(n) = \sqrt{(v}) e(n) + \sum_{k=1}^{P+1} a(k) x(n-k)
:param x: Array of complex data samples (length N)
:param order: Order of autoregressive process (0<order<N)
:param criter... |
Solve Ax = B using numpy cholesky solver | def _numpy_cholesky(A, B):
"""Solve Ax=B using numpy cholesky solver
A = LU
in the case where A is square and Hermitian, A = L.L* where L* is
transpoed and conjugate matrix
Ly = b
where
Ux=y
so x = U^{-1} y
where U = L*
and y = L^{-1} B
"""
L = numpy.linalg.cholesky... |
This function solve Ax = B directly without taking care of the input matrix properties. | def _numpy_solver(A, B):
"""This function solve Ax=B directly without taking care of the input
matrix properties.
"""
x = numpy.linalg.solve(A, B)
return x |
Solve linear system AX = B using CHOLESKY method. | def CHOLESKY(A, B, method='scipy'):
"""Solve linear system `AX=B` using CHOLESKY method.
:param A: an input Hermitian matrix
:param B: an array
:param str method: a choice of method in [numpy, scipy, numpy_solver]
* `numpy_solver` relies entirely on numpy.solver (no cholesky decomposition)
... |
Eigen value pseudo spectrum estimate. See: func: eigenfre | def music(X, IP, NSIG=None, NFFT=default_NFFT, threshold=None, criteria='aic',
verbose=False):
"""Eigen value pseudo spectrum estimate. See :func:`eigenfre`"""
return eigen(X, IP, NSIG=NSIG, method='music', NFFT=NFFT,
threshold=threshold, criteria=criteria, verbose=verbose) |
r Pseudo spectrum using eigenvector method ( EV or Music ) | def eigen(X, P, NSIG=None, method='music', threshold=None, NFFT=default_NFFT,
criteria='aic', verbose=False):
r"""Pseudo spectrum using eigenvector method (EV or Music)
This function computes either the Music or EigenValue (EV) noise
subspace frequency estimator.
First, an autocorrelation ma... |
todo | def _get_signal_space(S, NP, verbose=False, threshold=None, NSIG=None,
criteria='aic'):
"""todo
"""
from .criteria import aic_eigen, mdl_eigen
# This section selects automatically the noise and signal subspaces.
# NSIG being the number of eigenvalues corresponding to signals.
... |
Simple periodogram but matrices accepted. | def speriodogram(x, NFFT=None, detrend=True, sampling=1.,
scale_by_freq=True, window='hamming', axis=0):
"""Simple periodogram, but matrices accepted.
:param x: an array or matrix of data samples.
:param NFFT: length of the data before FFT is computed (zero padding)
:param bool detre... |
r Simple periodogram wrapper of numpy. psd function. | def WelchPeriodogram(data, NFFT=None, sampling=1., **kargs):
r"""Simple periodogram wrapper of numpy.psd function.
:param A: the input data
:param int NFFT: total length of the final data sets (padded
with zero if needed; default is 4096)
:param str window:
:Technical documentation:
... |
r Return Daniell s periodogram. | def DaniellPeriodogram(data, P, NFFT=None, detrend='mean', sampling=1.,
scale_by_freq=True, window='hamming'):
r"""Return Daniell's periodogram.
To reduce fast fluctuations of the spectrum one idea proposed by daniell
is to average each value with points in its neighboorhood. It's li... |
Return the centered frequency range as a generator. | def centerdc_gen(self):
"""Return the centered frequency range as a generator.
::
>>> print(list(Range(8).centerdc_gen()))
[-0.5, -0.375, -0.25, -0.125, 0.0, 0.125, 0.25, 0.375]
"""
for a in range(0, self.N):
yield (a-self.N/2) * self.df |
Return the one - sided frequency range as a generator. | def onesided_gen(self):
"""Return the one-sided frequency range as a generator.
If :attr:`N` is even, the length is N/2 + 1.
If :attr:`N` is odd, the length is (N+1)/2.
::
>>> print(list(Range(8).onesided()))
[0.0, 0.125, 0.25, 0.375, 0.5]
>>> print... |
Return the frequency vector according to: attr: sides | def frequencies(self, sides=None):
"""Return the frequency vector according to :attr:`sides`"""
# use the attribute sides except if a valid sides argument is provided
if sides is None:
sides = self.sides
if sides not in self._sides_choices:
raise errors.SpectrumC... |
This function returns the PSD in the ** sides ** format | def get_converted_psd(self, sides):
"""This function returns the PSD in the **sides** format
:param str sides: the PSD format in ['onesided', 'twosided', 'centerdc']
:return: the expected PSD.
.. doctest::
from spectrum import *
p = pcovar(marple_data, 15)
... |
a simple plotting routine to plot the PSD versus frequency. | def plot(self, filename=None, norm=False, ylim=None,
sides=None, **kargs):
"""a simple plotting routine to plot the PSD versus frequency.
:param str filename: save the figure into a file
:param norm: False by default. If True, the PSD is normalised.
:param ylim: readjust ... |
r Return the power contained in the PSD | def power(self):
r"""Return the power contained in the PSD
if scale_by_freq is False, the power is:
.. math:: P = N \sum_{k=1}^{N} P_{xx}(k)
else, it is
.. math:: P = \sum_{k=1}^{N} P_{xx}(k) \frac{df}{2\pi}
.. todo:: check these equations
"""
if s... |
An alias to: class: ~spectrum. periodogram. Periodogram | def periodogram(self):
"""An alias to :class:`~spectrum.periodogram.Periodogram`
The parameters are extracted from the attributes. Relevant attributes
ares :attr:`window`, attr:`sampling`, attr:`NFFT`, attr:`scale_by_freq`,
:attr:`detrend`.
.. plot::
:width: 80%
... |
Returns a dictionary with the elements of a Jupyter notebook | def ipy_notebook_skeleton():
"""Returns a dictionary with the elements of a Jupyter notebook"""
py_version = sys.version_info
notebook_skeleton = {
"cells": [],
"metadata": {
"kernelspec": {
"display_name": "Python " + str(py_version[0]),
"language... |
Converts the RST text from the examples docstrigs and comments into markdown text for the IPython notebooks | def rst2md(text):
"""Converts the RST text from the examples docstrigs and comments
into markdown text for the IPython notebooks"""
top_heading = re.compile(r'^=+$\s^([\w\s-]+)^=+$', flags=re.M)
text = re.sub(top_heading, r'# \1', text)
math_eq = re.compile(r'^\.\. math::((?:.+)?(?:\n+^ .+)*)', f... |
Add a markdown cell to the notebook | def add_markdown_cell(self, text):
"""Add a markdown cell to the notebook
Parameters
----------
code : str
Cell content
"""
markdown_cell = {
"cell_type": "markdown",
"metadata": {},
"source": [rst2md(text)]
}
... |
Saves the notebook to a file | def save_file(self):
"""Saves the notebook to a file"""
with open(self.write_file, 'w') as out_nb:
json.dump(self.work_notebook, out_nb, indent=2) |
r Computes power spectral density given ARMA values. | def arma2psd(A=None, B=None, rho=1., T=1., NFFT=4096, sides='default',
norm=False):
r"""Computes power spectral density given ARMA values.
This function computes the power spectral density values
given the ARMA parameters of an ARMA model. It assumes that
the driving sequence is a white noise p... |
Autoregressive and moving average estimators. | def arma_estimate(X, P, Q, lag):
"""Autoregressive and moving average estimators.
This function provides an estimate of the autoregressive
parameters, the moving average parameters, and the driving
white noise variance of an ARMA(P,Q) for a complex or real data sequence.
The parameters are estima... |
Moving average estimator. | def ma(X, Q, M):
"""Moving average estimator.
This program provides an estimate of the moving average parameters
and driving noise variance for a data sequence based on a
long AR model and a least squares fit.
:param array X: The input data array
:param int Q: Desired MA model order (must be >... |
PSD estimate using correlogram method. | def CORRELOGRAMPSD(X, Y=None, lag=-1, window='hamming',
norm='unbiased', NFFT=4096, window_params={},
correlation_method='xcorr'):
"""PSD estimate using correlogram method.
:param array X: complex or real data samples X(1) to X(N)
:param array Y: complex data sample... |
Helper function to get data over http or from a local file | def _get_data(url):
"""Helper function to get data over http or from a local file"""
if url.startswith('http://'):
# Try Python 2, use Python 3 on exception
try:
resp = urllib.urlopen(url)
encoding = resp.headers.dict.get('content-encoding', 'plain')
except Attrib... |
Select first block delimited by start_tag and end_tag | def _select_block(str_in, start_tag, end_tag):
"""Select first block delimited by start_tag and end_tag"""
start_pos = str_in.find(start_tag)
if start_pos < 0:
raise ValueError('start_tag not found')
depth = 0
for pos in range(start_pos, len(str_in)):
if str_in[pos] == start_tag:
... |
Parse a dictionary from the search index | def _parse_dict_recursive(dict_str):
"""Parse a dictionary from the search index"""
dict_out = dict()
pos_last = 0
pos = dict_str.find(':')
while pos >= 0:
key = dict_str[pos_last:pos]
if dict_str[pos + 1] == '[':
# value is a list
pos_tmp = dict_str.find(']',... |
Parse a Sphinx search index | def parse_sphinx_searchindex(searchindex):
"""Parse a Sphinx search index
Parameters
----------
searchindex : str
The Sphinx search index (contents of searchindex.js)
Returns
-------
filenames : list of str
The file names parsed from the search index.
objects : dict
... |
Embed hyperlinks to documentation into example code | def embed_code_links(app, exception):
"""Embed hyperlinks to documentation into example code"""
if exception is not None:
return
# No need to waste time embedding hyperlinks when not running the examples
# XXX: also at the time of writing this fixes make html-noplot
# for some reason I don'... |
Get a valid link False if not found | def _get_link(self, cobj):
"""Get a valid link, False if not found"""
fname_idx = None
full_name = cobj['module_short'] + '.' + cobj['name']
if full_name in self._searchindex['objects']:
value = self._searchindex['objects'][full_name]
if isinstance(value, dict):
... |
#ARMA 15 order a b rho = spectrum. arma_estimate ( data 15 15 30 ) psd = spectrum. arma2psd ( A = a B = b rho = rho ) newpsd = tools. cshift ( psd len ( psd )// 2 ) # switch positive and negative freq pylab. plot ( f 10 * pylab. log10 ( newpsd/ max ( newpsd )) label = ARMA 15 15 ) | def create_all_psd():
f = pylab.linspace(0, 1, 4096)
pylab.figure(figsize=(12,8))
# MA model
p = spectrum.pma(xx, 64,128); p(); p.plot()
"""
#ARMA 15 order
a, b, rho = spectrum.arma_estimate(data, 15,15, 30)
psd = spectrum.arma2psd(A=a,B=b, rho=rho)
newpsd = tools.cshift(psd, len(... |
Convert transfer function filter parameters to zero - pole - gain form | def tf2zp(b,a):
"""Convert transfer function filter parameters to zero-pole-gain form
Find the zeros, poles, and gains of this continuous-time system:
.. warning:: b and a must have the same length.
::
from spectrum import tf2zp
b = [2,3,0]
a = [1, 0.4, 1]
[z,p,k... |
Given two list or arrays pad with zeros the shortest array | def eqtflength(b,a):
"""Given two list or arrays, pad with zeros the shortest array
:param b: list or array
:param a: list or array
.. doctest::
>>> from spectrum.transfer import eqtflength
>>> a = [1,2]
>>> b = [1,2,3,4]
>>> a, b, = eqtflength(a,b)
"""
d = a... |
Return zero pole gain ( z p k ) representation from a numerator denominator representation of a linear filter. | def tf2zpk(b, a):
"""Return zero, pole, gain (z,p,k) representation from a numerator,
denominator representation of a linear filter.
Convert zero-pole-gain filter parameters to transfer function form
:param ndarray b: numerator polynomial.
:param ndarray a: numerator and denominator polynomials.
... |
State - space representation to zero - pole - gain representation. | def ss2zpk(a,b,c,d, input=0):
"""State-space representation to zero-pole-gain representation.
:param A: ndarray State-space representation of linear system.
:param B: ndarray State-space representation of linear system.
:param C: ndarray State-space representation of linear system.
:param D: ndarra... |
r Return polynomial transfer function representation from zeros and poles | def zpk2tf(z, p, k):
r"""Return polynomial transfer function representation from zeros and poles
:param ndarray z: Zeros of the transfer function.
:param ndarray p: Poles of the transfer function.
:param float k: System gain.
:return:
b : ndarray Numerator polynomial.
a : ndarray N... |
Zero - pole - gain representation to state - space representation | def zpk2ss(z, p, k):
"""Zero-pole-gain representation to state-space representation
:param sequence z,p: Zeros and poles.
:param float k: System gain.
:return:
* A, B, C, D : ndarray State-space matrices.
.. note:: wrapper of scipy function zpk2ss
"""
import scipy.signal
retur... |
r Returns the N - point window given a valid name | def create_window(N, name=None, **kargs):
r"""Returns the N-point window given a valid name
:param int N: window size
:param str name: window name (default is *rectangular*). Valid names
are stored in :func:`~spectrum.window.window_names`.
:param kargs: optional arguments are:
* *beta*... |
r Computes the equivalent noise bandwidth | def enbw(data):
r"""Computes the equivalent noise bandwidth
.. math:: ENBW = N \frac{\sum_{n=1}^{N} w_n^2}{\left(\sum_{n=1}^{N} w_n \right)^2}
.. doctest::
>>> from spectrum import create_window, enbw
>>> w = create_window(64, 'rectangular')
>>> enbw(w)
1.0
The follow... |
Independant Kaiser window | def _kaiser(n, beta):
"""Independant Kaiser window
For the definition of the Kaiser window, see A. V. Oppenheim & R. W. Schafer, "Discrete-Time Signal Processing".
The continuous version of width n centered about x=0 is:
.. note:: 2 times slower than scipy.kaiser
"""
from scipy.special import... |
A Window visualisation tool | def window_visu(N=51, name='hamming', **kargs):
"""A Window visualisation tool
:param N: length of the window
:param name: name of the window
:param NFFT: padding used by the FFT
:param mindB: the minimum frequency power in dB
:param maxdB: the maximum frequency power in dB
:param kargs: op... |
r Kaiser window | def window_kaiser(N, beta=8.6, method='numpy'):
r"""Kaiser window
:param N: window length
:param beta: kaiser parameter (default is 8.6)
To obtain a Kaiser window that designs an FIR filter with
sidelobe attenuation of :math:`\alpha` dB, use the following :math:`\beta` where
:math:`\beta = \pi... |
r Blackman window | def window_blackman(N, alpha=0.16):
r"""Blackman window
:param N: window length
.. math:: a_0 - a_1 \cos(\frac{2\pi n}{N-1}) +a_2 \cos(\frac{4\pi n }{N-1})
with
.. math::
a_0 = (1-\alpha)/2, a_1=0.5, a_2=\alpha/2 \rm{\;and\; \alpha}=0.16
When :math:`\alpha=0.16`, this is the unqual... |
r Gaussian window | def window_gaussian(N, alpha=2.5):
r"""Gaussian window
:param N: window length
.. math:: \exp^{-0.5 \left( \sigma\frac{n}{N/2} \right)^2}
with :math:`\frac{N-1}{2}\leq n \leq \frac{N-1}{2}`.
.. note:: N-1 is used to be in agreement with octave convention. The ENBW of
1.4 is also in agre... |
Cheb window | def window_chebwin(N, attenuation=50):
"""Cheb window
:param N: window length
.. plot::
:width: 80%
:include-source:
from spectrum import window_visu
window_visu(64, 'chebwin', attenuation=50)
.. seealso:: scipy.signal.chebwin, :func:`create_window`, :class:`Window`
... |
r Cosine tapering window also known as sine window. | def window_cosine(N):
r"""Cosine tapering window also known as sine window.
:param N: window length
.. math:: w(n) = \cos\left(\frac{\pi n}{N-1} - \frac{\pi}{2}\right) = \sin \left(\frac{\pi n}{N-1}\right)
.. plot::
:width: 80%
:include-source:
from spectrum import window_vis... |
r Lanczos window also known as sinc window. | def window_lanczos(N):
r"""Lanczos window also known as sinc window.
:param N: window length
.. math:: w(n) = sinc \left( \frac{2n}{N-1} - 1 \right)
.. plot::
:width: 80%
:include-source:
from spectrum import window_visu
window_visu(64, 'lanczos')
.. seealso:: :... |
r Bartlett - Hann window | def window_bartlett_hann(N):
r"""Bartlett-Hann window
:param N: window length
.. math:: w(n) = a_0 + a_1 \left| \frac{n}{N-1} -\frac{1}{2}\right| - a_2 \cos \left( \frac{2\pi n}{N-1} \right)
with :math:`a_0 = 0.62`, :math:`a_1 = 0.48` and :math:`a_2=0.38`
.. plot::
:width: 80%
:i... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.