"""

Numerical python functions written for compatability with MATLAB

commands with the same names.

MATLAB compatible functions

-------------------------------

:func:`cohere`

Coherence (normalized cross spectral density)

:func:`csd`

Cross spectral density uing Welch's average periodogram

:func:`detrend`

Remove the mean or best fit line from an array

:func:`find`

Return the indices where some condition is true;

numpy.nonzero is similar but more general.

:func:`griddata`

interpolate irregularly distributed data to a

regular grid.

:func:`prctile`

find the percentiles of a sequence

:func:`prepca`

Principal Component Analysis

:func:`psd`

Power spectral density uing Welch's average periodogram

:func:`rk4`

A 4th order runge kutta integrator for 1D or ND systems

:func:`specgram`

Spectrogram (power spectral density over segments of time)

Miscellaneous functions

-------------------------

Functions that don't exist in MATLAB, but are useful anyway:

:meth:`cohere_pairs`

Coherence over all pairs. This is not a MATLAB function, but we

compute coherence a lot in my lab, and we compute it for a lot of

pairs. This function is optimized to do this efficiently by

caching the direct FFTs.

:meth:`rk4`

A 4th order Runge-Kutta ODE integrator in case you ever find

yourself stranded without scipy (and the far superior

scipy.integrate tools)

:meth:`contiguous_regions`

return the indices of the regions spanned by some logical mask

:meth:`cross_from_below`

return the indices where a 1D array crosses a threshold from below

:meth:`cross_from_above`

return the indices where a 1D array crosses a threshold from above

record array helper functions

-------------------------------

A collection of helper methods for numpyrecord arrays

.. _htmlonly:

See :ref:`misc-examples-index`

:meth:`rec2txt`

pretty print a record array

:meth:`rec2csv`

store record array in CSV file

:meth:`csv2rec`

import record array from CSV file with type inspection

:meth:`rec_append_fields`

adds field(s)/array(s) to record array

:meth:`rec_drop_fields`

drop fields from record array

:meth:`rec_join`

join two record arrays on sequence of fields

:meth:`recs_join`

a simple join of multiple recarrays using a single column as a key

:meth:`rec_groupby`

summarize data by groups (similar to SQL GROUP BY)

:meth:`rec_summarize`

helper code to filter rec array fields into new fields

For the rec viewer functions(e rec2csv), there are a bunch of Format

objects you can pass into the functions that will do things like color

negative values red, set percent formatting and scaling, etc.

Example usage::

r = csv2rec('somefile.csv', checkrows=0)

formatd = dict(

weight = FormatFloat(2),

change = FormatPercent(2),

cost = FormatThousands(2),

)

rec2excel(r, 'test.xls', formatd=formatd)

rec2csv(r, 'test.csv', formatd=formatd)

scroll = rec2gtk(r, formatd=formatd)

win = gtk.Window()

win.set_size_request(600,800)

win.add(scroll)

win.show_all()

gtk.main()

Deprecated functions

---------------------

The following are deprecated; please import directly from numpy (with

care--function signatures may differ):

:meth:`load`

load ASCII file - use numpy.loadtxt

:meth:`save`

save ASCII file - use numpy.savetxt

"""

from __future__ import division, print_function

import csv, warnings, copy, os, operator

from itertools import izip

import numpy as np

ma = np.ma

from matplotlib import verbose

from matplotlib.cbook import mplDeprecation

import matplotlib.cbook as cbook

from matplotlib import docstring

from matplotlib.path import Path

def logspace(xmin,xmax,N):

return np.exp(np.linspace(np.log(xmin), np.log(xmax), N))

def _norm(x):

"return sqrt(x dot x)"

return np.sqrt(np.dot(x,x))

def window_hanning(x):

"return x times the hanning window of len(x)"

return np.hanning(len(x))*x

def window_none(x):

"No window function; simply return x"

return x

def detrend(x, key=None):

if key is None or key=='constant':

return detrend_mean(x)

elif key=='linear':

return detrend_linear(x)

def demean(x, axis=0):

"Return x minus its mean along the specified axis"

x = np.asarray(x)

if axis == 0 or axis is None or x.ndim <= 1:

return x - x.mean(axis)

ind = [slice(None)] * x.ndim

ind[axis] = np.newaxis

return x - x.mean(axis)[ind]

