from __future__ import (absolute_import, division, print_function,

unicode_literals)

import six

import tempfile

from numpy.testing import assert_allclose, assert_array_equal

import numpy.ma.testutils as matest

import numpy as np

from nose.tools import (assert_equal, assert_almost_equal, assert_not_equal,

assert_true, assert_raises)

import matplotlib.mlab as mlab

import matplotlib.cbook as cbook

from matplotlib.testing.decorators import knownfailureif, CleanupTestCase

try:

from mpl_toolkits.natgrid import _natgrid

HAS_NATGRID = True

except ImportError:

HAS_NATGRID = False

class general_testcase(CleanupTestCase):

def test_colinear_pca(self):

a = mlab.PCA._get_colinear()

pca = mlab.PCA(a)

assert_allclose(pca.fracs[2:], 0., atol=1e-8)

assert_allclose(pca.Y[:, 2:], 0., atol=1e-8)

def test_prctile(self):

# test odd lengths

x = [1, 2, 3]

assert_equal(mlab.prctile(x, 50), np.median(x))

# test even lengths

x = [1, 2, 3, 4]

assert_equal(mlab.prctile(x, 50), np.median(x))

# derived from email sent by jason-sage to MPL-user on 20090914

ob1 = [1, 1, 2, 2, 1, 2, 4, 3, 2, 2, 2, 3,

4, 5, 6, 7, 8, 9, 7, 6, 4, 5, 5]

p = [0, 75, 100]

expected = [1, 5.5, 9]

# test vectorized

actual = mlab.prctile(ob1, p)

assert_allclose(expected, actual)

# test scalar

for pi, expectedi in zip(p, expected):

actuali = mlab.prctile(ob1, pi)

assert_allclose(expectedi, actuali)

def test_norm(self):

np.random.seed(0)

N = 1000

x = np.random.standard_normal(N)

targ = np.linalg.norm(x)

res = mlab._norm(x)

assert_almost_equal(targ, res)

class spacing_testcase(CleanupTestCase):

def test_logspace_tens(self):

xmin = .01

xmax = 1000.

N = 6

res = mlab.logspace(xmin, xmax, N)

targ = np.logspace(np.log10(xmin), np.log10(xmax), N)

assert_allclose(targ, res)

def test_logspace_primes(self):

xmin = .03

xmax = 1313.

N = 7

res = mlab.logspace(xmin, xmax, N)

targ = np.logspace(np.log10(xmin), np.log10(xmax), N)

assert_allclose(targ, res)

def test_logspace_none(self):

xmin = .03

xmax = 1313.

N = 0

res = mlab.logspace(xmin, xmax, N)

targ = np.logspace(np.log10(xmin), np.log10(xmax), N)

assert_array_equal(targ, res)

assert_equal(res.size, 0)

def test_logspace_single(self):

xmin = .03

xmax = 1313.

N = 1

res = mlab.logspace(xmin, xmax, N)

targ = np.logspace(np.log10(xmin), np.log10(xmax), N)

assert_array_equal(targ, res)

assert_equal(res.size, 1)

class stride_testcase(CleanupTestCase):

def get_base(self, x):

y = x

while y.base is not None:

y = y.base

return y

def calc_window_target(self, x, NFFT, noverlap=0):

'''This is an adaptation of the original window extraction

algorithm. This is here to test to make sure the new implementation

has the same result'''

step = NFFT - noverlap

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

n = len(ind)

result = np.zeros((NFFT, n))

# do the ffts of the slices

for i in range(n):

result[:, i] = x[ind[i]:ind[i]+NFFT]

return result

def test_stride_windows_2D_ValueError(self):

x = np.arange(10)[np.newaxis]

assert_raises(ValueError, mlab.stride_windows, x, 5)

def test_stride_windows_0D_ValueError(self):

x = np.array(0)

assert_raises(ValueError, mlab.stride_windows, x, 5)

def test_stride_windows_noverlap_gt_n_ValueError(self):

x = np.arange(10)

assert_raises(ValueError, mlab.stride_windows, x, 2, 3)

def test_stride_windows_noverlap_eq_n_ValueError(self):

x = np.arange(10)

assert_raises(ValueError, mlab.stride_windows, x, 2, 2)

def test_stride_windows_n_gt_lenx_ValueError(self):

x = np.arange(10)

assert_raises(ValueError, mlab.stride_windows, x, 11)

def test_stride_windows_n_lt_1_ValueError(self):

x = np.arange(10)

assert_raises(ValueError, mlab.stride_windows, x, 0)

def test_stride_repeat_2D_ValueError(self):

