Esempio n. 1
0
    def test_from_parameters_force_width(self, width, latching, tc):
        # Create the mock signal and connection
        signal = SignalParameters(latching=latching)
        rps = ReceptionParameters(nengo.Lowpass(tc), width, None)

        # Create the filter
        lpf = LowpassFilter.from_parameters(signal, rps, width=2)
        assert lpf == LowpassFilter(2, latching, tc)
Esempio n. 2
0
    def test_equivalent_filters(self, minimise):
        """Test construction of filter regions from signals and keyspaces."""
        # Create two keyspaces, two signal parameters and two reception
        # parameters with equivalent synapses.
        ks_a = mock.Mock(name="Keyspace[A]")
        signal_a = SignalParameters(keyspace=ks_a, latching=False)

        ks_b = mock.Mock(name="Keyspace[B]")
        signal_b = SignalParameters(keyspace=ks_b, latching=False)

        rp_a = ReceptionParameters(nengo.Lowpass(0.01), 3, None)
        rp_b = ReceptionParameters(nengo.Lowpass(0.01), 3, None)

        # Create the data structure that is expected as input
        specs = [
            ReceptionSpec(signal_a, rp_a),
            ReceptionSpec(signal_b, rp_b),
        ]

        # Create the regions, with minimisation
        filter_region, routing_region = make_filter_regions(
            specs,
            0.001,
            minimise=minimise,
            filter_routing_tag="spam",
            index_field="eggs")

        # Check that the filter region is as expected
        assert filter_region.dt == 0.001

        if minimise:
            assert len(filter_region.filters) == 1
            assert filter_region.filters[0] == LowpassFilter(3, False, 0.01)
        else:
            assert len(filter_region.filters) == 2
            assert filter_region.filters[0] == LowpassFilter(3, False, 0.01)
            assert filter_region.filters[1] == LowpassFilter(3, False, 0.01)

        # Check that the routing region is as expected
        assert routing_region.filter_routing_tag == "spam"
        assert routing_region.index_field == "eggs"
        if minimise:
            assert (signal_a, 0) in routing_region.signal_routes
            assert (signal_b, 0) in routing_region.signal_routes
        else:
            if (signal_a, 0) in routing_region.signal_routes:
                assert (signal_b, 1) in routing_region.signal_routes
            else:
                assert (signal_b, 0) in routing_region.signal_routes
Esempio n. 3
0
    def test_standard(self, width, latching, dt, tc):
        """Test creating and writing out lowpass filters."""
        lpf = LowpassFilter(width, latching, tc)

        # Pack the filter into some data
        data = bytearray(lpf.size)
        lpf.pack_into(dt, data)

        # Check the values are sane
        v1, v2, mask, size = struct.unpack("<4I", data)
        val = math.exp(-dt / tc)
        assert v1 == tp.value_to_fix(val)
        assert v2 == tp.value_to_fix(1 - val)
        assert mask == (0xffffffff if latching else 0x00000000)
        assert size == width
Esempio n. 4
0
    def test_pack_data(self, tau, dt):
        # Create the filter
        f = LowpassFilter(0, False, tau)

        # Pack into an array
        data = bytearray(8)
        f.pack_data(dt, data, 0)

        # Compute expected values
        exp_a = tp.value_to_fix(np.exp(-dt / tau))
        exp_b = tp.value_to_fix(1.0 - np.exp(-dt / tau))

        # Unpack and check for accuracy
        (a, b) = struct.unpack_from("<2I", data)
        assert a == exp_a
        assert b == exp_b
Esempio n. 5
0
    def test_forced_filter_width(self):
        """Test construction of filter regions from signals and keyspaces."""
        # Create two keyspaces, two signals and two connections with equivalent
        # synapses.
        # Create two keyspaces, two signals and two reception parameters with
        # different synapses.
        ks_a = mock.Mock(name="Keyspace[A]")
        signal_a = SignalParameters(keyspace=ks_a, latching=False)

        ks_b = mock.Mock(name="Keyspace[B]")
        signal_b = SignalParameters(keyspace=ks_b, latching=False)

        rp_a = ReceptionParameters(nengo.Lowpass(0.01), 3, None)
        rp_b = ReceptionParameters(None, 5, None)

        # Create the type of dictionary that is expected as input
        specs = [
            ReceptionSpec(signal_a, rp_a),
            ReceptionSpec(signal_b, rp_b),
        ]

        # Create the regions, with minimisation
        filter_region, routing_region = make_filter_regions(specs,
                                                            0.001,
                                                            width=1)

        # Check that the filter region is as expected
        for f in filter_region.filters:
            assert (f == LowpassFilter(1, False, 0.01)
                    or f == NoneFilter(1, False))  # noqa: E711
Esempio n. 6
0
def test_filter_region_force_width():
    """Test creation of a filter data region."""
    # Create two filters
    fs = [LowpassFilter(5, False, 0.1), NoneFilter(3, False)]

    # Create the filter region
    fr = FilterRegion(fs, dt=0.001)

    # The size should be correct (count of words + header 1 + data 1 + header 2
    # + data 2)
    assert fr.sizeof() == 4 + 16 + 8 + 16 + 0

    # Check that the data is written out correctly
    fp = tempfile.TemporaryFile()
    fr.write_subregion_to_file(fp, filter_width=1)
    fp.seek(0)

    length, = struct.unpack("<I", fp.read(4))
    assert length == len(fs)

    expected_data = bytearray(fr.sizeof() - 4)
    fs[0].pack_into(fr.dt, expected_data, width=1)
    fs[1].pack_into(fr.dt,
                    expected_data, (fs[0].size_words() + 4) * 4,
                    width=1)
    assert fp.read() == expected_data
