Changeset 0a42239 for python


Ignore:
Timestamp:
Mar 8, 2013, 8:36:44 PM (12 years ago)
Author:
Paul Brossier <piem@piem.org>
Branches:
feature/autosink, feature/cnn, feature/cnn_org, feature/constantq, feature/crepe, feature/crepe_org, feature/pitchshift, feature/pydocstrings, feature/timestretch, fix/ffmpeg5, master, pitchshift, sampler, timestretch, yinfft+
Children:
973206a
Parents:
9582713
Message:

python/tests/test_fft.py: update, indent

Location:
python
Files:
1 edited
1 moved

Legend:

Unmodified
Added
Removed
  • python/tests/test_fft.py

    r9582713 r0a42239  
    33from numpy.testing import TestCase, run_module_suite
    44from numpy.testing import assert_equal, assert_almost_equal
    5 # WARNING: numpy also has an fft object
    65from aubio import fvec, fft, cvec
    76from numpy import array, shape
     
    109class aubio_fft_test_case(TestCase):
    1110
    12   def test_members(self):
    13     f = fft()
    14     assert_equal (f.win_s, 1024)
     11    def test_members(self):
     12        """ check members are set correctly """
     13        win_s = 2048
     14        f = fft(win_s)
     15        assert_equal (f.win_s, win_s)
    1516
    16   def test_output_dimensions(self):
    17     """ check the dimensions of output """
    18     win_s = 1024
    19     timegrain = fvec(win_s)
    20     f = fft(win_s)
    21     fftgrain = f (timegrain)
    22     assert_equal (fftgrain.norm, 0)
    23     assert_equal (shape(fftgrain.norm), (win_s/2+1,))
    24     assert_equal (fftgrain.phas, 0)
    25     assert_equal (shape(fftgrain.phas), (win_s/2+1,))
     17    def test_output_dimensions(self):
     18        """ check the dimensions of output """
     19        win_s = 1024
     20        timegrain = fvec(win_s)
     21        f = fft (win_s)
     22        fftgrain = f (timegrain)
     23        assert_equal (shape(fftgrain.norm), (win_s/2+1,))
     24        assert_equal (shape(fftgrain.phas), (win_s/2+1,))
    2625
    27   def test_zeros(self):
    28     """ check the transform of zeros """
    29     win_s = 512
    30     timegrain = fvec(win_s)
    31     f = fft(win_s)
    32     fftgrain = f(timegrain)
    33     assert_equal ( fftgrain.norm == 0, True )
    34     assert_equal ( fftgrain.phas == 0, True )
     26    def test_zeros(self):
     27        """ check the transform of zeros is all zeros """
     28        win_s = 512
     29        timegrain = fvec(win_s)
     30        f = fft (win_s)
     31        fftgrain = f (timegrain)
     32        assert_equal ( fftgrain.norm, 0 )
     33        assert_equal ( fftgrain.phas, 0 )
    3534
    36   def test_impulse(self):
    37     """ check the transform of one impulse at a random place """
    38     from random import random
    39     from math import floor
    40     win_s = 256
    41     i = floor(random()*win_s)
    42     impulse = pi * random()
    43     f = fft(win_s)
    44     timegrain = fvec(win_s)
    45     timegrain[i] = impulse
    46     fftgrain = f ( timegrain )
    47     #self.plot_this ( fftgrain.phas )
    48     assert_almost_equal ( fftgrain.norm, impulse, decimal = 6 )
    49     assert_equal ( fftgrain.phas <= pi, True)
    50     assert_equal ( fftgrain.phas >= -pi, True)
     35    def test_impulse(self):
     36        """ check the transform of one impulse at a random place """
     37        from random import random
     38        from math import floor
     39        win_s = 256
     40        i = floor(random()*win_s)
     41        impulse = pi * random()
     42        f = fft(win_s)
     43        timegrain = fvec(win_s)
     44        timegrain[i] = impulse
     45        fftgrain = f ( timegrain )
     46        #self.plot_this ( fftgrain.phas )
     47        assert_almost_equal ( fftgrain.norm, impulse, decimal = 6 )
     48        assert_equal ( fftgrain.phas <= pi, True)
     49        assert_equal ( fftgrain.phas >= -pi, True)
    5150
    52   def test_impulse_negative(self):
    53     """ check the transform of one impulse at a random place """
    54     from random import random
    55     from math import floor
    56     win_s = 256
    57     i = 0
    58     impulse = -10.
    59     f = fft(win_s)
    60     timegrain = fvec(win_s)
    61     timegrain[i] = impulse
    62     fftgrain = f ( timegrain )
    63     #self.plot_this ( fftgrain.phas )
    64     assert_almost_equal ( fftgrain.norm, abs(impulse), decimal = 6 )
    65     if impulse < 0:
    66       # phase can be pi or -pi, as it is not unwrapped
    67       assert_almost_equal ( abs(fftgrain.phas[1:-1]) , pi, decimal = 6 )
    68       assert_almost_equal ( fftgrain.phas[0], pi, decimal = 6)
    69       assert_almost_equal ( fftgrain.phas[-1], pi, decimal = 6)
    70     else:
    71       assert_equal ( fftgrain.phas[1:-1] == 0, True)
    72       assert_equal ( fftgrain.phas[0] == 0, True)
    73       assert_equal ( fftgrain.phas[-1] == 0, True)
    74     # now check the resynthesis
    75     synthgrain = f.rdo ( fftgrain )
    76     #self.plot_this ( fftgrain.phas.T )
    77     assert_equal ( fftgrain.phas <= pi, True)
    78     assert_equal ( fftgrain.phas >= -pi, True)
    79     #self.plot_this ( synthgrain - timegrain )
    80     assert_almost_equal ( synthgrain, timegrain, decimal = 6 )
     51    def test_impulse_negative(self):
     52        """ check the transform of one impulse at a random place """
     53        from random import random
     54        from math import floor
     55        win_s = 256
     56        i = 0
     57        impulse = -10.
     58        f = fft(win_s)
     59        timegrain = fvec(win_s)
     60        timegrain[i] = impulse
     61        fftgrain = f ( timegrain )
     62        #self.plot_this ( fftgrain.phas )
     63        assert_almost_equal ( fftgrain.norm, abs(impulse), decimal = 6 )
     64        if impulse < 0:
     65            # phase can be pi or -pi, as it is not unwrapped
     66            assert_almost_equal ( abs(fftgrain.phas[1:-1]) , pi, decimal = 6 )
     67            assert_almost_equal ( fftgrain.phas[0], pi, decimal = 6)
     68            assert_almost_equal ( fftgrain.phas[-1], pi, decimal = 6)
     69        else:
     70            assert_equal ( fftgrain.phas[1:-1] == 0, True)
     71            assert_equal ( fftgrain.phas[0] == 0, True)
     72            assert_equal ( fftgrain.phas[-1] == 0, True)
     73        # now check the resynthesis
     74        synthgrain = f.rdo ( fftgrain )
     75        #self.plot_this ( fftgrain.phas.T )
     76        assert_equal ( fftgrain.phas <= pi, True)
     77        assert_equal ( fftgrain.phas >= -pi, True)
     78        #self.plot_this ( synthgrain - timegrain )
     79        assert_almost_equal ( synthgrain, timegrain, decimal = 6 )
    8180
    82   def test_impulse_at_zero(self):
    83     """ check the transform of one impulse at a index 0 """
    84     win_s = 1024
    85     impulse = pi
    86     f = fft(win_s)
    87     timegrain = fvec(win_s)
    88     timegrain[0] = impulse
    89     fftgrain = f ( timegrain )
    90     #self.plot_this ( fftgrain.phas )
    91     assert_equal ( fftgrain.phas[0], 0)
    92     # could be 0 or -0 depending on fft implementation (0 for fftw3, -0 for ooura)
    93     assert_almost_equal ( fftgrain.phas[1], 0)
    94     assert_almost_equal ( fftgrain.norm[0], impulse, decimal = 6 )
     81    def test_impulse_at_zero(self):
     82        """ check the transform of one impulse at a index 0 """
     83        win_s = 1024
     84        impulse = pi
     85        f = fft(win_s)
     86        timegrain = fvec(win_s)
     87        timegrain[0] = impulse
     88        fftgrain = f ( timegrain )
     89        #self.plot_this ( fftgrain.phas )
     90        assert_equal ( fftgrain.phas[0], 0)
     91        # could be 0 or -0 depending on fft implementation (0 for fftw3, -0 for ooura)
     92        assert_almost_equal ( fftgrain.phas[1], 0)
     93        assert_almost_equal ( fftgrain.norm[0], impulse, decimal = 6 )
    9594
    96   def test_rdo_before_do(self):
    97     """ check running fft.rdo before fft.do works """
    98     win_s = 1024
    99     impulse = pi
    100     f = fft(win_s)
    101     fftgrain = cvec(win_s)
    102     t = f.rdo( fftgrain )
    103     assert_equal ( t, 0 )
     95    def test_rdo_before_do(self):
     96        """ check running fft.rdo before fft.do works """
     97        win_s = 1024
     98        impulse = pi
     99        f = fft(win_s)
     100        fftgrain = cvec(win_s)
     101        t = f.rdo( fftgrain )
     102        assert_equal ( t, 0 )
    104103
    105   def plot_this(self, this):
    106     from pylab import plot, show
    107     plot ( this )
    108     show ()
     104    def plot_this(self, this):
     105        from pylab import plot, show
     106        plot ( this )
     107        show ()
    109108
    110109if __name__ == '__main__':
    111   from unittest import main
    112   main()
     110    from unittest import main
     111    main()
    113112
Note: See TracChangeset for help on using the changeset viewer.