#! /usr/bin/env python from numpy.testing import TestCasefrom numpy.testing import assert_equal, assert_almost_equalimport numpy as npfrom aubio import fvec, fft, cvecfrom math import pi, floorfrom random import random class aubio_fft_test_case(TestCase):     def test_members(self):        """ check members are set correctly """        win_s = 2048        f = fft(win_s)        assert_equal (f.win_s, win_s)     def test_output_dimensions(self):        """ check the dimensions of output """        win_s = 1024        timegrain = fvec(win_s)        f = fft (win_s)        fftgrain = f (timegrain)        del f        assert_equal (fftgrain.norm.shape, (win_s/2+1,))        assert_equal (fftgrain.phas.shape, (win_s/2+1,))     def test_zeros(self):        """ check the transform of zeros is all zeros """        win_s = 512        timegrain = fvec(win_s)        f = fft (win_s)        fftgrain = f (timegrain)        assert_equal ( fftgrain.norm, 0 )        try:            assert_equal ( fftgrain.phas, 0 )        except AssertionError:            assert_equal (fftgrain.phas[fftgrain.phas > 0], +pi)            assert_equal (fftgrain.phas[fftgrain.phas < 0], -pi)            assert_equal (np.abs(fftgrain.phas[np.abs(fftgrain.phas) != pi]), 0)            self.skipTest('fft(fvec(%d)).phas != +0, ' % win_s \                    + 'This is expected when using fftw3 on powerpc.')     def test_impulse(self):        """ check the transform of one impulse at a random place """        win_s = 256        i = int(floor(random()*win_s))        impulse = pi * random()        f = fft(win_s)        timegrain = fvec(win_s)        timegrain[i] = impulse        fftgrain = f ( timegrain )        #self.plot_this ( fftgrain.phas )        assert_almost_equal ( fftgrain.norm, impulse, decimal = 6 )        assert_equal ( fftgrain.phas <= pi, True)        assert_equal ( fftgrain.phas >= -pi, True)     def test_impulse_negative(self):        """ check the transform of a negative impulse at a random place """        win_s = 256        i = int(floor(random()*win_s))        impulse = -.1        f = fft(win_s)        timegrain = fvec(win_s)        timegrain[0] = 0        timegrain[i] = impulse        fftgrain = f ( timegrain )        #self.plot_this ( fftgrain.phas )        assert_almost_equal ( fftgrain.norm, abs(impulse), decimal = 5 )        if impulse < 0:            # phase can be pi or -pi, as it is not unwrapped            #assert_almost_equal ( abs(fftgrain.phas[1:-1]) , pi, decimal = 6 )            assert_almost_equal ( fftgrain.phas[0], pi, decimal = 6)            assert_almost_equal ( np.fmod(fftgrain.phas[-1], pi), 0, decimal = 6)        else:            #assert_equal ( fftgrain.phas[1:-1] == 0, True)            assert_equal ( fftgrain.phas[0], 0)            assert_almost_equal ( np.fmod(fftgrain.phas[-1], pi), 0, decimal = 6)        # now check the resynthesis        synthgrain = f.rdo ( fftgrain )        #self.plot_this ( fftgrain.phas.T )        assert_equal ( fftgrain.phas <= pi, True)        assert_equal ( fftgrain.phas >= -pi, True)        #self.plot_this ( synthgrain - timegrain )        assert_almost_equal ( synthgrain, timegrain, decimal = 6 )     def test_impulse_at_zero(self):        """ check the transform of one impulse at a index 0 """        win_s = 1024        impulse = pi        f = fft(win_s)        timegrain = fvec(win_s)        timegrain[0] = impulse        fftgrain = f ( timegrain )        #self.plot_this ( fftgrain.phas )        assert_equal ( fftgrain.phas[0], 0)        # could be 0 or -0 depending on fft implementation (0 for fftw3, -0 for ooura)        assert_almost_equal ( fftgrain.phas[1], 0)        assert_almost_equal ( fftgrain.norm[0], impulse, decimal = 6 )     def test_rdo_before_do(self):        """ check running fft.rdo before fft.do works """        win_s = 1024        f = fft(win_s)        fftgrain = cvec(win_s)        t = f.rdo( fftgrain )        assert_equal ( t, 0 )     def plot_this(self, this):        from pylab import plot, show        plot ( this )        show ()     def test_local_fftgrain(self):        """ check aubio.fft() result can be accessed after deletion """        def compute_grain(impulse):            win_s = 1024            timegrain = fvec(win_s)            timegrain[0] = impulse            f = fft(win_s)            fftgrain = f ( timegrain )            return fftgrain        impulse = pi        fftgrain = compute_grain(impulse)        assert_equal ( fftgrain.phas[0], 0)        assert_almost_equal ( fftgrain.phas[1], 0)        assert_almost_equal ( fftgrain.norm[0], impulse, decimal = 6 )     def test_local_reconstruct(self):        """ check aubio.fft.rdo() result can be accessed after deletion """        def compute_grain(impulse):            win_s = 1024            timegrain = fvec(win_s)            timegrain[0] = impulse            f = fft(win_s)            fftgrain = f ( timegrain )            r = f.rdo(fftgrain)            return r        impulse = pi        r = compute_grain(impulse)        assert_almost_equal ( r[0], impulse, decimal = 6)        assert_almost_equal ( r[1:], 0) class aubio_fft_odd_sizes(TestCase):     def test_reconstruct_with_odd_size(self):        win_s = 29        self.recontruct(win_s, 'odd sizes not supported')     def test_reconstruct_with_radix15(self):        win_s = 2 ** 4 * 15        self.recontruct(win_s, 'radix 15 supported')     def test_reconstruct_with_radix5(self):        win_s = 2 ** 4 * 5        self.recontruct(win_s, 'radix 5 supported')     def test_reconstruct_with_radix3(self):        win_s = 2 ** 4 * 3        self.recontruct(win_s, 'radix 3 supported')     def recontruct(self, win_s, skipMessage):        try:            f = fft(win_s)        except RuntimeError:            self.skipTest(skipMessage)        input_signal = fvec(win_s)        input_signal[win_s//2] = 1        c = f(input_signal)        output_signal = f.rdo(c)        assert_almost_equal(input_signal, output_signal) class aubio_fft_wrong_params(TestCase):     def test_large_input_timegrain(self):        win_s = 1024        f = fft(win_s)        t = fvec(win_s + 1)        with self.assertRaises(ValueError):            f(t)     def test_small_input_timegrain(self):        win_s = 1024        f = fft(win_s)        t = fvec(1)        with self.assertRaises(ValueError):            f(t)     def test_large_input_fftgrain(self):        win_s = 1024        f = fft(win_s)        s = cvec(win_s + 5)        with self.assertRaises(ValueError):            f.rdo(s)     def test_small_input_fftgrain(self):        win_s = 1024        f = fft(win_s)        s = cvec(16)        with self.assertRaises(ValueError):            f.rdo(s)     def test_wrong_buf_size(self):        win_s = -1        with self.assertRaises(ValueError):            fft(win_s)     def test_buf_size_too_small(self):        win_s = 1        with self.assertRaises(RuntimeError):            fft(win_s) if __name__ == '__main__':    from unittest import main    main()