def detrend_mean(x):

"Return x minus the mean(x)"

return x - x.mean()

def detrend_none(x):

"Return x: no detrending"

return x

def detrend_linear(y):

"Return y minus best fit line; 'linear' detrending "

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

x = np.arange(len(y), dtype=np.float_)

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

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

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

return y - (b*x + a)

#This is a helper function that implements the commonality between the

#psd, csd, and spectrogram. It is *NOT* meant to be used outside of mlab

def _spectral_helper(x, y, NFFT=256, Fs=2, detrend=detrend_none,

window=window_hanning, noverlap=0, pad_to=None, sides='default',

scale_by_freq=None):

#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

#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)

else:

y = x

# 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 scale_by_freq is None:

scale_by_freq = True

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

if (sides == 'default' and np.iscomplexobj(x)) or sides == 'twosided':

numFreqs = pad_to

scaling_factor = 1.

elif sides in ('default', 'onesided'):

numFreqs = pad_to//2 + 1

scaling_factor = 2.

else:

raise ValueError("sides must be one of: 'default', 'onesided', or "

"'twosided'")

if cbook.iterable(window):

assert(len(window) == NFFT)

windowVals = window

else:

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

step = NFFT - noverlap

ind = np.arange(0, len(x) - NFFT + 1, step)

n = len(ind)

Pxy = np.zeros((numFreqs, n), np.complex_)

# do the ffts of the slices

for i in range(n):

thisX = x[ind[i]:ind[i]+NFFT]

thisX = windowVals * detrend(thisX)

fx = np.fft.fft(thisX, n=pad_to)

if same_data:

fy = fx

else:

thisY = y[ind[i]:ind[i]+NFFT]

thisY = windowVals * detrend(thisY)

fy = np.fft.fft(thisY, n=pad_to)

Pxy[:,i] = np.conjugate(fx[:numFreqs]) * fy[:numFreqs]

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

# windowing loss; see Bendat & Piersol Sec 11.5.2.

Pxy /= (np.abs(windowVals)**2).sum()

# 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:

Pxy[1:-1] *= 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:

Pxy /= Fs

t = 1./Fs * (ind + NFFT / 2.)

freqs = float(Fs) / pad_to * np.arange(numFreqs)

if (np.iscomplexobj(x) and sides == 'default') or sides == 'twosided':

# center the frequency range at zero