x = np.arange(10)[np.newaxis]

assert_raises(ValueError, mlab.stride_repeat, x, 5)

def test_stride_repeat_axis_lt_0_ValueError(self):

x = np.array(0)

assert_raises(ValueError, mlab.stride_repeat, x, 5, axis=-1)

def test_stride_repeat_axis_gt_1_ValueError(self):

x = np.array(0)

assert_raises(ValueError, mlab.stride_repeat, x, 5, axis=2)

def test_stride_repeat_n_lt_1_ValueError(self):

x = np.arange(10)

assert_raises(ValueError, mlab.stride_repeat, x, 0)

def test_stride_repeat_n1_axis0(self):

x = np.arange(10)

y = mlab.stride_repeat(x, 1)

assert_equal((1, ) + x.shape, y.shape)

assert_array_equal(x, y.flat)

assert_true(self.get_base(y) is x)

def test_stride_repeat_n1_axis1(self):

x = np.arange(10)

y = mlab.stride_repeat(x, 1, axis=1)

assert_equal(x.shape + (1, ), y.shape)

assert_array_equal(x, y.flat)

assert_true(self.get_base(y) is x)

def test_stride_repeat_n5_axis0(self):

x = np.arange(10)

y = mlab.stride_repeat(x, 5)

yr = np.repeat(x[np.newaxis], 5, axis=0)

assert_equal(yr.shape, y.shape)

assert_array_equal(yr, y)

assert_equal((5, ) + x.shape, y.shape)

assert_true(self.get_base(y) is x)

def test_stride_repeat_n5_axis1(self):

x = np.arange(10)

y = mlab.stride_repeat(x, 5, axis=1)

yr = np.repeat(x[np.newaxis], 5, axis=0).T

assert_equal(yr.shape, y.shape)

assert_array_equal(yr, y)

assert_equal(x.shape + (5, ), y.shape)

assert_true(self.get_base(y) is x)

def test_stride_windows_n1_noverlap0_axis0(self):

x = np.arange(10)

y = mlab.stride_windows(x, 1)

yt = self.calc_window_target(x, 1)

assert_equal(yt.shape, y.shape)

assert_array_equal(yt, y)

assert_equal((1, ) + x.shape, y.shape)

assert_true(self.get_base(y) is x)

def test_stride_windows_n1_noverlap0_axis1(self):

x = np.arange(10)

y = mlab.stride_windows(x, 1, axis=1)

yt = self.calc_window_target(x, 1).T

assert_equal(yt.shape, y.shape)

assert_array_equal(yt, y)

assert_equal(x.shape + (1, ), y.shape)

assert_true(self.get_base(y) is x)

def test_stride_windows_n5_noverlap0_axis0(self):

x = np.arange(100)

y = mlab.stride_windows(x, 5)

yt = self.calc_window_target(x, 5)

assert_equal(yt.shape, y.shape)

assert_array_equal(yt, y)

assert_equal((5, 20), y.shape)

assert_true(self.get_base(y) is x)

def test_stride_windows_n5_noverlap0_axis1(self):

x = np.arange(100)

y = mlab.stride_windows(x, 5, axis=1)

yt = self.calc_window_target(x, 5).T

assert_equal(yt.shape, y.shape)

assert_array_equal(yt, y)

assert_equal((20, 5), y.shape)

assert_true(self.get_base(y) is x)

def test_stride_windows_n15_noverlap2_axis0(self):

x = np.arange(100)

y = mlab.stride_windows(x, 15, 2)

yt = self.calc_window_target(x, 15, 2)

assert_equal(yt.shape, y.shape)

assert_array_equal(yt, y)

assert_equal((15, 7), y.shape)

assert_true(self.get_base(y) is x)

def test_stride_windows_n15_noverlap2_axis1(self):

x = np.arange(100)

y = mlab.stride_windows(x, 15, 2, axis=1)

yt = self.calc_window_target(x, 15, 2).T

assert_equal(yt.shape, y.shape)

assert_array_equal(yt, y)

assert_equal((7, 15), y.shape)

assert_true(self.get_base(y) is x)

def test_stride_windows_n13_noverlapn3_axis0(self):

x = np.arange(100)

y = mlab.stride_windows(x, 13, -3)

yt = self.calc_window_target(x, 13, -3)

assert_equal(yt.shape, y.shape)

assert_array_equal(yt, y)

assert_equal((13, 6), y.shape)

assert_true(self.get_base(y) is x)

def test_stride_windows_n13_noverlapn3_axis1(self):

x = np.arange(100)

