File size: 18,028 Bytes
aecbd27
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
"""Engine tests on tiny networks: exact dynamics, Brian2 step order, and equality with a
naive implementation written independently of the kernel."""

import math

import numpy as np
import pytest
from flysim.engine import (
    CpuEngine,
    InputSchedule,
    ModelParams,
    SynapseMatrix,
    poisson_schedule,
    trial_rng,
)
from flysim.engine.inputs import merge

P = ModelParams()
# First draw of trial 0 of one condition, pinned so a change to the seeding scheme
# cannot pass silently.
PINNED_DRAW = 1489115183


def _matrix(edges: list[tuple[int, int, int]], n: int) -> SynapseMatrix:
    pre, post, w = zip(*edges, strict=True) if edges else ((), (), ())
    return SynapseMatrix.from_edges(np.array(pre), np.array(post), np.array(w), n)


def _inputs(at: dict[int, list[int]]) -> InputSchedule:
    """{neuron: [steps]} -> schedule."""
    pairs = sorted((s, n) for n, steps in at.items() for s in steps)
    return InputSchedule(
        targets=np.array(sorted(at), dtype=np.int32),
        steps=np.array([s for s, _ in pairs], dtype=np.int64),
        neurons=np.array([n for _, n in pairs], dtype=np.int32),
    )


KERNELS = ("plain", "skip_rest", "vec")


def _run(matrix, schedule, steps, dtype=np.float32, params=P, skip_rest=False, kernel=None):
    eng = CpuEngine(dtype, skip_rest=skip_rest, kernel=kernel)
    eng.load(matrix, params)
    eng.schedule_inputs(schedule)
    eng.advance_to(steps)
    return eng


def _spike_steps(eng, neuron):
    s, n = eng.spikes_since(0)
    return s[n == neuron].tolist()


def test_params_match_the_preregistration():
    assert P.rfc_steps == 22
    assert P.delay_steps == 18
    assert P.w_input == pytest.approx(68.75)


def test_input_spike_fires_next_step_and_reset_discards_same_step_input():
    # Input at every step 0..9: an input fires the neuron in the next step, and the
    # input arriving in the spiking step is wiped by the reset (Brian2 order).
    eng = _run(_matrix([], 1), _inputs({0: list(range(10))}), 12)
    assert _spike_steps(eng, 0) == [1, 3, 5, 7, 9]


def test_delay_and_exact_propagator():
    # 0 spikes at step 1, so its synapse onto 1 lands at step 1 + 18 = 19.
    w = 100
    eng = _run(_matrix([(0, 1, w)], 2), _inputs({0: [0]}), 19, dtype=np.float64)
    assert eng.g[1] == 0 and eng.v[1] == P.v_0
    eng.advance_to(20)
    g0 = P.w_syn * w
    assert eng.g[1] == pytest.approx(g0)
    # From the end of step 19, neuron 1 follows the closed-form solution.
    for k in range(1, 200):
        eng.advance_to(20 + k)
        t = k * P.dt
        u = g0 * P.tau / (P.tau - P.t_mbr) * (math.exp(-t / P.tau) - math.exp(-t / P.t_mbr))
        assert eng.v[1] - P.v_0 == pytest.approx(u, rel=1e-9, abs=1e-12)
        assert eng.g[1] == pytest.approx(g0 * math.exp(-t / P.tau), rel=1e-9)
    assert _spike_steps(eng, 1) == []


def test_refractory_period_is_22_steps_and_drops_input():
    # 0 spikes at every odd step; each spike gives 1 a huge kick 18 steps later, at
    # odd steps from 19. 1 spikes at 20 and is refractory for steps 21-41; the kicks
    # in that window are dropped (Brian2's conditional write), so it is at rest at
    # step 42 and only the kick at 43 fires it, at 44. Period: 24 steps.
    eng = _run(_matrix([(0, 1, 20000)], 2), _inputs({0: list(range(0, 400, 2))}), 120)
    assert _spike_steps(eng, 1) == [20, 44, 68, 92, 116]


def test_input_to_refractory_neuron_is_dropped_not_deferred():
    # 1 spikes at 20 (kick from 0's spike at 1). A second, smaller kick lands at 25,
    # inside the refractory window: Brian2 drops it, so 1 stays exactly at rest.
    m = _matrix([(0, 1, 20000), (2, 1, 20000)], 3)
    eng = _run(m, _inputs({0: [0], 2: [5]}), 60, dtype=np.float64)
    assert _spike_steps(eng, 1) == [20]
    assert eng.v[1] == P.v_0 and eng.g[1] == 0