freqs = np.concatenate((freqs[numFreqs//2:] - Fs, freqs[:numFreqs//2]))

Pxy = np.concatenate((Pxy[numFreqs//2:, :], Pxy[:numFreqs//2, :]), 0)

return Pxy, freqs, t

#Split out these keyword docs so that they can be used elsewhere

docstring.interpd.update(PSD=cbook.dedent("""

Keyword arguments:

*NFFT*: integer

The number of data points used in each block for the FFT.

Must be even; a power 2 is most efficient. The default value is 256.

This should *NOT* be used to get zero padding, or the scaling of the

result will be incorrect. Use *pad_to* for this instead.

*Fs*: scalar

The sampling frequency (samples per time unit). It is used

to calculate the Fourier frequencies, freqs, in cycles per time

unit. The default value is 2.

*detrend*: callable

The function applied to each segment before fft-ing,

designed to remove the mean or linear trend. Unlike in

MATLAB, where the *detrend* parameter is a vector, in

matplotlib is it a function. The :mod:`~matplotlib.pylab`

module defines :func:`~matplotlib.pylab.detrend_none`,

:func:`~matplotlib.pylab.detrend_mean`, and

:func:`~matplotlib.pylab.detrend_linear`, but you can use

a custom function as well.

*window*: callable or ndarray

A function or a vector of length *NFFT*. To create window

vectors see :func:`window_hanning`, :func:`window_none`,

:func:`numpy.blackman`, :func:`numpy.hamming`,

:func:`numpy.bartlett`, :func:`scipy.signal`,

:func:`scipy.signal.get_window`, etc. The default is

:func:`window_hanning`. If a function is passed as the

argument, it must take a data segment as an argument and

return the windowed version of the segment.

*pad_to*: integer

The number of points to which the data segment is padded when

performing the FFT. This can be different from *NFFT*, which

specifies the number of data points used. While not increasing

the actual resolution of the psd (the minimum distance between

resolvable peaks), this can give more points in the plot,

allowing for more detail. This corresponds to the *n* parameter

in the call to fft(). The default is None, which sets *pad_to*

equal to *NFFT*

*sides*: [ 'default' | 'onesided' | 'twosided' ]

Specifies which sides of the PSD to return. Default gives the

default behavior, which returns one-sided for real data and both

for complex data. 'onesided' forces the return of a one-sided PSD,

while 'twosided' forces two-sided.

*scale_by_freq*: boolean

Specifies whether the resulting density values should be scaled

by the scaling frequency, which gives density in units of Hz^-1.

This allows for integration over the returned frequency values.

The default is True for MATLAB compatibility.

"""))

@docstring.dedent_interpd

def psd(x, NFFT=256, Fs=2, detrend=detrend_none, window=window_hanning,

noverlap=0, pad_to=None, sides='default', scale_by_freq=None):

"""

The power spectral density by Welch's average periodogram method.

The vector *x* is divided into *NFFT* length blocks. Each block

is detrended by the function *detrend* and windowed by the function

*window*. *noverlap* gives the length of the overlap between blocks.

The absolute(fft(block))**2 of each segment are averaged to compute

*Pxx*, with a scaling to correct for power loss due to windowing.

If len(*x*) < *NFFT*, it will be zero padded to *NFFT*.

*x*

Array or sequence containing the data

%(PSD)s

*noverlap*: integer

The number of points of overlap between blocks. The default value

is 0 (no overlap).

Returns the tuple (*Pxx*, *freqs*).

Refs:

Bendat & Piersol -- Random Data: Analysis and Measurement

Procedures, John Wiley & Sons (1986)

"""

Pxx,freqs = csd(x, x, NFFT, Fs, detrend, window, noverlap, pad_to, sides,

scale_by_freq)

return Pxx.real,freqs

@docstring.dedent_interpd

def csd(x, y, NFFT=256, Fs=2, detrend=detrend_none, window=window_hanning,

noverlap=0, pad_to=None, sides='default', scale_by_freq=None):

"""

The cross power spectral density by Welch's average periodogram

method. The vectors *x* and *y* are divided into *NFFT* length

blocks. Each block is detrended by the function *detrend* and

windowed by the function *window*. *noverlap* gives the length

of the overlap between blocks. The product of the direct FFTs

of *x* and *y* are averaged over each segment to compute *Pxy*,

with a scaling to correct for power loss due to windowing.

If len(*x*) < *NFFT* or len(*y*) < *NFFT*, they will be zero

padded to *NFFT*.

*x*, *y*

Array or sequence containing the data

%(PSD)s

*noverlap*: integer

The number of points of overlap between blocks. The default value

is 0 (no overlap).

Returns the tuple (*Pxy*, *freqs*).

Refs:

Bendat & Piersol -- Random Data: Analysis and Measurement

Procedures, John Wiley & Sons (1986)

"""

Pxy, freqs, t = _spectral_helper(x, y, NFFT, Fs, detrend, window,

noverlap, pad_to, sides, scale_by_freq)

if len(Pxy.shape) == 2 and Pxy.shape[1]>1:

Pxy = Pxy.mean(axis=1)

return Pxy, freqs

@docstring.dedent_interpd

def specgram(x, NFFT=256, Fs=2, detrend=detrend_none, window=window_hanning,

noverlap=128, pad_to=None, sides='default', scale_by_freq=None):

"""

Compute a spectrogram of data in *x*. Data are split into *NFFT*

length segments and the PSD of each section is computed. The

windowing function *window* is applied to each segment, and the

amount of overlap of each segment is specified with *noverlap*.

If *x* is real (i.e. non-complex) only the spectrum of the positive

frequencie is returned. If *x* is complex then the complete

spectrum is returned.

%(PSD)s

*noverlap*: integer

The number of points of overlap between blocks. The default value

is 128.

Returns a tuple (*Pxx*, *freqs*, *t*):

- *Pxx*: 2-D array, columns are the periodograms of

successive segments

- *freqs*: 1-D array of frequencies corresponding to the rows

in Pxx

- *t*: 1-D array of times corresponding to midpoints of

segments.

.. seealso::

:func:`psd`

:func:`psd` differs in the default overlap; in returning

the mean of the segment periodograms; and in not returning

times.

"""

assert(NFFT > noverlap)

Pxx, freqs, t = _spectral_helper(x, x, NFFT, Fs, detrend, window,

noverlap, pad_to, sides, scale_by_freq)

Pxx = Pxx.real #Needed since helper implements generically

return Pxx, freqs, t

_coh_error = """Coherence is calculated by averaging over *NFFT*

length segments. Your signal is too short for your choice of *NFFT*.

"""

@docstring.dedent_interpd

def cohere(x, y, NFFT=256, Fs=2, detrend=detrend_none, window=window_hanning,

noverlap=0, pad_to=None, sides='default', scale_by_freq=None):

"""

The coherence between *x* and *y*. Coherence is the normalized

cross spectral density:

.. math::

C_{xy} = \\frac{|P_{xy}|^2}{P_{xx}P_{yy}}

*x*, *y*

Array or sequence containing the data

%(PSD)s

*noverlap*: integer

The number of points of overlap between blocks. The default value

is 0 (no overlap).

The return value is the tuple (*Cxy*, *f*), where *f* are the

frequencies of the coherence vector. For cohere, scaling the

individual densities by the sampling frequency has no effect,

since the factors cancel out.

.. seealso::

:func:`psd` and :func:`csd`

For information about the methods used to compute

:math:`P_{xy}`, :math:`P_{xx}` and :math:`P_{yy}`.

"""

if len(x)<2*NFFT:

raise ValueError(_coh_error)

Pxx, f = psd(x, NFFT, Fs, detrend, window, noverlap, pad_to, sides,

scale_by_freq)

Pyy, f = psd(y, NFFT, Fs, detrend, window, noverlap, pad_to, sides,

scale_by_freq)

Pxy, f = csd(x, y, NFFT, Fs, detrend, window, noverlap, pad_to, sides,

scale_by_freq)

Cxy = np.divide(np.absolute(Pxy)**2, Pxx*Pyy)

Cxy.shape = (len(f),)

return Cxy, f

def donothing_callback(*args):

pass

def cohere_pairs( X, ij, NFFT=256, Fs=2, detrend=detrend_none,

window=window_hanning, noverlap=0,

preferSpeedOverMemory=True,

progressCallback=donothing_callback,

returnPxx=False):

u"""

Call signature::

Cxy, Phase, freqs = cohere_pairs( X, ij, ...)

Compute the coherence and phase for all pairs *ij*, in *X*.

*X* is a *numSamples* * *numCols* array

*ij* is a list of tuples. Each tuple is a pair of indexes into

the columns of X for which you want to compute coherence. For

example, if *X* has 64 columns, and you want to compute all

nonredundant pairs, define *ij* as::

ij = []

for i in range(64):

for j in range(i+1,64):

ij.append( (i,j) )

*preferSpeedOverMemory* is an optional bool. Defaults to true. If

False, limits the caching by only making one, rather than two,

complex cache arrays. This is useful if memory becomes critical.

Even when *preferSpeedOverMemory* is False, :func:`cohere_pairs`

will still give significant performace gains over calling

:func:`cohere` for each pair, and will use subtantially less

memory than if *preferSpeedOverMemory* is True. In my tests with

a 43000,64 array over all nonredundant pairs,

*preferSpeedOverMemory* = True delivered a 33% performance boost

on a 1.7GHZ Athlon with 512MB RAM compared with

*preferSpeedOverMemory* = False. But both solutions were more

than 10x faster than naively crunching all possible pairs through

:func:`cohere`.

Returns::

(Cxy, Phase, freqs)

where:

- *Cxy*: dictionary of (*i*, *j*) tuples -> coherence vector for

that pair. I.e., ``Cxy[(i,j) = cohere(X[:,i], X[:,j])``.

Number of dictionary keys is ``len(ij)``.

- *Phase*: dictionary of phases of the cross spectral density at

each frequency for each pair. Keys are (*i*, *j*).

- *freqs*: vector of frequencies, equal in length to either the

coherence or phase vectors for any (*i*, *j*) key.

e.g., to make a coherence Bode plot::

subplot(211)

plot( freqs, Cxy[(12,19)])

subplot(212)

plot( freqs, Phase[(12,19)])

For a large number of pairs, :func:`cohere_pairs` can be much more

efficient than just calling :func:`cohere` for each pair, because

it caches most of the intensive computations. If :math:`N` is the

number of pairs, this function is :math:`O(N)` for most of the

heavy lifting, whereas calling cohere for each pair is

:math:`O(N^2)`. However, because of the caching, it is also more

memory intensive, making 2 additional complex arrays with

approximately the same number of elements as *X*.

See :file:`test/cohere_pairs_test.py` in the src tree for an

example script that shows that this :func:`cohere_pairs` and

:func:`cohere` give the same results for a given pair.

.. seealso::

:func:`psd`

For information about the methods used to compute

:math:`P_{xy}`, :math:`P_{xx}` and :math:`P_{yy}`.

"""

numRows, numCols = X.shape

# zero pad if X is too short

if numRows < NFFT:

tmp = X

X = np.zeros( (NFFT, numCols), X.dtype)

X[:numRows,:] = tmp

del tmp

numRows, numCols = X.shape

# get all the columns of X that we are interested in by checking

# the ij tuples

allColumns = set()

for i,j in ij:

allColumns.add(i); allColumns.add(j)

Ncols = len(allColumns)

# for real X, ignore the negative frequencies

if np.iscomplexobj(X): numFreqs = NFFT

else: numFreqs = NFFT//2+1

# cache the FFT of every windowed, detrended NFFT length segement

# of every channel. If preferSpeedOverMemory, cache the conjugate

# as well

if cbook.iterable(window):

assert(len(window) == NFFT)

windowVals = window

else:

windowVals = window(np.ones(NFFT, X.dtype))

ind = range(0, numRows-NFFT+1, NFFT-noverlap)

numSlices = len(ind)

FFTSlices = {}

FFTConjSlices = {}

Pxx = {}

slices = range(numSlices)

normVal = np.linalg.norm(windowVals)**2

for iCol in allColumns:

progressCallback(i/Ncols, 'Cacheing FFTs')

Slices = np.zeros( (numSlices,numFreqs), dtype=np.complex_)

for iSlice in slices:

thisSlice = X[ind[iSlice]:ind[iSlice]+NFFT, iCol]

thisSlice = windowVals*detrend(thisSlice)

Slices[iSlice,:] = np.fft.fft(thisSlice)[:numFreqs]

FFTSlices[iCol] = Slices

if preferSpeedOverMemory:

FFTConjSlices[iCol] = np.conjugate(Slices)

Pxx[iCol] = np.divide(np.mean(abs(Slices)**2, axis=0), normVal)

del Slices, ind, windowVals

# compute the coherences and phases for all pairs using the

# cached FFTs

Cxy = {}

Phase = {}

count = 0

N = len(ij)

for i,j in ij:

count +=1

if count%10==0:

progressCallback(count/N, 'Computing coherences')

if preferSpeedOverMemory:

Pxy = FFTSlices[i] * FFTConjSlices[j]

else:

Pxy = FFTSlices[i] * np.conjugate(FFTSlices[j])

if numSlices>1: Pxy = np.mean(Pxy, axis=0)

#Pxy = np.divide(Pxy, normVal)

Pxy /= normVal

#Cxy[(i,j)] = np.divide(np.absolute(Pxy)**2, Pxx[i]*Pxx[j])

Cxy[i,j] = abs(Pxy)**2 / (Pxx[i]*Pxx[j])

Phase[i,j] = np.arctan2(Pxy.imag, Pxy.real)

freqs = Fs/NFFT*np.arange(numFreqs)

if returnPxx:

return Cxy, Phase, freqs, Pxx

else:

return Cxy, Phase, freqs

def entropy(y, bins):

r"""

Return the entropy of the data in *y*.

.. math::

\sum p_i \log_2(p_i)

where :math:`p_i` is the probability of observing *y* in the

:math:`i^{th}` bin of *bins*. *bins* can be a number of bins or a

range of bins; see :func:`numpy.histogram`.

Compare *S* with analytic calculation for a Gaussian::

x = mu + sigma * randn(200000)

Sanalytic = 0.5 * ( 1.0 + log(2*pi*sigma**2.0) )

"""

n, bins = np.histogram(y, bins)

n = n.astype(np.float_)

n = np.take(n, np.nonzero(n)[0]) # get the positive

p = np.divide(n, len(y))

delta = bins[1] - bins[0]

S = -1.0 * np.sum(p * np.log(p)) + np.log(delta)

return S

def normpdf(x, *args):

"Return the normal pdf evaluated at *x*; args provides *mu*, *sigma*"

mu, sigma = args

return 1./(np.sqrt(2*np.pi)*sigma)*np.exp(-0.5 * (1./sigma*(x - mu))**2)

def levypdf(x, gamma, alpha):

"Returm the levy pdf evaluated at *x* for params *gamma*, *alpha*"

N = len(x)

if N % 2 != 0:

raise ValueError('x must be an event length array; try\n' + \

'x = np.linspace(minx, maxx, N), where N is even')

dx = x[1] - x[0]

f = 1/(N*dx)*np.arange(-N / 2, N / 2, np.float_)

ind = np.concatenate([np.arange(N / 2, N, int),

np.arange(0, N / 2, int)])

df = f[1] - f[0]

cfl = np.exp(-gamma * np.absolute(2 * np.pi * f) ** alpha)

px = np.fft.fft(np.take(cfl, ind) * df).astype(np.float_)

return np.take(px, ind)

def find(condition):

"Return the indices where ravel(condition) is true"

res, = np.nonzero(np.ravel(condition))

return res

def longest_contiguous_ones(x):

"""

Return the indices of the longest stretch of contiguous ones in *x*,

assuming *x* is a vector of zeros and ones. If there are two

equally long stretches, pick the first.

"""

x = np.ravel(x)

if len(x)==0:

return np.array([])

ind = (x==0).nonzero()[0]

if len(ind)==0:

return np.arange(len(x))

if len(ind)==len(x):

return np.array([])

y = np.zeros( (len(x)+2,), x.dtype)

y[1:-1] = x

dif = np.diff(y)

up = (dif == 1).nonzero()[0];

dn = (dif == -1).nonzero()[0];

i = (dn-up == max(dn - up)).nonzero()[0][0]

ind = np.arange(up[i], dn[i])

return ind

def longest_ones(x):

'''alias for longest_contiguous_ones'''

return longest_contiguous_ones(x)

def prepca(P, frac=0):

"""

WARNING: this function is deprecated -- please see class PCA instead

Compute the principal components of *P*. *P* is a (*numVars*,

*numObs*) array. *frac* is the minimum fraction of variance that a

component must contain to be included.

Return value is a tuple of the form (*Pcomponents*, *Trans*,

*fracVar*) where:

- *Pcomponents* : a (numVars, numObs) array

- *Trans* : the weights matrix, ie, *Pcomponents* = *Trans* *

*P*

- *fracVar* : the fraction of the variance accounted for by each

component returned

A similar function of the same name was in the MATLAB

R13 Neural Network Toolbox but is not found in later versions;

its successor seems to be called "processpcs".

"""

warnings.warn('This function is deprecated -- see class PCA instead')

U,s,v = np.linalg.svd(P)

varEach = s**2/P.shape[1]

totVar = varEach.sum()

fracVar = varEach/totVar

ind = slice((fracVar>=frac).sum())

# select the components that are greater

Trans = U[:,ind].transpose()

# The transformed data

Pcomponents = np.dot(Trans,P)

return Pcomponents, Trans, fracVar[ind]

class PCA:

def __init__(self, a):

"""

compute the SVD of a and store data for PCA. Use project to

project the data onto a reduced set of dimensions

Inputs:

*a*: a numobservations x numdims array

Attrs:

*a* a centered unit sigma version of input a

*numrows*, *numcols*: the dimensions of a

*mu* : a numdims array of means of a

*sigma* : a numdims array of atandard deviation of a

*fracs* : the proportion of variance of each of the principal components

*Wt* : the weight vector for projecting a numdims point or array into PCA space

*Y* : a projected into PCA space

The factor loadings are in the Wt factor, ie the factor

loadings for the 1st principal component are given by Wt[0]

"""

n, m = a.shape

if n<m:

raise RuntimeError('we assume data in a is organized with numrows>numcols')

self.numrows, self.numcols = n, m

self.mu = a.mean(axis=0)

self.sigma = a.std(axis=0)

a = self.center(a)

self.a = a

U, s, Vh = np.linalg.svd(a, full_matrices=False)

Y = np.dot(Vh, a.T).T

vars = s**2/float(len(s))

self.fracs = vars/vars.sum()

self.Wt = Vh

self.Y = Y

def project(self, x, minfrac=0.):

'project x onto the principle axes, dropping any axes where fraction of variance<minfrac'

x = np.asarray(x)

ndims = len(x.shape)

if (x.shape[-1]!=self.numcols):

raise ValueError('Expected an array with dims[-1]==%d'%self.numcols)

Y = np.dot(self.Wt, self.center(x).T).T

mask = self.fracs>=minfrac

if ndims==2:

Yreduced = Y[:,mask]

else:

Yreduced = Y[mask]

return Yreduced

def center(self, x):

'center the data using the mean and sigma from training set a'

return (x - self.mu)/self.sigma

@staticmethod

def _get_colinear():

c0 = np.array([

0.19294738, 0.6202667 , 0.45962655, 0.07608613, 0.135818 ,

0.83580842, 0.07218851, 0.48318321, 0.84472463, 0.18348462,

0.81585306, 0.96923926, 0.12835919, 0.35075355, 0.15807861,

0.837437 , 0.10824303, 0.1723387 , 0.43926494, 0.83705486])

c1 = np.array([

-1.17705601, -0.513883 , -0.26614584, 0.88067144, 1.00474954,

-1.1616545 , 0.0266109 , 0.38227157, 1.80489433, 0.21472396,

-1.41920399, -2.08158544, -0.10559009, 1.68999268, 0.34847107,

-0.4685737 , 1.23980423, -0.14638744, -0.35907697, 0.22442616])

c2 = c0 + 2*c1

c3 = -3*c0 + 4*c1

a = np.array([c3, c0, c1, c2]).T

return a

def prctile(x, p = (0.0, 25.0, 50.0, 75.0, 100.0)):

"""

Return the percentiles of *x*. *p* can either be a sequence of

percentile values or a scalar. If *p* is a sequence, the ith

element of the return sequence is the *p*(i)-th percentile of *x*.

If *p* is a scalar, the largest value of *x* less than or equal to

the *p* percentage point in the sequence is returned.

"""

# This implementation derived from scipy.stats.scoreatpercentile

def _interpolate(a, b, fraction):

"""Returns the point at the given fraction between a and b, where

'fraction' must be between 0 and 1.

"""

return a + (b - a)*fraction

scalar = True

if cbook.iterable(p):

scalar = False

per = np.array(p)

values = np.array(x).ravel() # copy

values.sort()

idxs = per /100. * (values.shape[0] - 1)

ai = idxs.astype(np.int)

bi = ai + 1

frac = idxs % 1

# handle cases where attempting to interpolate past last index

cond = bi >= len(values)

if scalar:

if cond:

ai -= 1

bi -= 1

frac += 1

else:

ai[cond] -= 1

bi[cond] -= 1

frac[cond] += 1

return _interpolate(values[ai],values[bi],frac)

def prctile_rank(x, p):

"""

Return the rank for each element in *x*, return the rank

0..len(*p*). e.g., if *p* = (25, 50, 75), the return value will be a

len(*x*) array with values in [0,1,2,3] where 0 indicates the

value is less than the 25th percentile, 1 indicates the value is

>= the 25th and < 50th percentile, ... and 3 indicates the value

is above the 75th percentile cutoff.

*p* is either an array of percentiles in [0..100] or a scalar which

indicates how many quantiles of data you want ranked.

"""

if not cbook.iterable(p):

p = np.arange(100.0/p, 100.0, 100.0/p)

else:

p = np.asarray(p)

if p.max()<=1 or p.min()<0 or p.max()>100:

raise ValueError('percentiles should be in range 0..100, not 0..1')

ptiles = prctile(x, p)

return np.searchsorted(ptiles, x)

def center_matrix(M, dim=0):

"""

Return the matrix *M* with each row having zero mean and unit std.

If *dim* = 1 operate on columns instead of rows. (*dim* is

opposite to the numpy axis kwarg.)

"""

M = np.asarray(M, np.float_)

if dim:

M = (M - M.mean(axis=0)) / M.std(axis=0)

else:

M = (M - M.mean(axis=1)[:,np.newaxis])

M = M / M.std(axis=1)[:,np.newaxis]

return M

def rk4(derivs, y0, t):

"""