y = mlab.stride_windows(x, 13, -3, axis=1)

yt = self.calc_window_target(x, 13, -3).T

assert_equal(yt.shape, y.shape)

assert_array_equal(yt, y)

assert_equal((6, 13), y.shape)

assert_true(self.get_base(y) is x)

def test_stride_windows_n32_noverlap0_axis0_unflatten(self):

n = 32

x = np.arange(n)[np.newaxis]

x1 = np.tile(x, (21, 1))

x2 = x1.flatten()

y = mlab.stride_windows(x2, n)

assert_equal(y.shape, x1.T.shape)

assert_array_equal(y, x1.T)

def test_stride_windows_n32_noverlap0_axis1_unflatten(self):

n = 32

x = np.arange(n)[np.newaxis]

x1 = np.tile(x, (21, 1))

x2 = x1.flatten()

y = mlab.stride_windows(x2, n, axis=1)

assert_equal(y.shape, x1.shape)

assert_array_equal(y, x1)

def test_stride_ensure_integer_type(self):

N = 100

x = np.empty(N + 20, dtype='>f4')

x.fill(np.NaN)

y = x[10:-10]

y.fill(0.3)

# previous to #3845 lead to corrupt access

y_strided = mlab.stride_windows(y, n=33, noverlap=0.6)

assert_array_equal(y_strided, 0.3)

# previous to #3845 lead to corrupt access

y_strided = mlab.stride_windows(y, n=33.3, noverlap=0)

assert_array_equal(y_strided, 0.3)

# even previous to #3845 could not find any problematic

# configuration however, let's be sure it's not accidentally

# introduced

y_strided = mlab.stride_repeat(y, n=33.815)

assert_array_equal(y_strided, 0.3)

class csv_testcase(CleanupTestCase):

def setUp(self):

if six.PY3:

self.fd = tempfile.TemporaryFile(suffix='csv', mode="w+",

newline='')

else:

self.fd = tempfile.TemporaryFile(suffix='csv', mode="wb+")

def tearDown(self):

self.fd.close()

def test_recarray_csv_roundtrip(self):

expected = np.recarray((99,),

[(str('x'), np.float),

(str('y'), np.float),

(str('t'), np.float)])

# initialising all values: uninitialised memory sometimes produces

# floats that do not round-trip to string and back.

expected['x'][:] = np.linspace(-1e9, -1, 99)

expected['y'][:] = np.linspace(1, 1e9, 99)

expected['t'][:] = np.linspace(0, 0.01, 99)

mlab.rec2csv(expected, self.fd)

self.fd.seek(0)

actual = mlab.csv2rec(self.fd)

assert_allclose(expected['x'], actual['x'])

assert_allclose(expected['y'], actual['y'])

assert_allclose(expected['t'], actual['t'])

def test_rec2csv_bad_shape_ValueError(self):

bad = np.recarray((99, 4), [(str('x'), np.float),

(str('y'), np.float)])

# the bad recarray should trigger a ValueError for having ndim > 1.

assert_raises(ValueError, mlab.rec2csv, bad, self.fd)

def test_csv2rec_names_with_comments(self):

self.fd.write('# comment\n1,2,3\n4,5,6\n')

self.fd.seek(0)

array = mlab.csv2rec(self.fd, names='a,b,c')

assert len(array) == 2

assert len(array.dtype) == 3

class window_testcase(CleanupTestCase):

def setUp(self):

np.random.seed(0)

self.n = 1000

self.x = np.arange(0., self.n)

self.sig_rand = np.random.standard_normal(self.n) + 100.

self.sig_ones = np.ones_like(self.x)

self.sig_slope = np.linspace(-10., 90., self.n)

def check_window_apply_repeat(self, x, window, NFFT, noverlap):

'''This is an adaptation of the original window application

algorithm. This is here to test to make sure the new implementation

has the same result'''

step = NFFT - noverlap

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

n = len(ind)

result = np.zeros((NFFT, n))

if cbook.iterable(window):

windowVals = window

else:

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

# do the ffts of the slices

for i in range(n):

result[:, i] = windowVals * x[ind[i]:ind[i]+NFFT]

return result

def test_window_none_rand(self):

res = mlab.window_none(self.sig_ones)

assert_array_equal(res, self.sig_ones)

def test_window_none_ones(self):

res = mlab.window_none(self.sig_rand)

assert_array_equal(res, self.sig_rand)

def test_window_hanning_rand(self):

targ = np.hanning(len(self.sig_rand)) * self.sig_rand

res = mlab.window_hanning(self.sig_rand)