def test_inhibition_and_stimulated_neurons_have_no_refractory_period():
    m = _matrix([(0, 2, 30000), (1, 2, -30000)], 3)
    both = _run(m, _inputs({0: [0], 1: [0]}), 100)
    only_exc = _run(m, _inputs({0: [0]}), 100)
    assert _spike_steps(only_exc, 2) == [20]
    assert _spike_steps(both, 2) == []
    # 0 Hz targets still lose their refractory period (Brian2's poi() sets rfc = 0).
    eng = _run(m, InputSchedule(np.array([0, 1], np.int32), np.zeros(0, np.int64),
                                np.zeros(0, np.int32)), 1)
    assert eng.rfc.tolist() == [0, 0, P.rfc_steps]


def _naive(matrix: SynapseMatrix, schedule: InputSchedule, steps: int, dtype) -> list[tuple]:
    """Straightforward per-step implementation of the same schedule, no shortcuts."""
    f = np.dtype(dtype).type
    n = matrix.n
    a, b, c = (f(x) for x in P.coefficients())
    v = np.full(n, P.v_0, dtype)
    g = np.zeros(n, dtype)
    last = np.full(n, -(10**9))
    rfc = np.full(n, P.rfc_steps)
    rfc[schedule.targets] = 0
    history: list[np.ndarray] = []
    out = []
    for s in range(steps):
        active = (s - last) >= rfc
        v_new = f(P.v_0) + (v - f(P.v_0)) * a + g * b
        v = np.where(active, v_new, v).astype(dtype)
        g = np.where(active, g * c, g).astype(dtype)
        spk = np.flatnonzero(active & (v > f(P.v_th)))
        last[spk] = s
        history.append(spk)
        # Brian2's not_refractory after the thresholder: writes to v and g are
        # conditional on it.
        writable = active.copy()
        writable[spk] = False
        if s >= P.delay_steps:
            for j in history[s - P.delay_steps]:
                lo, hi = matrix.indptr[j], matrix.indptr[j + 1]
                for post, w in zip(matrix.indices[lo:hi], matrix.weights[lo:hi], strict=True):
                    if writable[post]:
                        g[post] += f(P.w_syn) * f(w)
        for k in np.flatnonzero(schedule.steps == s):
            if writable[schedule.neurons[k]]:
                v[schedule.neurons[k]] += f(P.w_input)
        v[spk] = f(P.v_rst)
        g[spk] = 0
        out += [(s, int(i)) for i in spk]
    return out


@pytest.mark.parametrize("kernel", KERNELS)
@pytest.mark.parametrize("dtype", [np.float32, np.float64])
def test_kernel_matches_naive_implementation(dtype, kernel):
    rng = np.random.default_rng(1)
    n, n_edges = 300, 6000
    pre = rng.integers(0, n, n_edges)
    post = rng.integers(0, n, n_edges)
    w = rng.integers(1, 40, n_edges) * np.where(rng.random(n_edges) < 0.25, -1, 1)
    m = SynapseMatrix.from_edges(pre, post, w, n)
    sched = poisson_schedule(rng, np.arange(20), 150.0, 0, 1500, P.dt)
    eng = _run(m, sched, 1500, dtype=dtype, kernel=kernel)
    s, i = eng.spikes_since(0)
    ours = list(zip(s.tolist(), i.tolist(), strict=True))
    assert len(ours) > 1000  # the network is actually active
    assert ours == _naive(m, sched, 1500, dtype)


@pytest.mark.parametrize("kernel", KERNELS)
def test_chunked_advance_and_log_growth_change_nothing(kernel):
    rng = np.random.default_rng(2)
    n = 200
    m = SynapseMatrix.from_edges(rng.integers(0, n, 4000), rng.integers(0, n, 4000),
                                 rng.integers(1, 30, 4000), n)
    sched = poisson_schedule(rng, np.arange(15), 200.0, 0, 3000, P.dt)
    whole = _run(m, sched, 3000)  # plain kernel, in one go

    chunked = CpuEngine(kernel=kernel)
    chunked.load(m, P)
    chunked._log = np.empty(n + 1, np.int32)  # force repeated growth
    chunked.schedule_inputs(sched)
    seen_s, seen_n = [], []
    for stop in range(100, 3001, 100):  # 10 ms chunks, as the live runs step
        before = chunked.step
        chunked.advance_to(stop)
        s, i = chunked.spikes_since(before)
        seen_s.append(s)
        seen_n.append(i)
    ws, wn = whole.spikes_since(0)
    np.testing.assert_array_equal(np.concatenate(seen_s), ws)
    np.testing.assert_array_equal(np.concatenate(seen_n), wn)
    np.testing.assert_array_equal(chunked.snapshot().v, whole.snapshot().v)