Esempio n. 7
0
    def test_eq(self):
        lpfs = [
            LowpassFilter(5, True, 0.01),
            LowpassFilter(5, True, 0.02),
            LowpassFilter(3, True, 0.01),
            LowpassFilter(5, False, 0.01)
        ]

        for lpf in lpfs[1:]:
            assert lpf != lpfs[0]

        lpf = LowpassFilter(5, True, 0.01)
        assert lpf == lpfs[0]

        nf = NoneFilter(5, True)
        assert lpf != nf and nf != lpf
Esempio n. 8
0
    def test_pack_data_tau_zero(self):
        # Create the filter
        f = LowpassFilter(0, False, 0)

        # Pack into an array
        data = bytearray(8)
        f.pack_data(0.001, data, 0)

        # Compute expected values
        exp_a = tp.value_to_fix(0.0)
        exp_b = tp.value_to_fix(1.0)

        # Unpack and check for accuracy
        (a, b) = struct.unpack_from("<2I", data)
        assert a == exp_a
        assert b == exp_b
Esempio n. 9
0
    def test_pack_data(self, tau, dt):
        # Create the filter
        f = LowpassFilter(0, False, tau)

        # Pack into an array
        data = bytearray(8)
        f.pack_data(dt, data, 0)

        # Compute expected values
        exp_a = tp.value_to_fix(np.exp(-dt / tau))
        exp_b = tp.value_to_fix(1.0 - np.exp(-dt / tau))

        # Unpack and check for accuracy
        (a, b) = struct.unpack_from("<2I", data)
        assert a == exp_a
        assert b == exp_b
    def test_from_parameters_force_width(self, width, latching, tc):
        # Create the mock signal and connection
        signal = SignalParameters(latching=latching)
        rps = ReceptionParameters(nengo.Lowpass(tc), width)

        # Create the filter
        lpf = LowpassFilter.from_parameters(signal, rps, width=2)
        assert lpf == LowpassFilter(2, latching, tc)
Esempio n. 11
0
    def test_eq(self):
        # Check that linear filters are equal iff. they share a numerator and
        # denominator.
        lpf = LowpassFilter(0, False, 0.1)
        lf1 = LinearFilter(0, False, [1.0], [0.1, 0.2])
        lf2 = LinearFilter(0, False, [1.0], [0.1, 0.3])
        lf3 = LinearFilter(0, False, [1.0], [0.1, 0.2])

        assert lf1 != lpf
        assert lf2 != lf1
        assert lf3 != lf2
        assert lf3 == lf1
Esempio n. 12
0
    def test_from_signal_and_connection_with_slice(self, latching, tc):
        # Create the mock signal and connection
        signal = mock.Mock(name="signal", spec_set=["latching"])
        signal.latching = latching

        with nengo.Network():
            a = nengo.Ensemble(100, 1)
            b = nengo.Ensemble(100, 2)
            connection = nengo.Connection(a, b[1], synapse=nengo.Lowpass(tc))

        # Create the filter
        lpf = LowpassFilter.from_signal_and_connection(signal, connection)
        assert lpf == LowpassFilter(2, latching, tc)
Esempio n. 13
0
    def test_different_filters(self):
        """Test construction of filter regions from signals and keyspaces."""
        # Create two keyspaces, two signals and two reception parameters with
        # different synapses.
        ks_a = mock.Mock(name="Keyspace[A]")
        signal_a = SignalParameters(keyspace=ks_a, latching=False)

        ks_b = mock.Mock(name="Keyspace[B]")
        signal_b = SignalParameters(keyspace=ks_b, latching=False)

        rp_a = ReceptionParameters(nengo.Lowpass(0.01), 3, None)
        rp_b = ReceptionParameters(None, 3, None)

        # Create the type of dictionary that is expected as input
        specs = [
            ReceptionSpec(signal_a, rp_a),
            ReceptionSpec(signal_b, rp_b),
        ]

        # Create the regions, with minimisation
        filter_region, routing_region = make_filter_regions(
            specs,
            0.001,
            minimise=True,  # Shouldn't achieve anything
            filter_routing_tag="spam",
            index_field="eggs")

        # Check that the filter region is as expected
        assert filter_region.dt == 0.001
        assert len(filter_region.filters) == 2

        for f in filter_region.filters:
            assert (f == LowpassFilter(3, False, 0.01)
                    or f == NoneFilter(3, False))  # noqa: E711

        # Check that the routing region is as expected
        assert routing_region.filter_routing_tag == "spam"

        assert routing_region.index_field == "eggs"
        if (signal_a, 0) in routing_region.signal_routes:
            assert (signal_b, 1) in routing_region.signal_routes
        else:
            assert (signal_b, 0) in routing_region.signal_routes