Esempio n. 1
0
class TestCovarianceEstimator(ut.TestCase):
    def setUp(self):
        self.dlen = 250000
        self.tf = 65
        self.nc = 4
        self.white_noise = sp.randn(self.dlen, self.nc)
        self.CE = TimeSeriesCovE(tf_max=self.tf, nc=self.nc)
        self.CE.new_chan_set((1, 2))
        self.CE.update(self.white_noise)

    def testTrivial(self):
        p_4_20 = {'tf': 20, 'chan_set': (0, 1, 2, 3)}
        C_4_20 = self.CE.get_cmx(**p_4_20)
        self.assertTupleEqual(C_4_20.shape, (4 * 20, 4 * 20))
        assert_equal(C_4_20, C_4_20.T)

        p_2_10 = {'tf': 10, 'chan_set': (0, 1)}
        C_2_10 = self.CE.get_cmx(**p_2_10)
        self.assertTupleEqual(C_2_10.shape, (2 * 10, 2 * 10))
        assert_equal(C_2_10, C_2_10.T)

    def testInverse(self):
        p_4_20 = {'tf': 20, 'chan_set': (0, 1, 2, 3)}
        C_4_20 = self.CE.get_cmx(**p_4_20)
        iC_4_20 = self.CE.get_icmx(**p_4_20)
        should_be_eye80 = sp.dot(C_4_20, iC_4_20)
        assert_almost_equal(should_be_eye80, sp.eye(80), decimal=5)

        p_2_10 = {'tf': 10, 'chan_set': (0, 1)}
        C_2_10 = self.CE.get_cmx(**p_2_10)
        iC_2_10 = self.CE.get_icmx(**p_2_10)
        should_be_eye20 = sp.dot(C_2_10, iC_2_10)
        assert_almost_equal(should_be_eye20, sp.eye(20), decimal=5)
Esempio n. 2
0
class TestCovarianceEstimator(ut.TestCase):
    def setUp(self):
        self.dlen = 250000
        self.tf = 65
        self.nc = 4
        self.white_noise = sp.randn(self.dlen, self.nc)
        self.CE = TimeSeriesCovE(tf_max=self.tf, nc=self.nc)
        self.CE.new_chan_set((1, 2))
        self.CE.update(self.white_noise)

    def testTrivial(self):
        p_4_20 = {'tf':20, 'chan_set':(0, 1, 2, 3)}
        C_4_20 = self.CE.get_cmx(**p_4_20)
        self.assertTupleEqual(C_4_20.shape, (4 * 20, 4 * 20 ))
        assert_equal(C_4_20, C_4_20.T)

        p_2_10 = {'tf':10, 'chan_set':(0, 1)}
        C_2_10 = self.CE.get_cmx(**p_2_10)
        self.assertTupleEqual(C_2_10.shape, (2 * 10, 2 * 10 ))
        assert_equal(C_2_10, C_2_10.T)

    def testInverse(self):
        p_4_20 = {'tf':20, 'chan_set':(0, 1, 2, 3)}
        C_4_20 = self.CE.get_cmx(**p_4_20)
        iC_4_20 = self.CE.get_icmx(**p_4_20)
        should_be_eye80 = sp.dot(C_4_20, iC_4_20)
        assert_almost_equal(should_be_eye80, sp.eye(80), decimal=5)

        p_2_10 = {'tf':10, 'chan_set':(0, 1)}
        C_2_10 = self.CE.get_cmx(**p_2_10)
        iC_2_10 = self.CE.get_icmx(**p_2_10)
        should_be_eye20 = sp.dot(C_2_10, iC_2_10)
        assert_almost_equal(should_be_eye20, sp.eye(20), decimal=5)
Esempio n. 3
0
class TestFilterNodes(ut.TestCase):
    def setUp(self):
        self.tf = 10
        self.nc = 2
        self.xi = sp.vstack([sp.arange(self.tf).astype(sp.float32)] * self.nc).T * 0.5
        self.len = 1000
        self.pos = [int(i * self.len / 4.0) for i in xrange(1, 4)]
        self.noise = sp.randn(self.len, self.nc)
        self.ce = TimeSeriesCovE(tf_max=self.tf, nc=self.nc)
        self.ce.update(self.noise)

    def testFilterTrivial(self):
        mf_h = MatchedFilterNode(self.tf, self.nc, self.ce)
        mf_h.append_xi_buf(self.xi, recalc=True)
        nmf_h = NormalisedMatchedFilterNode(self.tf, self.nc, self.ce)
        nmf_h.append_xi_buf(self.xi, recalc=True)
        f = sp.dot(mcvec_to_conc(self.xi), self.ce.get_icmx(tf=self.tf))
        nf = sp.dot(f, mcvec_to_conc(self.xi))
        f = mcvec_from_conc(f, nc=self.nc)
        assert_equal(mf_h.f, f)
        assert_equal(nmf_h.f, f / nf)

    """
Esempio n. 4
0
class TestFilterNodes(ut.TestCase):
    def setUp(self):
        self.tf = 10
        self.nc = 2
        self.xi = sp.vstack(
            [sp.arange(self.tf).astype(sp.float32)] * self.nc).T * 0.5
        self.len = 1000
        self.pos = [int(i * self.len / 4.0) for i in xrange(1, 4)]
        self.noise = sp.randn(self.len, self.nc)
        self.ce = TimeSeriesCovE(tf_max=self.tf, nc=self.nc)
        self.ce.update(self.noise)

    def testFilterTrivial(self):
        mf_h = MatchedFilterNode(self.tf, self.nc, self.ce)
        mf_h.append_xi_buf(self.xi, recalc=True)
        nmf_h = NormalisedMatchedFilterNode(self.tf, self.nc, self.ce)
        nmf_h.append_xi_buf(self.xi, recalc=True)
        f = sp.dot(mcvec_to_conc(self.xi), self.ce.get_icmx(tf=self.tf))
        nf = sp.dot(f, mcvec_to_conc(self.xi))
        f = mcvec_from_conc(f, nc=self.nc)
        assert_equal(mf_h.f, f)
        assert_equal(nmf_h.f, f / nf)

    """