def test_reset_restores_rest_and_inputs_cannot_go_back_in_time():
    eng = _run(_matrix([(0, 1, 5)], 2), _inputs({0: [0, 5]}), 50)
    with pytest.raises(ValueError):
        eng.schedule_inputs(_inputs({0: [10]}))
    eng.reset()
    assert eng.step == 0 and np.all(eng.v == P.v_0) and np.all(eng.g == 0)
    assert eng.spikes_since(0)[0].size == 0
    assert eng.rfc.tolist() == [P.rfc_steps] * 2


def test_seeding_is_stable_and_keyed():
    a = trial_rng("E1", "E1/sugar/100Hz", 3).random(4)
    b = trial_rng("E1", "E1/sugar/100Hz", 3).random(4)
    np.testing.assert_array_equal(a, b)
    assert not np.array_equal(a, trial_rng("E1", "E1/sugar/100Hz", 4).random(4))
    assert not np.array_equal(a, trial_rng("E1", "E1/sugar/50Hz", 3).random(4))
    assert trial_rng("E1", "E1/sugar/100Hz", 0).integers(0, 2**31) == PINNED_DRAW


def test_named_seed_namespaces_keep_the_recorded_seeds():
    """The public names of the chain tests and the live worker map to the namespace
    strings the recorded runs were seeded with (draws pinned before the renaming)."""
    assert trial_rng("chain-tests", "LC9/100Hz", 0).integers(0, 2**31) == 1436011335
    assert trial_rng("chain-tests", "control-55/03", 7).integers(0, 2**31) == 707105761
    assert trial_rng("live", "LC4/35Hz", 12).integers(0, 2**31) == 249271961



def test_poisson_rate_and_schedule_merge():
    rng = trial_rng("test", "rate", 0)
    s = poisson_schedule(rng, np.arange(50), 100.0, 0, 10000, P.dt)
    rate = len(s.steps) / 50 / 1.0
    assert 90 < rate < 110
    s2 = poisson_schedule(rng, np.array([60, 61]), 0.0, 0, 10000, P.dt)
    assert len(s2.steps) == 0
    merged = merge(s, s2)
    assert set(merged.targets.tolist()) == set(range(50)) | {60, 61}
    assert np.all(np.diff(merged.steps) >= 0)


def _sparse_net(seed: int, n: int = 3000, n_edges: int = 30000) -> SynapseMatrix:
    """Mostly quiet network: activity spreads from a few stimulated neurons, as in the
    connectome, so neurons leave rest, return to it and leave it again."""
    rng = np.random.default_rng(seed)
    pre, post = rng.integers(0, n, n_edges), rng.integers(0, n, n_edges)
    w = rng.integers(1, 60, n_edges) * np.where(rng.random(n_edges) < 0.3, -1, 1)
    return SynapseMatrix.from_edges(pre, post, w, n)


@pytest.mark.parametrize("seed", [3, 4, 5])
def test_skip_rest_is_bit_identical_to_the_plain_kernel(seed):
    m = _sparse_net(seed)
    rng = np.random.default_rng(seed)
    sched = poisson_schedule(rng, rng.choice(m.n, 40, replace=False), 120.0, 0, 3000, P.dt)
    plain = _run(m, sched, 6000)
    fast = CpuEngine(kernel="skip_rest")
    fast.dense_div = 1  # stay sparse: this test checks the list path
    fast.load(m, P)
    fast.schedule_inputs(sched)
    for stop in (1, 17, 18, 100, 2999, 3000, 3001, 4500, 6000):  # odd chunk edges
        fast.advance_to(stop)
    ps, pn = plain.spikes_since(0)
    fs, fn = fast.spikes_since(0)
    assert len(ps) > 1000
    np.testing.assert_array_equal(fs, ps)
    np.testing.assert_array_equal(fn, pn)
    # the whole state, bit for bit (v and g compared as raw bits, NaN-proof)
    a, b = plain.snapshot(), fast.snapshot()
    np.testing.assert_array_equal(a.v.view(np.int32), b.v.view(np.int32))
    np.testing.assert_array_equal(a.g.view(np.int32), b.g.view(np.int32))
    np.testing.assert_array_equal(a.last_spike, b.last_spike)
    # list invariant (sparse mode): every neuron off rest is listed, the list is sorted
    assert not fast._dense
    off = np.flatnonzero((fast.v != np.float32(P.v_0)) | (fast.g != 0))
    listed = np.union1d(fast._act[fast._cur, : fast._n_act], fast._new[: fast._n_new])
    assert np.isin(off, listed).all()
    cur = fast._act[fast._cur, : fast._n_act]
    assert np.all(np.diff(cur) > 0)
    assert 0 < fast._n_act < m.n  # it actually skips neurons


