INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Decorator for adding wait animation to long running functions. | def wait(animation='elipses', text='', speed=0.2):
"""
Decorator for adding wait animation to long running
functions.
Args:
animation (str, tuple): String reference to animation or tuple
with custom animation.
speed (float): Number of seconds each cycle of animation.
Ex... |
Decorator for adding simple text wait animation to long running functions. | def simple_wait(func):
"""
Decorator for adding simple text wait animation to
long running functions.
Examples:
>>> @animation.simple_wait
>>> def long_running_function():
>>> ... 5 seconds later ...
>>> return
"""
@wraps(func)
def wrapper(*args, **kw... |
Start animation thread. | def start(self):
"""
Start animation thread.
"""
self.thread = threading.Thread(target=self._animate)
self.thread.start()
return |
Stop animation thread. | def stop(self):
"""
Stop animation thread.
"""
time.sleep(self.speed)
self._count = -9999
sys.stdout.write(self.reverser + '\r\033[K\033[A')
sys.stdout.flush()
return |
Merge several timeseries Arguments: tup: sequence of Timeseries with the same shape except for axis 0 Returns: Resulting merged timeseries which can have duplicate time points. | def merge(tup):
"""Merge several timeseries
Arguments:
tup: sequence of Timeseries, with the same shape except for axis 0
Returns:
Resulting merged timeseries which can have duplicate time points.
"""
if not all(tuple(ts.shape[1:] == tup[0].shape[1:] for ts in tup[1:])):
raise V... |
Dynamically add new analysis methods to the Timeseries class. Args: source: Can be a function module or the filename of a python file. If a filename or a module is given then all functions defined inside not starting with _ will be added as methods. | def add_analyses(cls, source):
"""Dynamically add new analysis methods to the Timeseries class.
Args:
source: Can be a function, module or the filename of a python file.
If a filename or a module is given, then all functions defined
inside not starting with _ will be a... |
Calculate the absolute value element - wise. | def absolute(self):
"""Calculate the absolute value element-wise.
Returns:
absolute (Timeseries):
Absolute value. For complex input (a + b*j) gives sqrt(a**a + b**2)
"""
return Timeseries(np.absolute(self), self.tspan, self.labels) |
Return the angle of the complex argument. | def angle(self, deg=False):
"""Return the angle of the complex argument.
Args:
deg (bool, optional):
Return angle in degrees if True, radians if False (default).
Returns:
angle (Timeseries):
The counterclockwise angle from the positive real axis on
... |
Interchange two axes of a Timeseries. | def swapaxes(self, axis1, axis2):
"""Interchange two axes of a Timeseries."""
if self.ndim <=1 or axis1 == axis2:
return self
ar = np.asarray(self).swapaxes(axis1, axis2)
if axis1 != 0 and axis2 != 0:
# then axis 0 is unaffected by the swap
labels = se... |
Permute the dimensions of a Timeseries. | def transpose(self, *axes):
"""Permute the dimensions of a Timeseries."""
if self.ndim <= 1:
return self
ar = np.asarray(self).transpose(*axes)
if axes[0] != 0:
# then axis 0 is unaffected by the transposition
newlabels = [self.labels[ax] for ax in axe... |
If axis 0 is unaffected by the reshape then returns a Timeseries otherwise returns an ndarray. Preserves labels of axis j only if all axes< = j are unaffected by the reshape. See numpy. ndarray. reshape () for more information | def reshape(self, newshape, order='C'):
"""If axis 0 is unaffected by the reshape, then returns a Timeseries,
otherwise returns an ndarray. Preserves labels of axis j only if all
axes<=j are unaffected by the reshape.
See ``numpy.ndarray.reshape()`` for more information
"""
... |
Merge another timeseries with this one Arguments: ts ( Timeseries ): The two timeseries being merged must have the same shape except for axis 0. Returns: Resulting merged timeseries which can have duplicate time points. | def merge(self, ts):
"""Merge another timeseries with this one
Arguments:
ts (Timeseries): The two timeseries being merged must have the
same shape except for axis 0.
Returns:
Resulting merged timeseries which can have duplicate time points.
"""
i... |
Insert a new axis at a given position in the array shape Args: axis ( int ): Position ( amongst axes ) where new axis is to be inserted. | def expand_dims(self, axis):
"""Insert a new axis, at a given position in the array shape
Args:
axis (int): Position (amongst axes) where new axis is to be inserted.
"""
if axis == -1:
axis = self.ndim
array = np.expand_dims(self, axis)
if axis == 0:... |
Join a sequence of Timeseries to this one Args: tup ( sequence of Timeseries ): timeseries to be joined with this one. They must have the same shape as this Timeseries except in the dimension corresponding to axis. axis ( int optional ): The axis along which timeseries will be joined. Returns: res ( Timeseries or ndarr... | def concatenate(self, tup, axis=0):
"""Join a sequence of Timeseries to this one
Args:
tup (sequence of Timeseries): timeseries to be joined with this one.
They must have the same shape as this Timeseries, except in the
dimension corresponding to `axis`.
axis... |
Split a timeseries into multiple sub - timeseries | def split(self, indices_or_sections, axis=0):
"""Split a timeseries into multiple sub-timeseries"""
if not isinstance(indices_or_sections, numbers.Integral):
raise Error('splitting by array of indices is not yet implemented')
n = indices_or_sections
if self.shape[axis] % n !=... |
Plot a distributed timeseries Args: dts ( DistTimeseries ) title ( str optional ) points ( int optional ): Limit the number of time points plotted. If specified will downsample to use this total number of time points and only fetch back the necessary points to the client for plotting. Returns: fig | def plot(dts, title=None, points=None, show=True):
"""Plot a distributed timeseries
Args:
dts (DistTimeseries)
title (str, optional)
points (int, optional): Limit the number of time points plotted.
If specified, will downsample to use this total number of time points,
and on... |
Plot a polar histogram of a phase variable s probability distribution Args: dts: DistTimeseries with axis 2 ranging over separate instances of an oscillator ( time series values are assumed to represent an angle ) times ( float or sequence of floats ): The target times at which to plot the distribution nbins ( int ): n... | def phase_histogram(dts, times=None, nbins=30, colormap=mpl.cm.Blues):
"""Plot a polar histogram of a phase variable's probability distribution
Args:
dts: DistTimeseries with axis 2 ranging over separate instances of an
oscillator (time series values are assumed to represent an angle)
times ... |
plot Welch estimate of power spectral density using nperseg samples per segment with noverlap samples overlap and Hamming window. | def psd(ts, nperseg=1500, noverlap=1200, plot=True):
"""plot Welch estimate of power spectral density, using nperseg samples per
segment, with noverlap samples overlap and Hamming window."""
ts = ts.squeeze()
if ts.ndim is 1:
ts = ts.reshape((-1, 1))
fs = (len(ts) - 1.0) / (ts.tspan[-1] - ts... |
forward - backward butterworth low - pass filter | def lowpass(ts, cutoff_hz, order=3):
"""forward-backward butterworth low-pass filter"""
orig_ndim = ts.ndim
if ts.ndim is 1:
ts = ts[:, np.newaxis]
channels = ts.shape[1]
fs = (len(ts) - 1.0) / (ts.tspan[-1] - ts.tspan[0])
nyq = 0.5 * fs
cutoff = cutoff_hz/nyq
b, a = signal.butte... |
forward - backward butterworth band - pass filter | def bandpass(ts, low_hz, high_hz, order=3):
"""forward-backward butterworth band-pass filter"""
orig_ndim = ts.ndim
if ts.ndim is 1:
ts = ts[:, np.newaxis]
channels = ts.shape[1]
fs = (len(ts) - 1.0) / (ts.tspan[-1] - ts.tspan[0])
nyq = 0.5 * fs
low = low_hz/nyq
high = high_hz/ny... |
notch filter to remove remove a particular frequency Adapted from code by Sturla Molden | def notch(ts, freq_hz, bandwidth_hz=1.0):
"""notch filter to remove remove a particular frequency
Adapted from code by Sturla Molden
"""
orig_ndim = ts.ndim
if ts.ndim is 1:
ts = ts[:, np.newaxis]
channels = ts.shape[1]
fs = (len(ts) - 1.0) / (ts.tspan[-1] - ts.tspan[0])
nyq = 0.... |
Analytic signal using the Hilbert transform | def hilbert(ts):
"""Analytic signal, using the Hilbert transform"""
output = signal.hilbert(signal.detrend(ts, axis=0), axis=0)
return Timeseries(output, ts.tspan, labels=ts.labels) |
Amplitude of the analytic signal using the Hilbert transform | def hilbert_amplitude(ts):
"""Amplitude of the analytic signal, using the Hilbert transform"""
output = np.abs(signal.hilbert(signal.detrend(ts, axis=0), axis=0))
return Timeseries(output, ts.tspan, labels=ts.labels) |
Phase of the analytic signal using the Hilbert transform | def hilbert_phase(ts):
"""Phase of the analytic signal, using the Hilbert transform"""
output = np.angle(signal.hilbert(signal.detrend(ts, axis=0), axis=0))
return Timeseries(output, ts.tspan, labels=ts.labels) |
Continuous wavelet transform Note the full results can use a huge amount of memory at 64 - bit precision | def cwt(ts, freqs=np.logspace(0, 2), wavelet=cwtmorlet, plot=True):
"""Continuous wavelet transform
Note the full results can use a huge amount of memory at 64-bit precision
Args:
ts: Timeseries of m variables, shape (n, m). Assumed constant timestep.
freqs: list of frequencies (in Hz) to use f... |
Continuous wavelet transform using distributed computation. ( Currently just splits the data by channel. TODO split it further. ) Note: this function requires an IPython cluster to be started first. | def cwt_distributed(ts, freqs=np.logspace(0, 2), wavelet=cwtmorlet, plot=True):
"""Continuous wavelet transform using distributed computation.
(Currently just splits the data by channel. TODO split it further.)
Note: this function requires an IPython cluster to be started first.
Args:
ts: Timeser... |
Plot time resolved power spectral density from cwt results Args: ts: the original Timeseries coefs: continuous wavelet transform coefficients as calculated by cwt () freqs: list of frequencies ( in Hz ) corresponding to coefs. tsize fsize: size of the plot ( time axis and frequency axis in pixels ) | def _plot_cwt(ts, coefs, freqs, tsize=1024, fsize=512):
"""Plot time resolved power spectral density from cwt results
Args:
ts: the original Timeseries
coefs: continuous wavelet transform coefficients as calculated by cwt()
freqs: list of frequencies (in Hz) corresponding to coefs.
tsiz... |
For an ensemble of time series return the set of all time intervals between successive returns to value c for all instances in the ensemble. If c is not given the default is the mean across all times and across all time series in the ensemble. | def first_return_times(dts, c=None, d=0.0):
"""For an ensemble of time series, return the set of all time intervals
between successive returns to value c for all instances in the ensemble.
If c is not given, the default is the mean across all times and across all
time series in the ensemble.
Args:
... |
Example variability function. Gives two continuous time - resolved measures of the variability of a time series ranging between - 1 and 1. The two measures are based on variance of the centroid frequency and variance of the height of the spectral peak respectively. ( Centroid frequency meaning the power - weighted aver... | def variability_fp(ts, freqs=None, ncycles=6, plot=True):
"""Example variability function.
Gives two continuous, time-resolved measures of the variability of a
time series, ranging between -1 and 1.
The two measures are based on variance of the centroid frequency and
variance of the height of the ... |
Identify stationary epochs within a time series based on a continuous measure of variability. Epochs are defined to contain the points of minimal variability and to extend as wide as possible with variability not exceeding the threshold. | def epochs(ts, variability=None, threshold=0.0, minlength=1.0, plot=True):
"""Identify "stationary" epochs within a time series, based on a
continuous measure of variability.
Epochs are defined to contain the points of minimal variability, and to
extend as wide as possible with variability not exceedi... |
Identify epochs within a multivariate time series where at least a certain proportion of channels are stationary based on a previously computed variability measure. | def epochs_joint(ts, variability=None, threshold=0.0, minlength=1.0,
proportion=0.75, plot=True):
"""Identify epochs within a multivariate time series where at least a
certain proportion of channels are "stationary", based on a previously
computed variability measure.
(Note: This req... |
For an ensemble of oscillators return the set of periods lengths of all successive oscillations of all oscillators. | def periods(dts, phi=0.0):
"""For an ensemble of oscillators, return the set of periods lengths of
all successive oscillations of all oscillators.
An individual oscillation is defined to start and end when the phase
passes phi (by default zero) after completing a full cycle.
If the timeseries of... |
Circular mean phase | def circmean(dts, axis=2):
"""Circular mean phase"""
return np.exp(1.0j * dts).mean(axis=axis).angle() |
Order parameter of phase synchronization | def order_param(dts, axis=2):
"""Order parameter of phase synchronization"""
return np.abs(np.exp(1.0j * dts).mean(axis=axis)) |
Circular standard deviation | def circstd(dts, axis=2):
"""Circular standard deviation"""
R = np.abs(np.exp(1.0j * dts).mean(axis=axis))
return np.sqrt(-2.0 * np.log(R)) |
Aburn2012 equations right hand side noise free term Args: v: ( 8 ) array state vector t: number scalar time Returns: ( 8 ) array | def f(self, v, t):
"""Aburn2012 equations right hand side, noise free term
Args:
v: (8,) array
state vector
t: number
scalar time
Returns:
(8,) array
"""
ret = np.zeros(8)
ret[0] = v[4]
ret[4] = (self.He1*s... |
Aburn2012 equations right hand side noise term Args: v: ( 8 ) array state vector t: number scalar time Returns: ( 8 1 ) array Only one matrix column meaning that in this example we are modelling the noise input to pyramidal and spiny populations as fully correlated. To simulate uncorrelated inputs instead use an array ... | def G(self, v, t):
"""Aburn2012 equations right hand side, noise term
Args:
v: (8,) array
state vector
t: number
scalar time
Returns:
(8,1) array
Only one matrix column, meaning that in this example we are modelling
th... |
How to couple the output of one node to the input of another. Args: source_y ( array of shape ( 8 )): state of the source node target_y ( array of shape ( 8 )): state of the target node weight ( float ): the connection strength Returns: input ( array of shape ( 8 )): value to drive each variable of the target node. | def coupling(self, source_y, target_y, weight):
"""How to couple the output of one node to the input of another.
Args:
source_y (array of shape (8,)): state of the source node
target_y (array of shape (8,)): state of the target node
weight (float): the connection strength
... |
Compute the Hurst exponent of X. If the output H = 0. 5 the behavior of the time - series is similar to random walk. If H<0. 5 the time - series cover less distance than a random walk vice verse. | def hurst(X):
""" Compute the Hurst exponent of X. If the output H=0.5,the behavior
of the time-series is similar to random walk. If H<0.5, the time-series
cover less "distance" than a random walk, vice verse.
Parameters
----------
X
list
a time series
Returns
------... |
Build a set of embedding sequences from given time series X with lag Tau and embedding dimension DE. Let X = [ x ( 1 ) x ( 2 )... x ( N ) ] then for each i such that 1 < i < N - ( D - 1 ) * Tau we build an embedding sequence Y ( i ) = [ x ( i ) x ( i + Tau )... x ( i + ( D - 1 ) * Tau ) ]. All embedding sequence are pl... | def embed_seq(X, Tau, D):
"""Build a set of embedding sequences from given time series X with lag Tau
and embedding dimension DE. Let X = [x(1), x(2), ... , x(N)], then for each
i such that 1 < i < N - (D - 1) * Tau, we build an embedding sequence,
Y(i) = [x(i), x(i + Tau), ... , x(i + (D - 1) * Tau)].... |
Compute power in each frequency bin specified by Band from FFT result of X. By default X is a real signal. | def bin_power(X, Band, Fs):
"""Compute power in each frequency bin specified by Band from FFT result of
X. By default, X is a real signal.
Note
-----
A real signal can be synthesized, thus not real.
Parameters
-----------
Band
list
boundary frequencies (in Hz) of bins... |
Compute Petrosian Fractal Dimension of a time series from either two cases below: 1. X the time series of type list ( default ) 2. D the first order differential sequence of X ( if D is provided recommended to speed up ) | def pfd(X, D=None):
"""Compute Petrosian Fractal Dimension of a time series from either two
cases below:
1. X, the time series of type list (default)
2. D, the first order differential sequence of X (if D is provided,
recommended to speed up)
In case 1, D is computed using Numpy'... |
Compute Hjorth Fractal Dimension of a time series X kmax is an HFD parameter | def hfd(X, Kmax):
""" Compute Hjorth Fractal Dimension of a time series X, kmax
is an HFD parameter
"""
L = []
x = []
N = len(X)
for k in range(1, Kmax):
Lk = []
for m in range(0, k):
Lmk = 0
for i in range(1, int(numpy.floor((N - m) / k))):
... |
Compute Hjorth mobility and complexity of a time series from either two cases below: 1. X the time series of type list ( default ) 2. D a first order differential sequence of X ( if D is provided recommended to speed up ) | def hjorth(X, D=None):
""" Compute Hjorth mobility and complexity of a time series from either two
cases below:
1. X, the time series of type list (default)
2. D, a first order differential sequence of X (if D is provided,
recommended to speed up)
In case 1, D is computed using N... |
Compute spectral entropy of a time series from either two cases below: 1. X the time series ( default ) 2. Power_Ratio a list of normalized signal power in a set of frequency bins defined in Band ( if Power_Ratio is provided recommended to speed up ) | def spectral_entropy(X, Band, Fs, Power_Ratio=None):
"""Compute spectral entropy of a time series from either two cases below:
1. X, the time series (default)
2. Power_Ratio, a list of normalized signal power in a set of frequency
bins defined in Band (if Power_Ratio is provided, recommended to speed up... |
Compute SVD Entropy from either two cases below: 1. a time series X with lag tau and embedding dimension dE ( default ) 2. a list W of normalized singular values of a matrix ( if W is provided recommend to speed up. ) | def svd_entropy(X, Tau, DE, W=None):
"""Compute SVD Entropy from either two cases below:
1. a time series X, with lag tau and embedding dimension dE (default)
2. a list, W, of normalized singular values of a matrix (if W is provided,
recommend to speed up.)
If W is None, the function will do as fol... |
Computer approximate entropy ( ApEN ) of series X specified by M and R. | def ap_entropy(X, M, R):
"""Computer approximate entropy (ApEN) of series X, specified by M and R.
Suppose given time series is X = [x(1), x(2), ... , x(N)]. We first build
embedding matrix Em, of dimension (N-M+1)-by-M, such that the i-th row of
Em is x(i),x(i+1), ... , x(i+M-1). Hence, the embedding ... |
Computer sample entropy ( SampEn ) of series X specified by M and R. | def samp_entropy(X, M, R):
"""Computer sample entropy (SampEn) of series X, specified by M and R.
SampEn is very close to ApEn.
Suppose given time series is X = [x(1), x(2), ... , x(N)]. We first build
embedding matrix Em, of dimension (N-M+1)-by-M, such that the i-th row of
Em is x(i),x(i+1), ...... |
Compute Detrended Fluctuation Analysis from a time series X and length of boxes L. | def dfa(X, Ave=None, L=None):
"""Compute Detrended Fluctuation Analysis from a time series X and length of
boxes L.
The first step to compute DFA is to integrate the signal. Let original
series be X= [x(1), x(2), ..., x(N)].
The integrated signal Y = [y(1), y(2), ..., y(N)] is obtained as follows
... |
Compute Permutation Entropy of a given time series x specified by permutation order n and embedding lag tau. | def permutation_entropy(x, n, tau):
"""Compute Permutation Entropy of a given time series x, specified by
permutation order n and embedding lag tau.
Parameters
----------
x
list
a time series
n
integer
Permutation order
tau
integer
Embed... |
Calculates the information based similarity of two time series x and y. | def information_based_similarity(x, y, n):
"""Calculates the information based similarity of two time series x
and y.
Parameters
----------
x
list
a time series
y
list
a time series
n
integer
word order
Returns
----------
... |
Calculate largest Lyauponov exponent of a given time series x using Rosenstein algorithm. | def LLE(x, tau, n, T, fs):
"""Calculate largest Lyauponov exponent of a given time series x using
Rosenstein algorithm.
Parameters
----------
x
list
a time series
n
integer
embedding dimension
tau
integer
Embedding lag
fs
in... |
For a timeseries where all variables represent phases ( in radians ) return an equivalent timeseries where all values are in the range ( - pi pi ] | def mod2pi(ts):
"""For a timeseries where all variables represent phases (in radians),
return an equivalent timeseries where all values are in the range (-pi, pi]
"""
return np.pi - np.mod(np.pi - ts, 2*np.pi) |
For a single variable timeseries representing the phase of an oscillator find the times at which the phase crosses angle phi with the condition that the phase must visit phi + pi between crossings. | def phase_crossings(ts, phi=0.0):
"""For a single variable timeseries representing the phase of an oscillator,
find the times at which the phase crosses angle phi,
with the condition that the phase must visit phi+pi between crossings.
(Thus if noise causes the phase to wander back and forth across angl... |
For a single variable timeseries representing the phase of an oscillator measure the period of each successive oscillation. | def periods(ts, phi=0.0):
"""For a single variable timeseries representing the phase of an oscillator,
measure the period of each successive oscillation.
An individual oscillation is defined to start and end when the phase
passes phi (by default zero) after completing a full cycle.
If the timeser... |
Circular mean phase | def circmean(ts, axis=2):
"""Circular mean phase"""
return np.exp(1.0j * ts).mean(axis=axis).angle() |
Order parameter of phase synchronization | def order_param(ts, axis=2):
"""Order parameter of phase synchronization"""
return np.abs(np.exp(1.0j * ts).mean(axis=axis)) |
complex morlet wavelet function compatible with scipy. signal. cwt Parameters: points: int Number of points in vector. width: scalar Width parameter of wavelet. Equals ( sample rate/ fundamental frequency of wavelet ) Returns: vector: complex - valued ndarray of shape ( points ) | def cwtmorlet(points, width):
"""complex morlet wavelet function compatible with scipy.signal.cwt
Parameters: points: int
Number of points in `vector`.
width: scalar
Width parameter of wavelet.
Equals (sample rate / fundamental frequenc... |
Continuous wavelet transform. | def roughcwt(data, wavelet, widths):
"""
Continuous wavelet transform.
Performs a continuous wavelet transform on `data`,
using the `wavelet` function. A CWT performs a convolution
with `data` using the `wavelet` function, which is characterized
by a width parameter and length parameter.
P... |
Example variability function. Gives two continuous time - resolved measures of the variability of a time series ranging between - 1 and 1. The two measures are based on variance of the centroid frequency and variance of the height of the spectral peak respectively. ( Centroid frequency meaning the power - weighted aver... | def variability_fp(ts, freqs=None, ncycles=6, plot=True):
"""Example variability function.
Gives two continuous, time-resolved measures of the variability of a
time series, ranging between -1 and 1.
The two measures are based on variance of the centroid frequency and
variance of the height of the ... |
Shift and rescale array ar to the interval [ - 1 1 ] | def _rescale(ar):
"""Shift and rescale array ar to the interval [-1, 1]"""
max = np.nanmax(ar)
min = np.nanmin(ar)
midpoint = (max + min) / 2.0
return 2.0 * (ar - midpoint) / (max - min) |
Get cycle of colors in a way compatible with all matplotlib versions | def _get_color_list():
"""Get cycle of colors in a way compatible with all matplotlib versions"""
if 'axes.prop_cycle' in plt.rcParams:
return [p['color'] for p in list(plt.rcParams['axes.prop_cycle'])]
else:
return plt.rcParams['axes.color_cycle'] |
Plot the timeseries and variability. Optionally plot epochs. | def _plot_variability(ts, variability, threshold=None, epochs=None):
"""Plot the timeseries and variability. Optionally plot epochs."""
import matplotlib.style
import matplotlib as mpl
mpl.style.use('classic')
import matplotlib.pyplot as plt
if variability.ndim is 1:
variability = variab... |
Identify stationary epochs within a time series based on a continuous measure of variability. Epochs are defined to contain the points of minimal variability and to extend as wide as possible with variability not exceeding the threshold. | def epochs(ts, variability=None, threshold=0.0, minlength=1.0, plot=True):
"""Identify "stationary" epochs within a time series, based on a
continuous measure of variability.
Epochs are defined to contain the points of minimal variability, and to
extend as wide as possible with variability not exceedi... |
Same as epochs () but computes channels in parallel for speed. | def epochs_distributed(ts, variability=None, threshold=0.0, minlength=1.0,
plot=True):
"""Same as `epochs()`, but computes channels in parallel for speed.
(Note: This requires an IPython cluster to be started first,
e.g. on a workstation type 'ipcluster start')
Identify... |
Identify epochs within a multivariate time series where at least a certain proportion of channels are stationary based on a previously computed variability measure. | def epochs_joint(ts, variability=None, threshold=0.0, minlength=1.0,
proportion=0.75, plot=True):
"""Identify epochs within a multivariate time series where at least a
certain proportion of channels are "stationary", based on a previously
computed variability measure.
(Note: This req... |
Plot a Timeseries Args: ts Timeseries title str show bool whether to display the figure or just return a figure object | def plot(ts, title=None, show=True):
"""Plot a Timeseries
Args:
ts Timeseries
title str
show bool whether to display the figure or just return a figure object
"""
ts = _remove_pi_crossings(ts)
fig = plt.figure()
ylabelprops = dict(rotation=0,
hor... |
For each variable in the Timeseries checks whether it represents a phase variable ranging from - pi to pi. If so set all points where the phase crosses pi to nan so that spurious lines will not be plotted. | def _remove_pi_crossings(ts):
"""For each variable in the Timeseries, checks whether it represents
a phase variable ranging from -pi to pi. If so, set all points where the
phase crosses pi to 'nan' so that spurious lines will not be plotted.
If ts does not need adjustment, then return ts.
Otherwis... |
load a multi - channel Timeseries from a MATLAB. mat file | def timeseries_from_mat(filename, varname=None, fs=1.0):
"""load a multi-channel Timeseries from a MATLAB .mat file
Args:
filename (str): .mat file to load
varname (str): variable name. only needed if there is more than one
variable saved in the .mat file
fs (scalar): sample rate of t... |
save a Timeseries to a MATLAB. mat file Args: ts ( Timeseries ): the timeseries to save filename ( str ):. mat filename to save to | def save_mat(ts, filename):
"""save a Timeseries to a MATLAB .mat file
Args:
ts (Timeseries): the timeseries to save
filename (str): .mat filename to save to
"""
import scipy.io as sio
tspan = ts.tspan
fs = (1.0*len(tspan) - 1) / (tspan[-1] - tspan[0])
mat_dict = {'data': np.asar... |
Load a multi - channel Timeseries from any file type supported by biosig | def timeseries_from_file(filename):
"""Load a multi-channel Timeseries from any file type supported by `biosig`
Supported file formats include EDF/EDF+, BDF/BDF+, EEG, CNT and GDF.
Full list is here: http://pub.ist.ac.at/~schloegl/biosig/TESTED
For EDF, EDF+, BDF and BDF+ files, we will use python-edf... |
load a multi - channel Timeseries from an EDF ( European Data Format ) file or EDF + file using edflib. | def _load_edflib(filename):
"""load a multi-channel Timeseries from an EDF (European Data Format) file
or EDF+ file, using edflib.
Args:
filename: EDF+ file
Returns:
Timeseries
"""
import edflib
e = edflib.EdfReader(filename, annotations_mode='all')
if np.ptp(e.get_samples_... |
Get a list of event annotations from an EDF ( European Data Format file or EDF + file using edflib. | def annotations_from_file(filename):
"""Get a list of event annotations from an EDF (European Data Format file
or EDF+ file, using edflib.
Args:
filename: EDF+ file
Returns:
list: annotation events, each in the form [start_time, duration, text]
"""
import edflib
e = edflib.EdfR... |
After using the superclass __numpy_ufunc__ to route ufunc computations on the array data convert any resulting ndarray RemoteArray and DistArray instances into Timeseries RemoteTimeseries and DistTimeseries instances if appropriate | def _ufunc_wrap(out_arr, ufunc, method, i, inputs, **kwargs):
"""After using the superclass __numpy_ufunc__ to route ufunc computations
on the array data, convert any resulting ndarray, RemoteArray and DistArray
instances into Timeseries, RemoteTimeseries and DistTimeseries instances
if appropriate"""
... |
construct a RemoteTimeseries from a RemoteArray | def _rts_from_ra(ra, tspan, labels, block=True):
"""construct a RemoteTimeseries from a RemoteArray"""
def _convert(a, tspan, labels):
from nsim import Timeseries
return Timeseries(a, tspan, labels)
return distob.call(
_convert, ra, tspan, labels, prefer_local=False, block=block) |
construct a DistTimeseries from a DistArray | def _dts_from_da(da, tspan, labels):
"""construct a DistTimeseries from a DistArray"""
sublabels = labels[:]
new_subarrays = []
for i, ra in enumerate(da._subarrays):
if isinstance(ra, RemoteTimeseries):
new_subarrays.append(ra)
else:
if labels[da._distaxis]:
... |
Make a simulation of the system defined by functions f and G. | def newsim(f, G, y0, name='NewModel', modelType=ItoModel, T=60.0, dt=0.005, repeat=1, identical=True):
"""Make a simulation of the system defined by functions f and G.
dy = f(y,t)dt + G(y,t).dW with initial condition y0
This helper function is for convenience, making it easy to define
one-off simulati... |
Use the functions f and G to define a new Model class for simulations. | def newmodel(f, G, y0, name='NewModel', modelType=ItoModel):
"""Use the functions f and G to define a new Model class for simulations.
It will take functions f and G from global scope and make a new Model class
out of them. It will automatically gather any globals used in the definition
of f and G and... |
Make a new version of a function that has its own independent copy of any globals that it uses directly and has its own name. All other attributes are assigned from the original function. | def __clone_function(f, name=None):
"""Make a new version of a function that has its own independent copy
of any globals that it uses directly, and has its own name.
All other attributes are assigned from the original function.
Args:
f: the function to clone
name (str): the name for the ... |
Insert a new axis at a given position in the array shape Args: axis ( int ): Position ( amongst axes ) where new axis is to be inserted. | def expand_dims(self, axis):
"""Insert a new axis, at a given position in the array shape
Args:
axis (int): Position (amongst axes) where new axis is to be inserted.
"""
if axis <= self._distaxis:
subaxis = axis
new_distaxis = self._distaxis + 1
... |
Calculate the absolute value element - wise. | def absolute(self):
"""Calculate the absolute value element-wise.
Returns:
absolute (Timeseries):
Absolute value. For complex input (a + b*j) gives sqrt(a**a + b**2)
"""
da = distob.vectorize(np.absolute)(self)
return _dts_from_da(da, self.tspan, self.label... |
Return the angle of a complex Timeseries | def angle(self, deg=False):
"""Return the angle of a complex Timeseries
Args:
deg (bool, optional):
Return angle in degrees if True, radians if False (default).
Returns:
angle (Timeseries):
The counterclockwise angle from the positive real axis on
... |
How to couple the output of one subsystem to the input of another. | def coupling(self, source_y, target_y, weight):
"""How to couple the output of one subsystem to the input of another.
This is a fallback default coupling function that should usually be
replaced with your own.
This example coupling function takes the mean of all variables of the
... |
Deterministic term f of the complete network system dy = f ( y t ) dt + G ( y t ). dot ( dW ) | def f(self, y, t):
"""Deterministic term f of the complete network system
dy = f(y, t)dt + G(y, t).dot(dW)
(or for an ODE network system without noise, dy/dt = f(y, t))
Args:
y (array of shape (d,)): where d is the dimension of the overall
state space of the compl... |
Noise coefficient matrix G of the complete network system dy = f ( y t ) dt + G ( y t ). dot ( dW ) | def G(self, y, t):
"""Noise coefficient matrix G of the complete network system
dy = f(y, t)dt + G(y, t).dot(dW)
(for an ODE network system without noise this function is not used)
Args:
y (array of shape (d,)): where d is the dimension of the overall
state space ... |
Allow submodels with scalar equations. Convert to 1D vector systems. Args: m ( Model ) | def _scalar_to_vector(self, m):
"""Allow submodels with scalar equations. Convert to 1D vector systems.
Args:
m (Model)
"""
if not isinstance(m.y0, numbers.Number):
return m
else:
m = copy.deepcopy(m)
t0 = 0.0
if isinstanc... |
Introduce a new axis 2 that ranges across nodes of the network | def _reshape_timeseries(self, ts):
"""Introduce a new axis 2 that ranges across nodes of the network"""
if np.count_nonzero(np.diff(self._sublengths)) == 0:
# then all submodels have the same dimension, so can reshape array
# in place without copying data:
subdim = se... |
Introduce a new axis 2 that ranges across nodes of the network | def _reshape_output(self, ts):
"""Introduce a new axis 2 that ranges across nodes of the network"""
subodim = len(self.submodels[0].output_vars)
shp = list(ts.shape)
shp[1] = subodim
shp.insert(2, self._n)
ts = ts.reshape(tuple(shp))
ts.labels[2] = self._node_labe... |
Simulated time series | def timeseries(self):
"""Simulated time series"""
if self._timeseries is None:
self.compute()
if isinstance(self.system, NetworkModel):
return self.system._reshape_timeseries(self._timeseries)
else:
return self._timeseries |
Simulated model output | def output(self):
"""Simulated model output"""
if self._timeseries is None:
self.compute()
output = self._timeseries[:, self.system.output_vars]
if isinstance(self.system, NetworkModel):
return self.system._reshape_output(output)
else:
return o... |
Rank 3 array representing output time series. Axis 0 is time axis 1 ranges across output variables of a single simulation axis 2 ranges across different simulation instances. | def output(self):
"""Rank 3 array representing output time series. Axis 0 is time,
axis 1 ranges across output variables of a single simulation,
axis 2 ranges across different simulation instances."""
subts = [s.output for s in self.sims]
sub_ndim = subts[0].ndim
if sub... |
Given an integer index ix into the list of sims returns the pair ( s m ) where s is the relevant subsim and m is the subindex into s. So self [ ix ] == self. _subsims [ s ] [ m ] | def _tosub(self, ix):
"""Given an integer index ix into the list of sims, returns the pair
(s, m) where s is the relevant subsim and m is the subindex into s.
So self[ix] == self._subsims[s][m]
"""
N = self._n
if ix >= N or ix < -N:
raise IndexError(
... |
Maps a list of integer indices to sub - indices. ixlist can contain repeated indices and does not need to be sorted. Returns pair ( ss ms ) where ss is a list of subsim numbers and ms is a list of lists of subindices m ( one list for each subsim in ss ). | def _tosubs(self, ixlist):
"""Maps a list of integer indices to sub-indices.
ixlist can contain repeated indices and does not need to be sorted.
Returns pair (ss, ms) where ss is a list of subsim numbers and ms is a
list of lists of subindices m (one list for each subsim in ss).
... |
Rank 3 array representing output time series. Axis 0 is time axis 1 ranges across output variables of a single simulation axis 2 ranges across different simulation instances. | def output(self):
"""Rank 3 array representing output time series. Axis 0 is time,
axis 1 ranges across output variables of a single simulation, axis 2
ranges across different simulation instances."""
subts = [rms.output for rms in self._subsims]
distaxis = subts[0].ndim - 1
... |
For a single variable timeseries find the times at which the value crosses c from above or below. Can optionally set a non - zero d to impose the condition that the value must wander at least d units away from c between crossings. | def crossing_times(ts, c=0.0, d=0.0):
"""For a single variable timeseries, find the times at which the
value crosses ``c`` from above or below. Can optionally set a non-zero
``d`` to impose the condition that the value must wander at least ``d``
units away from ``c`` between crossings.
If the time... |
For a single variable time series first wait until the time series attains the value c for the first time. Then record the time intervals between successive returns to c. If c is not given the default is the mean of the time series. Args: ts: Timeseries ( single variable ) | def first_return_times(ts, c=None, d=0.0):
"""For a single variable time series, first wait until the time series
attains the value c for the first time. Then record the time intervals
between successive returns to c. If c is not given, the default is the mean
of the time series.
Args:
t... |
Returns the discrete linear convolution of a time series with itself optionally using unbiased normalization. | def autocorrelation(ts, normalized=False, unbiased=False):
"""
Returns the discrete, linear convolution of a time series with itself,
optionally using unbiased normalization.
N.B. Autocorrelation estimates are necessarily inaccurate for longer lags,
as there are less pairs of points to convolve s... |
Verifies the value is between 1 and 9 inclusively. | def fan_speed(self, value):
"""Verifies the value is between 1 and 9 inclusively."""
if value not in range(1, 10):
raise exceptions.RoasterValueError
self._fan_speed.value = value |
Verifies that the heat setting is between 0 and 3. | def heat_setting(self, value):
"""Verifies that the heat setting is between 0 and 3."""
if value not in range(0, 4):
raise exceptions.RoasterValueError
self._heat_setting.value = value |
Verifies that the heater_level is between 0 and heater_segments. Can only be called when freshroastsr700 object is initialized with ext_sw_heater_drive = True. Will throw RoasterValueError otherwise. | def heater_level(self, value):
"""Verifies that the heater_level is between 0 and heater_segments.
Can only be called when freshroastsr700 object is initialized
with ext_sw_heater_drive=True. Will throw RoasterValueError
otherwise."""
if self._ext_sw_heater_drive:
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.