# Utility Functions¶

Utility functions for SRSF Manipulations

moduleauthor:: J. Derek Tucker <jdtuck@sandia.gov>

utility_functions.SqrtMean(gam)[source]

calculates the srsf of warping functions with corresponding shooting vectors

Parameters: gam – numpy ndarray of shape (M,N) of M warping functions with N samples 2 numpy ndarray and vector Karcher mean psi function vector of dim N which is the Karcher mean warping function numpy ndarray of shape (M,N) of M SRSF of the warping functions numpy ndarray of shape (M,N) of M shooting vectors
utility_functions.SqrtMeanInverse(gam)[source]

finds the inverse of the mean of the set of the diffeomorphisms gamma

Parameters: gam – numpy ndarray of shape (M,N) of M warping functions with N samples vector inverse of gam
utility_functions.SqrtMedian(gam)[source]

calculates the median srsf of warping functions with corresponding shooting vectors

Parameters: Return type: gam – numpy ndarray of shape (M,N) of M warping functions with N samples 2 numpy ndarray and vector Karcher median warping function vector of dim N which is the Karcher median srsf function numpy ndarray of shape (M,N) of M SRSF of the warping functions numpy ndarray of shape (M,N) of M shooting vectors
utility_functions.cumtrapzmid(x, y, c, mid)[source]

cumulative trapezoidal numerical integration taken from midpoint

Parameters: x – vector of size N describing the time samples y – vector of size N describing the function c – midpointtic mid – midpiont location vector cumulative integration
utility_functions.diffop(n, binsize=1)[source]

Creates a second order differential operator

Parameters: n – dimension binsize – dx (default = 1) numpy ndarray matrix describing differential operator
utility_functions.elastic_depth(f, time, method='DP2', lam=0.0, parallel=True)[source]

calculates the elastic depth between functions in matrix f

Parameters: f – matrix of size MxN (M time points for N functions) time – vector of size M describing the sample points method – method to apply optimization (default=”DP2”) options are “DP”,”DP2”,”RBFGS” lam – controls the elasticity (default = 0.0) scalar amplitude depth phase depth
utility_functions.elastic_distance(f1, f2, time, method='DP2', lam=0.0)[source]

” calculates the distances between function, where f1 is aligned to f2. In other words calculates the elastic distances

Parameters: f1 – vector of size N f2 – vector of size N time – vector of size N describing the sample points method – method to apply optimization (default=”DP2”) options are “DP”,”DP2”,”RBFGS” lam – controls the elasticity (default = 0.0) scalar amplitude distance phase distance
utility_functions.f_K_fold(Nobs, K=5)[source]

generates sample indices for K-fold cross validation

:param Nobs number of observations :param K number of folds

Return type: numpy ndarray train indexes (Nobs*(K-1)/K X K) test indexes (Nobs*(1/K) X K)
utility_functions.f_to_srsf(f, time, smooth=False)[source]

converts f to a square-root slope function (SRSF)

Parameters: f – vector of size N samples time – vector of size N describing the sample points vector srsf of f
utility_functions.geigen(Amat, Bmat, Cmat)[source]

generalized eigenvalue problem of the form

max tr L’AM / sqrt(tr L’BL tr M’CM) w.r.t. L and M

:param Amat numpy ndarray of shape (M,N) :param Bmat numpy ndarray of shape (M,N) :param Bmat numpy ndarray of shape (M,N)

Return type: numpy ndarray eigenvalues left eigenvectors right eigenvectors
utility_functions.gradient_spline(time, f, smooth=False)[source]

This function takes the gradient of f using b-spline smoothing

Parameters: time – vector of size N describing the sample points f – numpy ndarray of shape (M,N) of M functions with N samples smooth – smooth data (default = F) tuple of numpy ndarray smoothed functions functions first derivative of each function second derivative of each function
utility_functions.innerprod_q(time, q1, q2)[source]

calculates the innerproduct between two srsfs

:param time vector descrbing time samples :param q1 vector of srsf 1 :param q2 vector of srsf 2

Return type: scalar inner product value
utility_functions.invertGamma(gam)[source]

finds the inverse of the diffeomorphism gamma

Parameters: gam – vector describing the warping function vector inverse of gam
utility_functions.optimum_reparam(q1, time, q2, method='DP2', lam=0.0, grid_dim=7)[source]

calculates the warping to align srsf q2 to q1

Parameters: q1 – vector of size N or array of NxM samples of first SRSF time – vector of size N describing the sample points q2 – vector of size N or array of NxM samples samples of second SRSF method – method to apply optimization (default=”DP2”) options are “DP”,”DP2”,”RBFGS” lam – controls the amount of elasticity (default = 0.0) grid_dim – size of the grid, for the DP2 method only (default = 7) vector describing the warping function used to align q2 with q1
utility_functions.optimum_reparam_pair(q, time, q1, q2, lam=0.0)[source]

calculates the warping to align srsf pair q1 and q2 to q

Parameters: q – vector of size N or array of NxM samples of first SRSF time – vector of size N describing the sample points q1 – vector of size N or array of NxM samples samples of second SRSF q2 – vector of size N or array of NxM samples samples of second SRSF lam – controls the amount of elasticity (default = 0.0) vector describing the warping function used to align q2 with q1
utility_functions.outlier_detection(q, time, mq, k=1.5)[source]

calculates outlier’s using geodesic distances of the SRSFs from the median

Parameters: q – numpy ndarray of N x M of M SRS functions with N samples time – vector of size N describing the sample points mq – median calculated using time_warping.srsf_align() k – cutoff threshold (default = 1.5) q_outlier: outlier functions
utility_functions.randomGamma(gam, num)[source]

generates random warping functions

Parameters: gam – numpy ndarray of N x M of M of warping functions num – number of random functions rgam: random warping functions
utility_functions.resamplefunction(x, n)[source]

resample function using n points

Parameters: x – functions n – number of points numpy array resampled function
utility_functions.rgam(N, sigma, num)[source]

Generates random warping functions

Parameters: N – length of warping function sigma – variance of warping functions num – number of warping functions gam: numpy ndarray of warping functions
utility_functions.smooth_data(f, sparam)[source]

This function smooths a collection of functions using a box filter

Parameters: f – numpy ndarray of shape (M,N) of M functions with N samples sparam – Number of times to run box filter (default = 25) numpy ndarray smoothed functions functions
utility_functions.srsf_to_f(q, time, f0=0.0)[source]

converts q (srsf) to a function

Parameters: q – vector of size N samples of srsf time – vector of size N describing time sample points f0 – initial value vector function
utility_functions.update_progress(progress)[source]

This function creates a progress bar

Parameters: progress – fraction of progress
utility_functions.warp_f_gamma(time, f, gam)[source]

warps a function f by gam

:param time vector describing time samples :param q vector describing srsf :param gam vector describing warping function

Return type: numpy ndarray warped srsf
utility_functions.warp_q_gamma(time, q, gam)[source]

warps a srsf q by gam

:param time vector describing time samples :param q vector describing srsf :param gam vector describing warping function

Return type: numpy ndarray warped srsf
utility_functions.zero_crossing(Y, q, bt, time, y_max, y_min, gmax, gmin)[source]

finds zero-crossing of optimal gamma, gam = s*gmax + (1-s)*gmin from elastic regression model

Parameters: Y – response q – predicitve function bt – basis function time – time samples y_max – maximum repsonse for warping function gmax y_min – minimum response for warping function gmin gmax – max warping function gmin – min warping fucntion numpy array optimal warping function