def test_skip_rest_survives_reset():
    m = _sparse_net(6)
    rng = np.random.default_rng(6)
    sched = poisson_schedule(rng, np.arange(30), 150.0, 0, 1000, P.dt)
    eng = CpuEngine(kernel="skip_rest")
    eng.load(m, P)
    eng.schedule_inputs(sched)
    eng.advance_to(1500)
    first = eng.spikes_since(0)
    eng.reset()
    assert eng._n_act == 0 and eng._n_new == 0 and not eng._flag.any()
    eng.schedule_inputs(sched)
    eng.advance_to(1500)
    for x, y in zip(first, eng.spikes_since(0), strict=True):
        np.testing.assert_array_equal(x, y)


@pytest.mark.parametrize("dense_div", [1, 2, 50, 10**6])
def test_skip_rest_dense_switch_is_bit_identical(dense_div):
    m = _sparse_net(7)
    rng = np.random.default_rng(7)
    sched = poisson_schedule(rng, rng.choice(m.n, 60, replace=False), 150.0, 0, 3000, P.dt)
    plain = _run(m, sched, 6000)
    fast = CpuEngine(kernel="skip_rest")
    fast.dense_div = dense_div
    fast.load(m, P)
    fast.schedule_inputs(sched)
    for stop in (250, 2000, 6000):
        fast.advance_to(stop)
    for x, y in zip(plain.spikes_since(0), fast.spikes_since(0), strict=True):
        np.testing.assert_array_equal(x, y)
    np.testing.assert_array_equal(plain.v.view(np.int32), fast.v.view(np.int32))
    np.testing.assert_array_equal(plain.g.view(np.int32), fast.g.view(np.int32))
    if dense_div in (1, 10**6):  # 1 never switches; 10**6 switches at the first input
        assert fast._dense == (dense_div == 10**6)



def _bits_equal(a: CpuEngine, b: CpuEngine) -> None:
    """Spikes and the whole state, bit for bit (v and g as raw bits, NaN-proof)."""
    for x, y in zip(a.spikes_since(0), b.spikes_since(0), strict=True):
        np.testing.assert_array_equal(x, y)
    bits = np.int32 if a.dtype == np.float32 else np.int64
    np.testing.assert_array_equal(a.v.view(bits), b.v.view(bits))
    np.testing.assert_array_equal(a.g.view(bits), b.g.view(bits))
    np.testing.assert_array_equal(a.last, b.last)


def _until_matches(eng: CpuEngine) -> None:
    """vec's refractory state is last + max(rfc, 1) for every neuron that has spiked."""
    spiked = eng.last > -(2**40)
    np.testing.assert_array_equal(eng._until[spiked],
                                  eng.last[spiked] + np.maximum(eng.rfc[spiked], 1))
    assert np.all(eng._until[~spiked] < -(2**29))


def test_kernel_choice():
    assert CpuEngine().kernel == "vec" and CpuEngine(skip_rest=True).kernel == "vec"
    assert CpuEngine(kernel="skip_rest").kernel == "skip_rest"
    assert CpuEngine(skip_rest=False).kernel == "plain"
    assert CpuEngine(kernel="vec").kernel == "vec"
    with pytest.raises(ValueError):
        CpuEngine(kernel="fast")