assert_allclose(targ, res, atol=1e-06)

def test_window_hanning_ones(self):

targ = np.hanning(len(self.sig_ones))

res = mlab.window_hanning(self.sig_ones)

assert_allclose(targ, res, atol=1e-06)

def test_apply_window_1D_axis1_ValueError(self):

x = self.sig_rand

window = mlab.window_hanning

assert_raises(ValueError, mlab.apply_window, x, window, axis=1,

return_window=False)

def test_apply_window_1D_els_wrongsize_ValueError(self):

x = self.sig_rand

window = mlab.window_hanning(np.ones(x.shape[0]-1))

assert_raises(ValueError, mlab.apply_window, x, window)

def test_apply_window_0D_ValueError(self):

x = np.array(0)

window = mlab.window_hanning

assert_raises(ValueError, mlab.apply_window, x, window, axis=1,

return_window=False)

def test_apply_window_3D_ValueError(self):

x = self.sig_rand[np.newaxis][np.newaxis]

window = mlab.window_hanning

assert_raises(ValueError, mlab.apply_window, x, window, axis=1,

return_window=False)

def test_apply_window_hanning_1D(self):

x = self.sig_rand

window = mlab.window_hanning

window1 = mlab.window_hanning(np.ones(x.shape[0]))

y, window2 = mlab.apply_window(x, window, return_window=True)

yt = window(x)

assert_equal(yt.shape, y.shape)

assert_equal(x.shape, y.shape)

assert_allclose(yt, y, atol=1e-06)

assert_array_equal(window1, window2)

def test_apply_window_hanning_1D_axis0(self):

x = self.sig_rand

window = mlab.window_hanning

y = mlab.apply_window(x, window, axis=0, return_window=False)

yt = window(x)

assert_equal(yt.shape, y.shape)

assert_equal(x.shape, y.shape)

assert_allclose(yt, y, atol=1e-06)

def test_apply_window_hanning_els_1D_axis0(self):

x = self.sig_rand

window = mlab.window_hanning(np.ones(x.shape[0]))

window1 = mlab.window_hanning

y = mlab.apply_window(x, window, axis=0, return_window=False)

yt = window1(x)

assert_equal(yt.shape, y.shape)

assert_equal(x.shape, y.shape)

assert_allclose(yt, y, atol=1e-06)

def test_apply_window_hanning_2D_axis0(self):

x = np.random.standard_normal([1000, 10]) + 100.

window = mlab.window_hanning

y = mlab.apply_window(x, window, axis=0, return_window=False)

yt = np.zeros_like(x)

for i in range(x.shape[1]):

yt[:, i] = window(x[:, i])

assert_equal(yt.shape, y.shape)

assert_equal(x.shape, y.shape)

assert_allclose(yt, y, atol=1e-06)

def test_apply_window_hanning_els1_2D_axis0(self):

x = np.random.standard_normal([1000, 10]) + 100.

window = mlab.window_hanning(np.ones(x.shape[0]))

window1 = mlab.window_hanning

y = mlab.apply_window(x, window, axis=0, return_window=False)

yt = np.zeros_like(x)

for i in range(x.shape[1]):

yt[:, i] = window1(x[:, i])

assert_equal(yt.shape, y.shape)

assert_equal(x.shape, y.shape)

assert_allclose(yt, y, atol=1e-06)

def test_apply_window_hanning_els2_2D_axis0(self):

x = np.random.standard_normal([1000, 10]) + 100.

window = mlab.window_hanning

window1 = mlab.window_hanning(np.ones(x.shape[0]))

y, window2 = mlab.apply_window(x, window, axis=0, return_window=True)

yt = np.zeros_like(x)

for i in range(x.shape[1]):

yt[:, i] = window1*x[:, i]

assert_equal(yt.shape, y.shape)

assert_equal(x.shape, y.shape)

assert_allclose(yt, y, atol=1e-06)

assert_array_equal(window1, window2)

def test_apply_window_hanning_els3_2D_axis0(self):

x = np.random.standard_normal([1000, 10]) + 100.

window = mlab.window_hanning

window1 = mlab.window_hanning(np.ones(x.shape[0]))

y, window2 = mlab.apply_window(x, window, axis=0, return_window=True)

yt = mlab.apply_window(x, window1, axis=0, return_window=False)

assert_equal(yt.shape, y.shape)

assert_equal(x.shape, y.shape)

assert_allclose(yt, y, atol=1e-06)

assert_array_equal(window1, window2)

def test_apply_window_hanning_2D_axis1(self):

x = np.random.standard_normal([10, 1000]) + 100.

