def test_realizeQNTF(self):
     """Test function for realizeQNTF()"""
     for i in self.orders:
         if not i in self.res: continue
         for j in self.f0s:
             if not j in self.res[i]: continue
             for ng in self.NG:
                 if not ng in self.res[i][j]: continue
                 for ing in self.ING:
                     if not ing in self.res[i][j][ng]: continue
                     for rot in self.rots:
                         if not rot in self.res[i][j][ng][ing]: continue
                         for f in self.forms:
                             if not f in self.res[i][j][ng][ing][rot]: continue
                             if self.res[i][j][ng][ing][rot][f] is None: continue
                             print("Testing form: %s, order: %d, f0: %f, NG %d ING %d ROT %d" % \
                                   (f, i, j, ng, ing, rot))
                             ntf = ds.synthesizeQNTF(i, self.osr, j, ng, ing)
                             ABCD = ds.realizeQNTF(ntf, f, rot)
                             if not np.allclose(self.res[i][j][ng][ing][rot][f].real,
                                                ABCD.real, atol=1e-3, rtol=1e-3):
                                 print(ntf)
                                 print(ABCD)
                                 print(self.res[i][j][ng][ing][rot][f])
                                 print(ABCD - self.res[i][j][ng][ing][rot][f])
                             self.assertTrue(np.allclose(self.res[i][j][ng][ing][rot][f].real,
                                             ABCD.real, atol=1e-3, rtol=1e-3))
     return
    def test_simulateSNR_4(self):
        """Test function for simulateSNR() 4/4"""
        SNR_ref = np.array([23.0421, 32.1100, 43.3758, 53.1791,
                            65.5504, 70.5023, 73.4608, 76.2416, 77.8770,
                            78.2733, 79.3729, 79.5728, 80.8729, 82.7461,
                            83.0723, 84.8488, 84.3327])
        AMP_ref = np.array([-70, -60, -50, -40, -30, -20, -15, -10, -9, -8, -7,
                            -6, -5, -4, -3, -2, -1, 0])

        order = 4
        osr = 32
        M = 8
        NG = -50
        ING = -10
        f0 = 1./ 16
        quadrature = 1
        form = 'PFB'
        nlev = M + 1
        z0 = np.exp(1j*2*np.pi*f0)
        bw = 1./ osr
        delta = 2
        FullScale = M
        ntf0 = ds.synthesizeQNTF(order, osr, f0, NG, ING)
        ABCD = ds.realizeQNTF(ntf0, form, True)
        #print(ABCD)
        #ds.PlotExampleSpectrum(ntf0, M, osr, f0, quadrature=True)
        a, b = ds.simulateSNR(ABCD, osr, None, f0, nlev);
        assert np.allclose(a[6:], SNR_ref, atol=10, rtol=1e-3)
        assert np.allclose(b[5:], AMP_ref, atol=1)
    def test_simulateSNR_4(self):
        """Test function for simulateSNR() 4/4"""
        SNR_ref = np.array([
            23.0421, 32.1100, 43.3758, 53.1791, 65.5504, 70.5023, 73.4608,
            76.2416, 77.8770, 78.2733, 79.3729, 79.5728, 80.8729, 82.7461,
            83.0723, 84.8488, 84.3327
        ])
        AMP_ref = np.array([
            -70, -60, -50, -40, -30, -20, -15, -10, -9, -8, -7, -6, -5, -4, -3,
            -2, -1, 0
        ])

        order = 4
        osr = 32
        M = 8
        NG = -50
        ING = -10
        f0 = 1. / 16
        quadrature = 1
        form = 'PFB'
        nlev = M + 1
        z0 = np.exp(1j * 2 * np.pi * f0)
        bw = 1. / osr
        delta = 2
        FullScale = M
        ntf0 = ds.synthesizeQNTF(order, osr, f0, NG, ING)
        ABCD = ds.realizeQNTF(ntf0, form, True)
        #print(ABCD)
        #ds.PlotExampleSpectrum(ntf0, M, osr, f0, quadrature=True)
        a, b = ds.simulateSNR(ABCD, osr, None, f0, nlev)
        assert np.allclose(a[6:], SNR_ref, atol=10, rtol=1e-3)
        assert np.allclose(b[5:], AMP_ref, atol=1)
 def test_simulateQSNR(self):
     """Test function for simulateSNR() 4/4"""
     order = 4
     osr = 32
     M = 8
     NG = -50
     ING = -10
     f0 = 1. / 16
     quadrature = 1
     form = 'PFB'
     nlev = M + 1
     z0 = np.exp(1j * 2 * np.pi * f0)
     bw = 1. / osr
     delta = 2
     FullScale = M
     ntf0 = ds.synthesizeQNTF(order, osr, f0, NG, ING)
     ABCD = ds.realizeQNTF(ntf0, form, True)
     a, b = ds.simulateQSNR(ABCD, osr, None, f0, nlev)
     assert np.allclose(a[6:], self.SNR_ref, atol=6, rtol=1e-3)
     assert np.allclose(b[5:], self.AMP_ref, atol=1)
 def test_simulateQSNR(self):
     """Test function for simulateSNR() 4/4"""
     order = 4
     osr = 32
     M = 8
     NG = -50
     ING = -10
     f0 = 1./ 16
     quadrature = 1
     form = 'PFB'
     nlev = M + 1
     z0 = np.exp(1j*2*np.pi*f0)
     bw = 1./ osr
     delta = 2
     FullScale = M
     ntf0 = ds.synthesizeQNTF(order, osr, f0, NG, ING)
     ABCD = ds.realizeQNTF(ntf0, form, True)
     a, b = ds.simulateQSNR(ABCD, osr, None, f0, nlev);
     assert np.allclose(a[6:], self.SNR_ref, atol=6, rtol=1e-3)
     assert np.allclose(b[5:], self.AMP_ref, atol=1)
Example #6
0
 def test_realizeQNTF(self):
     """Test function for realizeQNTF()"""
     for i in self.orders:
         if not i in self.res: continue
         for j in self.f0s:
             if not j in self.res[i]: continue
             for ng in self.NG:
                 if not ng in self.res[i][j]: continue
                 for ing in self.ING:
                     if not ing in self.res[i][j][ng]: continue
                     for rot in self.rots:
                         if not rot in self.res[i][j][ng][ing]: continue
                         for f in self.forms:
                             if not f in self.res[i][j][ng][ing][rot]:
                                 continue
                             if self.res[i][j][ng][ing][rot][f] is None:
                                 continue
                             print("Testing form: %s, order: %d, f0: %f, NG %d ING %d ROT %d" % \
                                   (f, i, j, ng, ing, rot))
                             ntf = ds.synthesizeQNTF(
                                 i, self.osr, j, ng, ing)
                             ABCD = ds.realizeQNTF(ntf, f, rot)
                             if not np.allclose(
                                     self.res[i][j][ng][ing][rot][f].real,
                                     ABCD.real,
                                     atol=1e-3,
                                     rtol=1e-3):
                                 print(ntf)
                                 print(ABCD)
                                 print(self.res[i][j][ng][ing][rot][f])
                                 print(ABCD -
                                       self.res[i][j][ng][ing][rot][f])
                             self.assertTrue(
                                 np.allclose(
                                     self.res[i][j][ng][ing][rot][f].real,
                                     ABCD.real,
                                     atol=1e-3,
                                     rtol=1e-3))
     return