May 23, 2013 · Aug 26, 2013 · Aug 26, 2013 · Aug 26, 2013 · Aug 26, 2013 · Aug 27, 2013
diff --git a/lib/matplotlib/mlab.py b/lib/matplotlib/mlab.py
            numFreqs = pad_to//2 + 1
        scaling_factor = 2.

    result = stride_windows(x, NFFT, noverlap)
    result = stride_windows(x, NFFT, noverlap, axis=0)
    result = detrend(result, detrend_func, axis=0)
    result, windowVals = apply_window(result, window, axis=0,
                                      return_window=True)
    result = detrend(result, detrend_func, axis=0)
    result = np.fft.fft(result, n=pad_to, axis=0)[:numFreqs, :]
    freqs = np.fft.fftfreq(pad_to, 1/Fs)[:numFreqs]

diff --git a/lib/matplotlib/tests/test_mlab.py b/lib/matplotlib/tests/test_mlab.py
        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)


 class csv_testcase(CleanupTestCase):
    def setUp(self):
        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):
        assert_equal(spec.shape, freqs.shape)
        self.check_freqs(spec, freqs, fsp, self.fstims)

    def test_psd_detrend_mean_func_offset(self):
        if self.NFFT_density is None:
            return
        freqs = self.freqs_density
        ydata = np.zeros(self.NFFT_density)
        ydata1 = ydata+5
        ydata2 = ydata+3.3
        ydata = np.vstack([ydata1, ydata2])
        ydata = np.tile(ydata, (20, 1))
        ydatab = ydata.T.flatten()
        ydata = ydata.flatten()
        ycontrol = np.zeros_like(ydata)
        spec_g, fsp_g = mlab.psd(x=ydata,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=0,
                                 sides=self.sides,
                                 detrend=mlab.detrend_mean)
        spec_b, fsp_b = mlab.psd(x=ydatab,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=0,
                                 sides=self.sides,
                                 detrend=mlab.detrend_mean)
        spec_c, fsp_c = mlab.psd(x=ycontrol,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=0,
                                 sides=self.sides)
        assert_array_equal(fsp_g, fsp_c)
        assert_array_equal(fsp_b, fsp_c)
        assert_allclose(spec_g, spec_c, atol=1e-08)
        # these should not be almost equal
        assert_raises(AssertionError,
                      assert_allclose, spec_b, spec_c, atol=1e-08)

    def test_psd_detrend_mean_str_offset(self):
        if self.NFFT_density is None:
            return
        freqs = self.freqs_density
        ydata = np.zeros(self.NFFT_density)
        ydata1 = ydata+5
        ydata2 = ydata+3.3
        ydata = np.vstack([ydata1, ydata2])
        ydata = np.tile(ydata, (20, 1))
        ydatab = ydata.T.flatten()
        ydata = ydata.flatten()
        ycontrol = np.zeros_like(ydata)
        spec_g, fsp_g = mlab.psd(x=ydata,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=0,
                                 sides=self.sides,
                                 detrend='mean')
        spec_b, fsp_b = mlab.psd(x=ydatab,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=0,
                                 sides=self.sides,
                                 detrend='mean')
        spec_c, fsp_c = mlab.psd(x=ycontrol,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=0,
                                 sides=self.sides)
        assert_array_equal(fsp_g, fsp_c)
        assert_array_equal(fsp_b, fsp_c)
        assert_allclose(spec_g, spec_c, atol=1e-08)
        # these should not be almost equal
        assert_raises(AssertionError,
                      assert_allclose, spec_b, spec_c, atol=1e-08)

    def test_psd_detrend_linear_func_trend(self):
        if self.NFFT_density is None:
            return
        freqs = self.freqs_density
        ydata = np.arange(self.NFFT_density)
        ydata1 = ydata+5
        ydata2 = ydata+3.3
        ydata = np.vstack([ydata1, ydata2])
        ydata = np.tile(ydata, (20, 1))
        ydatab = ydata.T.flatten()
        ydata = ydata.flatten()
        ycontrol = np.zeros_like(ydata)
        spec_g, fsp_g = mlab.psd(x=ydata,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=0,
                                 sides=self.sides,
                                 detrend=mlab.detrend_linear)
        spec_b, fsp_b = mlab.psd(x=ydatab,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=0,
                                 sides=self.sides,
                                 detrend=mlab.detrend_linear)
        spec_c, fsp_c = mlab.psd(x=ycontrol,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=0,
                                 sides=self.sides)
        assert_array_equal(fsp_g, fsp_c)
        assert_array_equal(fsp_b, fsp_c)
        assert_allclose(spec_g, spec_c, atol=1e-08)
        # these should not be almost equal
        assert_raises(AssertionError,
                      assert_allclose, spec_b, spec_c, atol=1e-08)

    def test_psd_detrend_linear_str_trend(self):
        if self.NFFT_density is None:
            return
        freqs = self.freqs_density
        ydata = np.arange(self.NFFT_density)
        ydata1 = ydata+5
        ydata2 = ydata+3.3
        ydata = np.vstack([ydata1, ydata2])
        ydata = np.tile(ydata, (20, 1))
        ydatab = ydata.T.flatten()
        ydata = ydata.flatten()
        ycontrol = np.zeros_like(ydata)
        spec_g, fsp_g = mlab.psd(x=ydata,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=0,
                                 sides=self.sides,
                                 detrend='linear')
        spec_b, fsp_b = mlab.psd(x=ydatab,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=0,
                                 sides=self.sides,
                                 detrend='linear')
        spec_c, fsp_c = mlab.psd(x=ycontrol,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=0,
                                 sides=self.sides)
        assert_array_equal(fsp_g, fsp_c)
        assert_array_equal(fsp_b, fsp_c)
        assert_allclose(spec_g, spec_c, atol=1e-08)
        # these should not be almost equal
        assert_raises(AssertionError,
                      assert_allclose, spec_b, spec_c, atol=1e-08)

    def test_psd_window_hanning(self):
        if self.NFFT_density is None:
            return
        freqs = self.freqs_density
        ydata = np.arange(self.NFFT_density)
        ydata1 = ydata+5
        ydata2 = ydata+3.3
        ycontrol1, windowVals = mlab.apply_window(ydata1,
                                                  mlab.window_hanning,
                                                  return_window=True)
        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))
        ydatab = ydata.T.flatten()
        ydataf = ydata.flatten()
        ycontrol = ycontrol.flatten()
        spec_g, fsp_g = mlab.psd(x=ydataf,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=0,
                                 sides=self.sides,
                                 window=mlab.window_hanning)
        spec_b, fsp_b = mlab.psd(x=ydatab,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=0,
                                 sides=self.sides,
                                 window=mlab.window_hanning)
        spec_c, fsp_c = mlab.psd(x=ycontrol,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=0,
                                 sides=self.sides,
                                 window=mlab.window_none)
        spec_c *= len(ycontrol1)/(np.abs(windowVals)**2).sum()
        assert_array_equal(fsp_g, fsp_c)
        assert_array_equal(fsp_b, fsp_c)
        assert_allclose(spec_g, spec_c, atol=1e-08)
        # these should not be almost equal
        assert_raises(AssertionError,
                      assert_allclose, spec_b, spec_c, atol=1e-08)

    def test_psd_window_hanning_detrend_linear(self):
        if self.NFFT_density is None:
            return
        freqs = self.freqs_density
        ydata = np.arange(self.NFFT_density)
        ycontrol = np.zeros(self.NFFT_density)
        ydata1 = ydata+5
        ydata2 = ydata+3.3
        ycontrol1 = ycontrol
        ycontrol2 = ycontrol
        ycontrol1, windowVals = mlab.apply_window(ycontrol1,
                                                  mlab.window_hanning,
                                                  return_window=True)
        ycontrol2 = mlab.window_hanning(ycontrol2)
        ydata = np.vstack([ydata1, ydata2])
        ycontrol = np.vstack([ycontrol1, ycontrol2])
        ydata = np.tile(ydata, (20, 1))
        ycontrol = np.tile(ycontrol, (20, 1))
        ydatab = ydata.T.flatten()
        ydataf = ydata.flatten()
        ycontrol = ycontrol.flatten()
        spec_g, fsp_g = mlab.psd(x=ydataf,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=0,
                                 sides=self.sides,
                                 detrend=mlab.detrend_linear,
                                 window=mlab.window_hanning)
        spec_b, fsp_b = mlab.psd(x=ydatab,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=0,
                                 sides=self.sides,
                                 detrend=mlab.detrend_linear,
                                 window=mlab.window_hanning)
        spec_c, fsp_c = mlab.psd(x=ycontrol,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=0,
                                 sides=self.sides,
                                 window=mlab.window_none)
        spec_c *= len(ycontrol1)/(np.abs(windowVals)**2).sum()
        assert_array_equal(fsp_g, fsp_c)
        assert_array_equal(fsp_b, fsp_c)
        assert_allclose(spec_g, spec_c, atol=1e-08)
        # these should not be almost equal
        assert_raises(AssertionError,
                      assert_allclose, spec_b, spec_c, atol=1e-08)

    def test_psd_windowarray(self):
        freqs = self.freqs_density
        spec, fsp = mlab.psd(x=self.y,
        assert_allclose(fsp, freqs, atol=1e-06)
        assert_equal(spec.shape, freqs.shape)

    def test_psd_windowarray_scale_by_freq(self):
        freqs = self.freqs_density
        spec, fsp = mlab.psd(x=self.y,
                             NFFT=self.NFFT_density,
                             Fs=self.Fs,
                             noverlap=self.nover_density,
                             pad_to=self.pad_to_density,
                             sides=self.sides)
        spec_s, fsp_s = mlab.psd(x=self.y,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=self.nover_density,
                                 pad_to=self.pad_to_density,
                                 sides=self.sides,
                                 scale_by_freq=True)
        spec_n, fsp_n = mlab.psd(x=self.y,
                                 NFFT=self.NFFT_density,
                                 Fs=self.Fs,
                                 noverlap=self.nover_density,
                                 pad_to=self.pad_to_density,
                                 sides=self.sides,
                                 scale_by_freq=False)

        assert_array_equal(fsp, fsp_s)
        assert_array_equal(fsp, fsp_n)
        assert_array_equal(spec, spec_s)
        assert_allclose(spec_s, spec_n/self.Fs, atol=1e-08)

    def test_complex_spectrum(self):
        freqs = self.freqs_spectrum
        spec, fsp = mlab.complex_spectrum(x=self.y,
Original file line number	Diff line number	Diff line change
Expand Up		@@ -730,10 +730,10 @@ def _spectral_helper(x, y=None, NFFT=None, Fs=None, detrend_func=None,
		numFreqs = pad_to//2 + 1
		scaling_factor = 2.

		result = stride_windows(x, NFFT, noverlap)
		result = stride_windows(x, NFFT, noverlap, axis=0)
		result = detrend(result, detrend_func, axis=0)
		result, windowVals = apply_window(result, window, axis=0,
		return_window=True)
		result = detrend(result, detrend_func, axis=0)
		result = np.fft.fft(result, n=pad_to, axis=0)[:numFreqs, :]
		freqs = np.fft.fftfreq(pad_to, 1/Fs)[:numFreqs]

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -259,6 +259,24 @@ def test_stride_windows_n13_noverlapn3_axis1(self):
		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)


		class csv_testcase(CleanupTestCase):
		def setUp(self):
Expand DownExpand Up		@@ -503,6 +521,51 @@ def test_apply_window_stride_windows_hanning_2D_n13_noverlapn3_axis0(self):
		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):
Expand DownExpand Up		@@ -1460,6 +1523,243 @@ def test_psd(self):
		assert_equal(spec.shape, freqs.shape)
		self.check_freqs(spec, freqs, fsp, self.fstims)

		def test_psd_detrend_mean_func_offset(self):
		if self.NFFT_density is None:
		return
		freqs = self.freqs_density
		ydata = np.zeros(self.NFFT_density)
		ydata1 = ydata+5
		ydata2 = ydata+3.3
		ydata = np.vstack([ydata1, ydata2])
		ydata = np.tile(ydata, (20, 1))
		ydatab = ydata.T.flatten()
		ydata = ydata.flatten()
		ycontrol = np.zeros_like(ydata)
		spec_g, fsp_g = mlab.psd(x=ydata,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=0,
		sides=self.sides,
		detrend=mlab.detrend_mean)
		spec_b, fsp_b = mlab.psd(x=ydatab,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=0,
		sides=self.sides,
		detrend=mlab.detrend_mean)
		spec_c, fsp_c = mlab.psd(x=ycontrol,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=0,
		sides=self.sides)
		assert_array_equal(fsp_g, fsp_c)
		assert_array_equal(fsp_b, fsp_c)
		assert_allclose(spec_g, spec_c, atol=1e-08)
		# these should not be almost equal
		assert_raises(AssertionError,
		assert_allclose, spec_b, spec_c, atol=1e-08)

		def test_psd_detrend_mean_str_offset(self):
		if self.NFFT_density is None:
		return
		freqs = self.freqs_density
		ydata = np.zeros(self.NFFT_density)
		ydata1 = ydata+5
		ydata2 = ydata+3.3
		ydata = np.vstack([ydata1, ydata2])
		ydata = np.tile(ydata, (20, 1))
		ydatab = ydata.T.flatten()
		ydata = ydata.flatten()
		ycontrol = np.zeros_like(ydata)
		spec_g, fsp_g = mlab.psd(x=ydata,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=0,
		sides=self.sides,
		detrend='mean')
		spec_b, fsp_b = mlab.psd(x=ydatab,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=0,
		sides=self.sides,
		detrend='mean')
		spec_c, fsp_c = mlab.psd(x=ycontrol,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=0,
		sides=self.sides)
		assert_array_equal(fsp_g, fsp_c)
		assert_array_equal(fsp_b, fsp_c)
		assert_allclose(spec_g, spec_c, atol=1e-08)
		# these should not be almost equal
		assert_raises(AssertionError,
		assert_allclose, spec_b, spec_c, atol=1e-08)

		def test_psd_detrend_linear_func_trend(self):
		if self.NFFT_density is None:
		return
		freqs = self.freqs_density
		ydata = np.arange(self.NFFT_density)
		ydata1 = ydata+5
		ydata2 = ydata+3.3
		ydata = np.vstack([ydata1, ydata2])
		ydata = np.tile(ydata, (20, 1))
		ydatab = ydata.T.flatten()
		ydata = ydata.flatten()
		ycontrol = np.zeros_like(ydata)
		spec_g, fsp_g = mlab.psd(x=ydata,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=0,
		sides=self.sides,
		detrend=mlab.detrend_linear)
		spec_b, fsp_b = mlab.psd(x=ydatab,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=0,
		sides=self.sides,
		detrend=mlab.detrend_linear)
		spec_c, fsp_c = mlab.psd(x=ycontrol,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=0,
		sides=self.sides)
		assert_array_equal(fsp_g, fsp_c)
		assert_array_equal(fsp_b, fsp_c)
		assert_allclose(spec_g, spec_c, atol=1e-08)
		# these should not be almost equal
		assert_raises(AssertionError,
		assert_allclose, spec_b, spec_c, atol=1e-08)

		def test_psd_detrend_linear_str_trend(self):
		if self.NFFT_density is None:
		return
		freqs = self.freqs_density
		ydata = np.arange(self.NFFT_density)
		ydata1 = ydata+5
		ydata2 = ydata+3.3
		ydata = np.vstack([ydata1, ydata2])
		ydata = np.tile(ydata, (20, 1))
		ydatab = ydata.T.flatten()
		ydata = ydata.flatten()
		ycontrol = np.zeros_like(ydata)
		spec_g, fsp_g = mlab.psd(x=ydata,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=0,
		sides=self.sides,
		detrend='linear')
		spec_b, fsp_b = mlab.psd(x=ydatab,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=0,
		sides=self.sides,
		detrend='linear')
		spec_c, fsp_c = mlab.psd(x=ycontrol,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=0,
		sides=self.sides)
		assert_array_equal(fsp_g, fsp_c)
		assert_array_equal(fsp_b, fsp_c)
		assert_allclose(spec_g, spec_c, atol=1e-08)
		# these should not be almost equal
		assert_raises(AssertionError,
		assert_allclose, spec_b, spec_c, atol=1e-08)

		def test_psd_window_hanning(self):
		if self.NFFT_density is None:
		return
		freqs = self.freqs_density
		ydata = np.arange(self.NFFT_density)
		ydata1 = ydata+5
		ydata2 = ydata+3.3
		ycontrol1, windowVals = mlab.apply_window(ydata1,
		mlab.window_hanning,
		return_window=True)
		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))
		ydatab = ydata.T.flatten()
		ydataf = ydata.flatten()
		ycontrol = ycontrol.flatten()
		spec_g, fsp_g = mlab.psd(x=ydataf,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=0,
		sides=self.sides,
		window=mlab.window_hanning)
		spec_b, fsp_b = mlab.psd(x=ydatab,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=0,
		sides=self.sides,
		window=mlab.window_hanning)
		spec_c, fsp_c = mlab.psd(x=ycontrol,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=0,
		sides=self.sides,
		window=mlab.window_none)
		spec_c = len(ycontrol1)/(np.abs(windowVals)*2).sum()
		assert_array_equal(fsp_g, fsp_c)
		assert_array_equal(fsp_b, fsp_c)
		assert_allclose(spec_g, spec_c, atol=1e-08)
		# these should not be almost equal
		assert_raises(AssertionError,
		assert_allclose, spec_b, spec_c, atol=1e-08)

		def test_psd_window_hanning_detrend_linear(self):
		if self.NFFT_density is None:
		return
		freqs = self.freqs_density
		ydata = np.arange(self.NFFT_density)
		ycontrol = np.zeros(self.NFFT_density)
		ydata1 = ydata+5
		ydata2 = ydata+3.3
		ycontrol1 = ycontrol
		ycontrol2 = ycontrol
		ycontrol1, windowVals = mlab.apply_window(ycontrol1,
		mlab.window_hanning,
		return_window=True)
		ycontrol2 = mlab.window_hanning(ycontrol2)
		ydata = np.vstack([ydata1, ydata2])
		ycontrol = np.vstack([ycontrol1, ycontrol2])
		ydata = np.tile(ydata, (20, 1))
		ycontrol = np.tile(ycontrol, (20, 1))
		ydatab = ydata.T.flatten()
		ydataf = ydata.flatten()
		ycontrol = ycontrol.flatten()
		spec_g, fsp_g = mlab.psd(x=ydataf,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=0,
		sides=self.sides,
		detrend=mlab.detrend_linear,
		window=mlab.window_hanning)
		spec_b, fsp_b = mlab.psd(x=ydatab,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=0,
		sides=self.sides,
		detrend=mlab.detrend_linear,
		window=mlab.window_hanning)
		spec_c, fsp_c = mlab.psd(x=ycontrol,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=0,
		sides=self.sides,
		window=mlab.window_none)
		spec_c = len(ycontrol1)/(np.abs(windowVals)*2).sum()
		assert_array_equal(fsp_g, fsp_c)
		assert_array_equal(fsp_b, fsp_c)
		assert_allclose(spec_g, spec_c, atol=1e-08)
		# these should not be almost equal
		assert_raises(AssertionError,
		assert_allclose, spec_b, spec_c, atol=1e-08)

		def test_psd_windowarray(self):
		freqs = self.freqs_density
		spec, fsp = mlab.psd(x=self.y,
Expand All		@@ -1472,6 +1772,34 @@ def test_psd_windowarray(self):
		assert_allclose(fsp, freqs, atol=1e-06)
		assert_equal(spec.shape, freqs.shape)

		def test_psd_windowarray_scale_by_freq(self):
		freqs = self.freqs_density
		spec, fsp = mlab.psd(x=self.y,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=self.nover_density,
		pad_to=self.pad_to_density,
		sides=self.sides)
		spec_s, fsp_s = mlab.psd(x=self.y,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=self.nover_density,
		pad_to=self.pad_to_density,
		sides=self.sides,
		scale_by_freq=True)
		spec_n, fsp_n = mlab.psd(x=self.y,
		NFFT=self.NFFT_density,
		Fs=self.Fs,
		noverlap=self.nover_density,
		pad_to=self.pad_to_density,
		sides=self.sides,
		scale_by_freq=False)

		assert_array_equal(fsp, fsp_s)
		assert_array_equal(fsp, fsp_n)
		assert_array_equal(spec, spec_s)
		assert_allclose(spec_s, spec_n/self.Fs, atol=1e-08)

		def test_complex_spectrum(self):
		freqs = self.freqs_spectrum
		spec, fsp = mlab.complex_spectrum(x=self.y,
Expand Down