window = mlab.window_hanning

y = mlab.apply_window(x, window, axis=1, return_window=False)

yt = np.zeros_like(x)

for i in range(x.shape[0]):

yt[i, :] = window(x[i, :])

assert_equal(yt.shape, y.shape)

assert_equal(x.shape, y.shape)

assert_allclose(yt, y, atol=1e-06)

def test_apply_window_hanning_2D__els1_axis1(self):

x = np.random.standard_normal([10, 1000]) + 100.

window = mlab.window_hanning(np.ones(x.shape[1]))

window1 = mlab.window_hanning

y = mlab.apply_window(x, window, axis=1, return_window=False)

yt = np.zeros_like(x)

for i in range(x.shape[0]):

yt[i, :] = window1(x[i, :])

assert_equal(yt.shape, y.shape)

assert_equal(x.shape, y.shape)

assert_allclose(yt, y, atol=1e-06)

def test_apply_window_hanning_2D_els2_axis1(self):

x = np.random.standard_normal([10, 1000]) + 100.

window = mlab.window_hanning

window1 = mlab.window_hanning(np.ones(x.shape[1]))

y, window2 = mlab.apply_window(x, window, axis=1, return_window=True)

yt = np.zeros_like(x)

for i in range(x.shape[0]):

yt[i, :] = window1 * x[i, :]

assert_equal(yt.shape, y.shape)

assert_equal(x.shape, y.shape)

assert_allclose(yt, y, atol=1e-06)

assert_array_equal(window1, window2)

def test_apply_window_hanning_2D_els3_axis1(self):

x = np.random.standard_normal([10, 1000]) + 100.

window = mlab.window_hanning

window1 = mlab.window_hanning(np.ones(x.shape[1]))

y = mlab.apply_window(x, window, axis=1, return_window=False)

yt = mlab.apply_window(x, window1, axis=1, return_window=False)

assert_equal(yt.shape, y.shape)

assert_equal(x.shape, y.shape)

assert_allclose(yt, y, atol=1e-06)

def test_apply_window_stride_windows_hanning_2D_n13_noverlapn3_axis0(self):

x = self.sig_rand

window = mlab.window_hanning

yi = mlab.stride_windows(x, n=13, noverlap=2, axis=0)

y = mlab.apply_window(yi, window, axis=0, return_window=False)

yt = self.check_window_apply_repeat(x, window, 13, 2)

assert_equal(yt.shape, y.shape)

assert_not_equal(x.shape, y.shape)

assert_allclose(yt, y, atol=1e-06)

def test_apply_window_hanning_2D_stack_axis1(self):

ydata = np.arange(32)

ydata1 = ydata+5

ydata2 = ydata+3.3

ycontrol1 = mlab.apply_window(ydata1, mlab.window_hanning)

ycontrol2 = mlab.window_hanning(ydata2)

ydata = np.vstack([ydata1, ydata2])

ycontrol = np.vstack([ycontrol1, ycontrol2])

ydata = np.tile(ydata, (20, 1))

ycontrol = np.tile(ycontrol, (20, 1))

result = mlab.apply_window(ydata, mlab.window_hanning, axis=1,

return_window=False)

assert_allclose(ycontrol, result, atol=1e-08)

def test_apply_window_hanning_2D_stack_windows_axis1(self):

ydata = np.arange(32)

ydata1 = ydata+5

ydata2 = ydata+3.3

ycontrol1 = mlab.apply_window(ydata1, mlab.window_hanning)

ycontrol2 = mlab.window_hanning(ydata2)

ydata = np.vstack([ydata1, ydata2])

ycontrol = np.vstack([ycontrol1, ycontrol2])

ydata = np.tile(ydata, (20, 1))

ycontrol = np.tile(ycontrol, (20, 1))

result = mlab.apply_window(ydata, mlab.window_hanning, axis=1,

return_window=False)

assert_allclose(ycontrol, result, atol=1e-08)

def test_apply_window_hanning_2D_stack_windows_axis1_unflatten(self):

n = 32

ydata = np.arange(n)

ydata1 = ydata+5

ydata2 = ydata+3.3

ycontrol1 = mlab.apply_window(ydata1, mlab.window_hanning)

ycontrol2 = mlab.window_hanning(ydata2)

ydata = np.vstack([ydata1, ydata2])

ycontrol = np.vstack([ycontrol1, ycontrol2])

ydata = np.tile(ydata, (20, 1))

ycontrol = np.tile(ycontrol, (20, 1))

ydata = ydata.flatten()