@pytest.mark.parametrize("dtype", [np.float32, np.float64])
@pytest.mark.parametrize("dense_div", [1, 2, 50, 10**6])
@pytest.mark.parametrize("seed", [3, 7])
def test_vec_is_bit_identical_to_the_plain_kernel(seed, dense_div, dtype):
    # dense_div 1 never leaves the list path; 10**6 sweeps densely from the first input
    m = _sparse_net(seed)
    rng = np.random.default_rng(seed)
    sched = poisson_schedule(rng, rng.choice(m.n, 60, replace=False), 150.0, 0, 3000, P.dt)
    plain = _run(m, sched, 6000, dtype=dtype)
    fast = CpuEngine(dtype, kernel="vec")
    fast.dense_div = dense_div
    fast.load(m, P)
    fast._log = np.empty(m.n + 1, np.int32)  # force repeated log growth
    fast.schedule_inputs(sched)
    for stop in (1, 17, 18, 100, 511, 2999, 3000, 3001, 4500, 6000):  # odd chunk edges
        fast.advance_to(stop)
    assert len(plain.spikes_since(0)[0]) > 1000
    _bits_equal(plain, fast)
    _until_matches(fast)
    if dense_div in (1, 10**6):
        assert fast._dense == (dense_div == 10**6)


def test_vec_dense_sweep_with_blocks_and_ragged_tail():
    # more neurons than one block, not a multiple of it, dense from the start; a long
    # quiet tail lets g decay into the subnormal range, where it gets stuck: m * c
    # rounds back to m for subnormal mantissas m <= 25, so g never reaches 0
    from flysim.engine.kernel import VEC_BLOCK

    n = 3 * VEC_BLOCK + 77
    m = _sparse_net(8, n=n, n_edges=12 * n)
    rng = np.random.default_rng(8)
    sched = poisson_schedule(rng, rng.choice(n, 40, replace=False), 150.0, 0, 1500, P.dt)
    plain = CpuEngine(kernel="plain")
    fast = CpuEngine(kernel="vec")
    fast.dense_div = 10**6
    subnormal = 0
    for eng in (plain, fast):
        eng.load(m, P)
        eng.schedule_inputs(sched)
    for stop in range(500, 12001, 500):
        plain.advance_to(stop)
        fast.advance_to(stop)
        _bits_equal(plain, fast)
        gb = plain.g.view(np.int32) & 0x7FFFFFFF
        subnormal += int(np.sum((gb > 0) & (gb < 0x00800000)))
    assert fast._dense and subnormal > 0
    gb = plain.g.view(np.int32) & 0x7FFFFFFF
    assert np.all(gb < 0x00800000) and np.any(gb > 0)  # every g is 0 or subnormal


@pytest.mark.parametrize("kernel", ["skip_rest", "vec"])
def test_rfc_change_after_a_spike_is_honoured(kernel):
    # 1 spikes at 20 (kick from 0's spike at 1), so it is refractory for 22 steps. At
    # step 22 it becomes a stimulus target, so rfc drops to 0 and the inputs at 25 and
    # later count at once, as in the plain kernel (rfc is read when it is used).
    m = _matrix([(0, 1, 20000)], 2)
    for k in ("plain", kernel):
        eng = CpuEngine(np.float64, kernel=k)
        eng.load(m, P)
        eng.schedule_inputs(_inputs({0: [0]}))
        eng.advance_to(22)
        eng.schedule_inputs(_inputs({1: [25, 26, 30]}))
        eng.advance_to(60)
        if k == "plain":
            plain = eng
    assert _spike_steps(plain, 1) == [20, 26, 31]
    _bits_equal(plain, eng)
    if kernel == "vec":
        _until_matches(eng)


def test_vec_survives_reset():
    m = _sparse_net(6)
    rng = np.random.default_rng(6)
    sched = poisson_schedule(rng, np.arange(30), 150.0, 0, 1000, P.dt)
    eng = CpuEngine(kernel="vec")
    eng.dense_div = 10**6
    eng.load(m, P)
    eng.schedule_inputs(sched)
    eng.advance_to(1500)
    first = eng.spikes_since(0)
    assert eng._dense
    eng.reset()
    assert not eng._dense and eng._n_act == 0 and not eng._flag.any()
    assert np.all(eng._until < -(2**29)) and eng.rfc.tolist() == [P.rfc_steps] * m.n
    eng.schedule_inputs(sched)
    eng.advance_to(1500)
    for x, y in zip(first, eng.spikes_since(0), strict=True):
        np.testing.assert_array_equal(x, y)