ydata1 = mlab.stride_windows(ydata, 32, noverlap=0, axis=0)

result = mlab.apply_window(ydata1, mlab.window_hanning, axis=0,

return_window=False)

assert_allclose(ycontrol.T, result, atol=1e-08)

class detrend_testcase(CleanupTestCase):

def setUp(self):

np.random.seed(0)

n = 1000

x = np.linspace(0., 100, n)

self.sig_zeros = np.zeros(n)

self.sig_off = self.sig_zeros + 100.

self.sig_slope = np.linspace(-10., 90., n)

self.sig_slope_mean = x - x.mean()

sig_rand = np.random.standard_normal(n)

sig_sin = np.sin(x*2*np.pi/(n/100))

sig_rand -= sig_rand.mean()

sig_sin -= sig_sin.mean()

self.sig_base = sig_rand + sig_sin

self.atol = 1e-08

def test_detrend_none_0D_zeros(self):

input = 0.

targ = input

res = mlab.detrend_none(input)

assert_equal(input, targ)

def test_detrend_none_0D_zeros_axis1(self):

input = 0.

targ = input

res = mlab.detrend_none(input, axis=1)

assert_equal(input, targ)

def test_detrend_str_none_0D_zeros(self):

input = 0.

targ = input

res = mlab.detrend(input, key='none')

assert_equal(input, targ)

def test_detrend_detrend_none_0D_zeros(self):

input = 0.

targ = input

res = mlab.detrend(input, key=mlab.detrend_none)

assert_equal(input, targ)

def test_detrend_none_0D_off(self):

input = 5.5

targ = input

res = mlab.detrend_none(input)

assert_equal(input, targ)

def test_detrend_none_1D_off(self):

input = self.sig_off

targ = input

res = mlab.detrend_none(input)

assert_array_equal(res, targ)

def test_detrend_none_1D_slope(self):

input = self.sig_slope

targ = input

res = mlab.detrend_none(input)

assert_array_equal(res, targ)

def test_detrend_none_1D_base(self):

input = self.sig_base

targ = input

res = mlab.detrend_none(input)

assert_array_equal(res, targ)

def test_detrend_none_1D_base_slope_off_list(self):

input = self.sig_base + self.sig_slope + self.sig_off

targ = input.tolist()

res = mlab.detrend_none(input.tolist())

assert_equal(res, targ)

def test_detrend_none_2D(self):

arri = [self.sig_base,

self.sig_base + self.sig_off,

self.sig_base + self.sig_slope,

self.sig_base + self.sig_off + self.sig_slope]

input = np.vstack(arri)

targ = input

res = mlab.detrend_none(input)

assert_array_equal(res, targ)

def test_detrend_none_2D_T(self):

arri = [self.sig_base,

self.sig_base + self.sig_off,

self.sig_base + self.sig_slope,

self.sig_base + self.sig_off + self.sig_slope]

input = np.vstack(arri)

targ = input

res = mlab.detrend_none(input.T)

assert_array_equal(res.T, targ)

def test_detrend_mean_0D_zeros(self):

input = 0.

targ = 0.

res = mlab.detrend_mean(input)

assert_almost_equal(res, targ)

def test_detrend_str_mean_0D_zeros(self):

input = 0.

targ = 0.

res = mlab.detrend(input, key='mean')

assert_almost_equal(res, targ)

def test_detrend_detrend_mean_0D_zeros(self):

input = 0.

targ = 0.

res = mlab.detrend(input, key=mlab.detrend_mean)

assert_almost_equal(res, targ)

def test_detrend_mean_0D_off(self):

input = 5.5

targ = 0.

res = mlab.detrend_mean(input)

assert_almost_equal(res, targ)

def test_detrend_str_mean_0D_off(self):

input = 5.5

targ = 0.

res = mlab.detrend(input, key='mean')

assert_almost_equal(res, targ)

def test_detrend_detrend_mean_0D_off(self):

input = 5.5

targ = 0.

res = mlab.detrend(input, key=mlab.detrend_mean)

assert_almost_equal(res, targ)

def test_detrend_mean_1D_zeros(self):

input = self.sig_zeros

targ = self.sig_zeros

res = mlab.detrend_mean(input)

assert_allclose(res, targ, atol=self.atol)

def test_detrend_mean_1D_base(self):

input = self.sig_base

targ = self.sig_base

res = mlab.detrend_mean(input)

assert_allclose(res, targ, atol=self.atol)

def test_detrend_mean_1D_base_off(self):

input = self.sig_base + self.sig_off

targ = self.sig_base

res = mlab.detrend_mean(input)

assert_allclose(res, targ, atol=self.atol)

def test_detrend_mean_1D_base_slope(self):

input = self.sig_base + self.sig_slope

targ = self.sig_base + self.sig_slope_mean

res = mlab.detrend_mean(input)

assert_allclose(res, targ, atol=self.atol)

def test_detrend_mean_1D_base_slope_off(self):

input = self.sig_base + self.sig_slope + self.sig_off

targ = self.sig_base + self.sig_slope_mean

res = mlab.detrend_mean(input)

assert_allclose(res, targ, atol=1e-08)

def test_detrend_mean_1D_base_slope_off_axis0(self):

input = self.sig_base + self.sig_slope + self.sig_off

targ = self.sig_base + self.sig_slope_mean

res = mlab.detrend_mean(input, axis=0)

assert_allclose(res, targ, atol=1e-08)

def test_detrend_mean_1D_base_slope_off_list(self):

input = self.sig_base + self.sig_slope + self.sig_off

targ = self.sig_base + self.sig_slope_mean

res = mlab.detrend_mean(input.tolist())

assert_allclose(res, targ, atol=1e-08)

def test_detrend_mean_1D_base_slope_off_list_axis0(self):

input = self.sig_base + self.sig_slope + self.sig_off

targ = self.sig_base + self.sig_slope_mean

res = mlab.detrend_mean(input.tolist(), axis=0)

assert_allclose(res, targ, atol=1e-08)

def test_demean_0D_off(self):

input = 5.5

targ = 0.

res = mlab.demean(input, axis=None)

assert_almost_equal(res, targ)

def test_demean_1D_base_slope_off(self):

input = self.sig_base + self.sig_slope + self.sig_off

targ = self.sig_base + self.sig_slope_mean

res = mlab.demean(input)

assert_allclose(res, targ, atol=1e-08)

def test_demean_1D_base_slope_off_axis0(self):

input = self.sig_base + self.sig_slope + self.sig_off

targ = self.sig_base + self.sig_slope_mean

res = mlab.demean(input, axis=0)

assert_allclose(res, targ, atol=1e-08)

def test_demean_1D_base_slope_off_list(self):

input = self.sig_base + self.sig_slope + self.sig_off

targ = self.sig_base + self.sig_slope_mean

res = mlab.demean(input.tolist())

assert_allclose(res, targ, atol=1e-08)

def test_detrend_mean_2D_default(self):

arri = [self.sig_off,

self.sig_base + self.sig_off]

arrt = [self.sig_zeros,

self.sig_base]

input = np.vstack(arri)

targ = np.vstack(arrt)

res = mlab.detrend_mean(input)

assert_allclose(res, targ, atol=1e-08)

def test_detrend_mean_2D_none(self):

arri = [self.sig_off,

self.sig_base + self.sig_off]

arrt = [self.sig_zeros,

self.sig_base]

input = np.vstack(arri)

targ = np.vstack(arrt)

res = mlab.detrend_mean(input, axis=None)

assert_allclose(res, targ,

atol=1e-08)

def test_detrend_mean_2D_none_T(self):

arri = [self.sig_off,

self.sig_base + self.sig_off]

arrt = [self.sig_zeros,

self.sig_base]

input = np.vstack(arri).T

targ = np.vstack(arrt)

res = mlab.detrend_mean(input, axis=None)

assert_allclose(res.T, targ,

atol=1e-08)

def test_detrend_mean_2D_axis0(self):

arri = [self.sig_base,

self.sig_base + self.sig_off,

self.sig_base + self.sig_slope,

self.sig_base + self.sig_off + self.sig_slope]

arrt = [self.sig_base,

self.sig_base,

self.sig_base + self.sig_slope_mean,

self.sig_base + self.sig_slope_mean]

input = np.vstack(arri).T

targ = np.vstack(arrt).T

res = mlab.detrend_mean(input, axis=0)

assert_allclose(res, targ,

atol=1e-08)

def test_detrend_mean_2D_axis1(self):

arri = [self.sig_base,

self.sig_base + self.sig_off,

self.sig_base + self.sig_slope,

self.sig_base + self.sig_off + self.sig_slope]

arrt = [self.sig_base,

self.sig_base,

self.sig_base + self.sig_slope_mean,

self.sig_base + self.sig_slope_mean]

input = np.vstack(arri)

targ = np.vstack(arrt)

res = mlab.detrend_mean(input, axis=1)

assert_allclose(res, targ,

atol=1e-08)

def test_detrend_mean_2D_axism1(self):

arri = [self.sig_base,

self.sig_base + self.sig_off,

self.sig_base + self.sig_slope,

self.sig_base + self.sig_off + self.sig_slope]

arrt = [self.sig_base,

self.sig_base,

self.sig_base + self.sig_slope_mean,

self.sig_base + self.sig_slope_mean]

input = np.vstack(arri)

targ = np.vstack(arrt)

res = mlab.detrend_mean(input, axis=-1)

assert_allclose(res, targ,

atol=1e-08)

def test_detrend_mean_2D_none(self):

arri = [self.sig_off,

self.sig_base + self.sig_off]

arrt = [self.sig_zeros,

self.sig_base]

input = np.vstack(arri)

targ = np.vstack(arrt)

res = mlab.detrend_mean(input, axis=None)

assert_allclose(res, targ,

atol=1e-08)

def test_detrend_mean_2D_none_T(self):

arri = [self.sig_off,

self.sig_base + self.sig_off]

arrt = [self.sig_zeros,

self.sig_base]

input = np.vstack(arri).T

targ = np.vstack(arrt)

res = mlab.detrend_mean(input, axis=None)

assert_allclose(res.T, targ,

atol=1e-08)

def test_detrend_mean_2D_axis0(self):

arri = [self.sig_base,

self.sig_base + self.sig_off,

self.sig_base + self.sig_slope,

self.sig_base + self.sig_off + self.sig_slope]

arrt = [self.sig_base,

self.sig_base,

self.sig_base + self.sig_slope_mean,

self.sig_base + self.sig_slope_mean]

input = np.vstack(arri).T

targ = np.vstack(arrt).T

res = mlab.detrend_mean(input, axis=0)

assert_allclose(res, targ,

atol=1e-08)

def test_detrend_mean_2D_axis1(self):

arri = [self.sig_base,

self.sig_base + self.sig_off,

self.sig_base + self.sig_slope,

self.sig_base + self.sig_off + self.sig_slope]

arrt = [self.sig_base,

self.sig_base,

self.sig_base + self.sig_slope_mean,

self.sig_base + self.sig_slope_mean]

input = np.vstack(arri)

targ = np.vstack(arrt)

res = mlab.detrend_mean(input, axis=1)

assert_allclose(res, targ,

atol=1e-08)

def test_detrend_mean_2D_axism1(self):

arri = [self.sig_base,

self.sig_base + self.sig_off,

self.sig_base + self.sig_slope,

self.sig_base + self.sig_off + self.sig_slope]

arrt = [self.sig_base,

self.sig_base,

self.sig_base + self.sig_slope_mean,

self.sig_base + self.sig_slope_mean]

input = np.vstack(arri)

targ = np.vstack(arrt)

res = mlab.detrend_mean(input, axis=-1)

assert_allclose(res, targ,

atol=1e-08)

def test_detrend_2D_default(self):

arri = [self.sig_off,

self.sig_base + self.sig_off]

arrt = [self.sig_zeros,

self.sig_base]

input = np.vstack(arri)

targ = np.vstack(arrt)

res = mlab.detrend(input)

assert_allclose(res, targ, atol=1e-08)

def test_detrend_2D_none(self):

arri = [self.sig_off,

self.sig_base + self.sig_off]

arrt = [self.sig_zeros,

self.sig_base]

input = np.vstack(arri)

targ = np.vstack(arrt)

res = mlab.detrend(input, axis=None)

assert_allclose(res, targ, atol=1e-08)

def test_detrend_str_mean_2D_axis0(self):

arri = [self.sig_base,

self.sig_base + self.sig_off,

self.sig_base + self.sig_slope,

self.sig_base + self.sig_off + self.sig_slope]

arrt = [self.sig_base,

self.sig_base,

self.sig_base + self.sig_slope_mean,

self.sig_base + self.sig_slope_mean]

input = np.vstack(arri).T

targ = np.vstack(arrt).T

res = mlab.detrend(input, key='mean', axis=0)

assert_allclose(res, targ,

atol=1e-08)

def test_detrend_str_constant_2D_none_T(self):

arri = [self.sig_off,

self.sig_base + self.sig_off]

arrt = [self.sig_zeros,

self.sig_base]

input = np.vstack(arri).T

targ = np.vstack(arrt)

res = mlab.detrend(input, key='constant', axis=None)

assert_allclose(res.T, targ,

atol=1e-08)

def test_detrend_str_default_2D_axis1(self):

arri = [self.sig_base,

self.sig_base + self.sig_off,

self.sig_base + self.sig_slope,

self.sig_base + self.sig_off + self.sig_slope]