{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5d8cbd11",
   "metadata": {},
   "source": [
    "# Spike trains: storage, encoding, and plotting\n",
    "\n",
    "Spiking models produce rasters: boolean arrays of shape `(n_time, n_neurons)` that are mostly zeros. `braintools.spike` provides three tools for working with them:\n",
    "\n",
    "- the `SpikeTrains` container, which stores only the spike times in a fixed-shape layout that works under `jax.jit` and `jax.vmap`;\n",
    "- the **encoders**, which turn numbers or stimuli into spike rasters;\n",
    "- the **bitwise operations**, which combine spike tensors and stay differentiable for surrogate-gradient spikes.\n",
    "\n",
    "This tutorial covers the dense and event forms of a `SpikeTrains` and the conversions between them, units, the capacity `K` and how overflow is reported, the encoders, and the bitwise operations. It ends by plotting a raster, an ISI histogram and a PSTH with `braintools.visualize`, and by computing a few statistics with `braintools.analysis.spike`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "823a6826",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:21:23.034835Z",
     "iopub.status.busy": "2026-10-19T16:21:23.034683Z",
     "iopub.status.idle": "2026-10-19T16:21:29.420385Z",
     "shell.execute_reply": "2026-10-19T16:21:29.419474Z"
    }
   },
   "outputs": [],
   "source": [
    "import brainstate\n",
    "import brainunit as u\n",
    "import jax\n",
    "import jax.numpy as jnp\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "import braintools\n",
    "from braintools.analysis import spike as spk\n",
    "from braintools.spike import SpikeTrains\n",
    "\n",
    "brainstate.environ.set(dt=0.1 * u.ms)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c18e9f69",
   "metadata": {},
   "source": [
    "## 1. Dense form and event form\n",
    "\n",
    "A **dense** raster has one row per time step and one column per neuron. Here `PoissonEncoder` draws 1 s of Poisson spikes (10,000 steps of 0.1 ms) for four neurons firing at 5, 20, 50 and 100 Hz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a47e42bf",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:21:29.423448Z",
     "iopub.status.busy": "2026-10-19T16:21:29.422950Z",
     "iopub.status.idle": "2026-10-19T16:21:30.269614Z",
     "shell.execute_reply": "2026-10-19T16:21:30.268672Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "raster: (10000, 4) float32  spikes per neuron: [  5.  23.  44. 104.]\n"
     ]
    }
   ],
   "source": [
    "brainstate.random.seed(0)\n",
    "rates = jnp.array([5., 20., 50., 100.])  # Hz\n",
    "raster = braintools.spike.PoissonEncoder()(rates, n_time=10_000)\n",
    "print('raster:', raster.shape, raster.dtype, ' spikes per neuron:', raster.sum(axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1036726a",
   "metadata": {},
   "source": [
    "The raster holds 40,000 numbers for 176 spikes. `SpikeTrains.from_dense` keeps only the spike times. Row `n` of `st.times` holds the `st.counts[n]` spike times of neuron `n` in ascending order, followed by `+inf` padding up to the **capacity** `K`, the length of the longest train. The time step comes from `brainstate.environ` (0.1 ms here), so the times are in milliseconds:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b8c1fd1b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:21:30.272072Z",
     "iopub.status.busy": "2026-10-19T16:21:30.271792Z",
     "iopub.status.idle": "2026-10-19T16:21:31.093188Z",
     "shell.execute_reply": "2026-10-19T16:21:31.092125Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SpikeTrains(n_neurons=4, capacity=104, n_spikes=176, t_start=0. ms, t_stop=1000. ms, overflow=False)\n",
      "counts: [  5  23  44 104]  capacity K = 104\n",
      "first spike times:\n",
      " [[351.1 495.2 754.5 895.4]\n",
      " [  9.9  26.8  35.4  50.4]\n",
      " [ 16.2  75.2  88.4  99.5]\n",
      " [ 13.   54.5  66.9  67.4]] ms\n",
      "padding of neuron 0: [inf inf inf] ms\n",
      "mask (valid entries): (4, 104) 176 valid of 416\n"
     ]
    }
   ],
   "source": [
    "def in_ms(q):\n",
    "    \"\"\"Times as float64 milliseconds rounded to 0.1 ms, for printing.\"\"\"\n",
    "    return np.asarray(q.to_decimal(u.ms), dtype=np.float64).round(1)\n",
    "\n",
    "\n",
    "st = SpikeTrains.from_dense(raster)\n",
    "print(st)\n",
    "print('counts:', st.counts, ' capacity K =', st.capacity)\n",
    "print('first spike times:\\n', in_ms(st.times[:, :4]), 'ms')\n",
    "print('padding of neuron 0:', st.times[0, 5:8])\n",
    "print('mask (valid entries):', st.mask.shape, int(st.mask.sum()), 'valid of', st.mask.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9d4688d",
   "metadata": {},
   "source": [
    "Every field has a static shape: `times` is `(N, K)`, `counts` is `(N,)`, and `t_start`, `t_stop` and `overflow` are scalars. That makes a `SpikeTrains` a JAX pytree that can be passed through `jit` and `vmap` (section 4).\n",
    "\n",
    "The **event** form is a flat, time-sorted list of `(time, neuron)` pairs, as recorded by most simulators and acquisition systems. `to_events` returns it, and `from_events` builds a `SpikeTrains` from it. The events may come in any order; they are sorted per neuron. A ragged list with one array per neuron is a third form, handled by `to_list` and `from_list`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3c5bc2a5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:21:31.095905Z",
     "iopub.status.busy": "2026-10-19T16:21:31.095650Z",
     "iopub.status.idle": "2026-10-19T16:21:32.053218Z",
     "shell.execute_reply": "2026-10-19T16:21:32.052395Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "events: 176\n",
      "first 6 times: [ 9.9 13.  16.2 26.8 35.4 50.4]  neurons: [1 3 2 1 1 1]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "same times after the shuffle: True\n",
      "ragged lengths: [5, 23, 44, 104]\n",
      "from_list round trip: True\n"
     ]
    }
   ],
   "source": [
    "times, ids = st.to_events()\n",
    "print('events:', times.shape[0])\n",
    "print('first 6 times:', in_ms(times[:6]), ' neurons:', ids[:6])\n",
    "\n",
    "rng = np.random.default_rng(0)\n",
    "perm = rng.permutation(times.shape[0])  # shuffle the events\n",
    "st_ev = SpikeTrains.from_events(times[perm], ids[perm], n_neurons=4,\n",
    "                                t_start=0. * u.ms, t_stop=1000. * u.ms)\n",
    "print('same times after the shuffle:', bool(jnp.all(st_ev.times == st.times)))\n",
    "\n",
    "trains = st.to_list()\n",
    "print('ragged lengths:', [len(t) for t in trains])\n",
    "print('from_list round trip:', bool(jnp.all(SpikeTrains.from_list(trains, t_start=0. * u.ms,\n",
    "                                                                    t_stop=1000. * u.ms).times == st.times)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29913ab5",
   "metadata": {},
   "source": [
    "The bounds matter: without `t_start` and `t_stop`, `from_events` and `from_list` use the first and last spike, which would shorten the recording and bias every rate computed from it.\n",
    "\n",
    "`to_dense` goes back to a boolean raster (one row per `dt`), and the round trip is exact:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e3b78fd2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:21:32.055281Z",
     "iopub.status.busy": "2026-10-19T16:21:32.055105Z",
     "iopub.status.idle": "2026-10-19T16:21:32.648983Z",
     "shell.execute_reply": "2026-10-19T16:21:32.648054Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10000, 4) bool  equal to the raster: True\n"
     ]
    }
   ],
   "source": [
    "dense = st.to_dense()\n",
    "print(dense.shape, dense.dtype, ' equal to the raster:', bool((dense == (raster != 0)).all()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a7cd534",
   "metadata": {},
   "source": [
    "## 2. Binning, windows and selections\n",
    "\n",
    "`bin(bin_size)` counts spikes in consecutive bins starting at `t_start`, giving an `(n_bins, N)` array. Dividing the mean count by the bin width gives the firing rate. `window(t0, t1)` keeps the spikes in `[t0, t1)` (with the same capacity), and `select(idx)` keeps a subset of neurons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6ca5d109",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:21:32.651327Z",
     "iopub.status.busy": "2026-10-19T16:21:32.651166Z",
     "iopub.status.idle": "2026-10-19T16:21:33.914626Z",
     "shell.execute_reply": "2026-10-19T16:21:33.913834Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "binned: (10, 4)\n",
      "[[ 0  4  4  8]\n",
      " [ 0  1  5 13]\n",
      " [ 0  2  7 10]]\n",
      "rate (Hz): [  5.       23.       44.      104.00001]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SpikeTrains(n_neurons=4, capacity=104, n_spikes=56, t_start=200. ms, t_stop=500. ms, overflow=False)\n",
      "counts in [200, 500) ms: [ 2  7 15 32]\n",
      "SpikeTrains(n_neurons=2, capacity=104, n_spikes=127, t_start=0. ms, t_stop=1000. ms, overflow=False)\n"
     ]
    }
   ],
   "source": [
    "counts = st.bin(100 * u.ms)\n",
    "print('binned:', counts.shape)\n",
    "print(counts[:3])\n",
    "print('rate (Hz):', counts.mean(axis=0) / 0.1)\n",
    "\n",
    "w = st.window(200 * u.ms, 500 * u.ms)\n",
    "print(w)\n",
    "print('counts in [200, 500) ms:', w.counts)\n",
    "print(st.select([3, 1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6750e30a",
   "metadata": {},
   "source": [
    "The rates are the spike counts per second, 5, 23, 44 and 104 Hz, close to the requested 5, 20, 50 and 100 Hz for a 1 s sample."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb908ee4",
   "metadata": {},
   "source": [
    "## 3. Units, `dt` and `t0`\n",
    "\n",
    "When `dt` is a `brainunit` Quantity (the default from `brainstate.environ` is one here), `times`, `t_start` and `t_stop` are Quantities in that unit, and every time argument (`bin_size`, window bounds, ...) must be a Quantity with time dimensions. Any time unit works: `bin(0.1 * u.second)` gives the same bins as `bin(100 * u.ms)`. `t_start` shifts the time of row 0. With a plain `dt`, the times are plain numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "eefe3e34",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:21:33.917118Z",
     "iopub.status.busy": "2026-10-19T16:21:33.916906Z",
     "iopub.status.idle": "2026-10-19T16:21:34.046726Z",
     "shell.execute_reply": "2026-10-19T16:21:34.045797Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t_start, t_stop: 500. ms 1500. ms\n",
      "first spikes of neuron 1 : [ 9.9 26.8 35.4] -> [509.9 526.8 535.4] ms\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bins in seconds = bins in ms: True\n",
      "unitless times: [ 9.9 26.8 35.4]  t_stop = 1000.0\n"
     ]
    }
   ],
   "source": [
    "st_shift = SpikeTrains.from_dense(raster, dt=0.1 * u.ms, t_start=500 * u.ms)\n",
    "print('t_start, t_stop:', st_shift.t_start, st_shift.t_stop)\n",
    "print('first spikes of neuron 1 :', in_ms(st.times[1, :3]), '->',\n",
    "      in_ms(st_shift.times[1, :3]), 'ms')\n",
    "print('bins in seconds = bins in ms:', bool((st.bin(0.1 * u.second) == counts).all()))\n",
    "\n",
    "st_plain = SpikeTrains.from_dense(raster, dt=0.1)\n",
    "print('unitless times:', np.asarray(st_plain.times[1, :3], dtype=np.float64).round(1), ' t_stop =', st_plain.t_stop)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b013be14",
   "metadata": {},
   "source": [
    "Mixing the two is an error, so a missing unit is caught instead of silently read as milliseconds:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "936cfdf3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:21:34.049322Z",
     "iopub.status.busy": "2026-10-19T16:21:34.049121Z",
     "iopub.status.idle": "2026-10-19T16:21:34.053371Z",
     "shell.execute_reply": "2026-10-19T16:21:34.052655Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TypeError: `t_start` must be a Quantity compatible with ms because `dt` is a Quantity; got the plain value 5.0.\n",
      "UnitMismatchError: Cannot convert to the decimal number using a unit with different dimensions. (units are mV and ms).\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    SpikeTrains.from_dense(raster, dt=0.1 * u.ms, t_start=5.)\n",
    "except TypeError as e:\n",
    "    print('TypeError:', e)\n",
    "try:\n",
    "    st.bin(1 * u.mV)\n",
    "except u.UnitMismatchError as e:\n",
    "    print('UnitMismatchError:', e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "462e2ab1",
   "metadata": {},
   "source": [
    "## 4. Capacity and overflow\n",
    "\n",
    "The capacity `K` is part of the array shapes, so it must be fixed when a function is traced:\n",
    "\n",
    "- With concrete input and `capacity=None`, `K` is the largest spike count (104 above).\n",
    "- With concrete input, a capacity that is too small raises `ValueError` right away.\n",
    "- Inside `jit` or `vmap`, the counts are not known at trace time, so `capacity` must be given. If a neuron fires more often, its first `K` spikes are kept, its count is clipped to `K`, and the `overflow` flag is set. The function cannot raise inside the transform; call `check()` on the result afterwards to turn the flag into an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4883ef7d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:21:34.055875Z",
     "iopub.status.busy": "2026-10-19T16:21:34.055683Z",
     "iopub.status.idle": "2026-10-19T16:21:34.196399Z",
     "shell.execute_reply": "2026-10-19T16:21:34.195413Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ValueError: SpikeTrains.from_dense: neuron 3 has 104 spikes, more than capacity=50. Increase `capacity`, or pass `capacity=None` to size it from the data.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SpikeTrains(n_neurons=4, capacity=64, n_spikes=136, t_start=0. ms, t_stop=1000. ms, overflow=True)\n",
      "counts: [ 5 23 44 64]  overflow: True\n",
      "ValueError: SpikeTrains overflow: some neuron had more than capacity=64 spikes, and the extra spikes were dropped. Rebuild with a larger `capacity`.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    SpikeTrains.from_dense(raster, capacity=50)\n",
    "except ValueError as e:\n",
    "    print('ValueError:', e)\n",
    "\n",
    "to_trains = jax.jit(lambda r: SpikeTrains.from_dense(r, dt=0.1 * u.ms, capacity=64))\n",
    "st_j = to_trains(raster)\n",
    "print(st_j)\n",
    "print('counts:', st_j.counts, ' overflow:', bool(st_j.overflow))\n",
    "try:\n",
    "    st_j.check()\n",
    "except ValueError as e:\n",
    "    print('ValueError:', e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a7ebaac",
   "metadata": {},
   "source": [
    "Neuron 3 had 104 spikes, so with `K = 64` it lost 40 of them and `overflow` is `True`. A safe capacity is an upper bound on the count: the number of time steps always works, and for a known rate a bound a few standard deviations above the expected count is enough.\n",
    "\n",
    "`jax.vmap` builds one `SpikeTrains` per trial with a shared capacity. Below are 20 trials of the same four neurons. With `K = 110`, a trial overflows whenever the 100 Hz neuron fires more than 110 spikes, and `overflow` (one flag per trial) shows which trials did. With `K = 160` none do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a2f87c19",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:21:34.199538Z",
     "iopub.status.busy": "2026-10-19T16:21:34.199262Z",
     "iopub.status.idle": "2026-10-19T16:21:36.028454Z",
     "shell.execute_reply": "2026-10-19T16:21:36.027611Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "trials: (20, 10000, 4)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "K=110: times (20, 4, 110), trials with overflow: [16]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "K=160: times (20, 4, 160), trials with overflow: []\n",
      "true counts of the 100 Hz neuron: [93, 95, 106, 88, 107, 94, 106, 104, 102, 75, 94, 92, 85, 102, 87, 100, 112, 94, 101, 107]\n",
      "mean count per neuron: [ 4.       20.75     46.8      97.200005]\n"
     ]
    }
   ],
   "source": [
    "brainstate.random.seed(1)\n",
    "trials = braintools.spike.PoissonEncoder()(jnp.tile(rates, (20, 1)), n_time=10_000)  # (T, 20, 4)\n",
    "trials = jnp.moveaxis(trials, 1, 0)                                                 # (20, T, 4)\n",
    "print('trials:', trials.shape)\n",
    "\n",
    "for K in (110, 160):\n",
    "    batched = jax.vmap(lambda r: SpikeTrains.from_dense(r, dt=0.1 * u.ms, capacity=K))(trials)\n",
    "    print(f'K={K}: times {batched.times.shape}, trials with overflow: '\n",
    "          f'{np.flatnonzero(np.asarray(batched.overflow)).tolist()}')\n",
    "print('true counts of the 100 Hz neuron:', np.asarray(trials[:, :, 3].sum(axis=1), dtype=int).tolist())\n",
    "print('mean count per neuron:', np.asarray(batched.counts.mean(axis=0)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17c5327e",
   "metadata": {},
   "source": [
    "## 5. Encoders: from stimuli to spikes\n",
    "\n",
    "The encoders in `braintools.spike` turn numbers or time series into spike rasters with time on axis 0, which go straight into `SpikeTrains.from_dense` (`StepCurrentEncoder` is the exception: it returns an input current for a neuron model):\n",
    "\n",
    "| Encoder | Code |\n",
    "|---|---|\n",
    "| `RateEncoder`, `PoissonEncoder`, `BernoulliEncoder` | the value sets a firing rate or a spike probability per step |\n",
    "| `PopulationEncoder` | a population with Gaussian tuning curves; the bump of activity marks the value |\n",
    "| `LatencyEncoder`, `RankOrderEncoder` | one spike per feature; larger values fire earlier |\n",
    "| `SpikeCountEncoder` | a fixed number of spikes that grows with the value |\n",
    "| `DeltaEncoder`, `StepCurrentEncoder` | changes of a signal; a current that drives a neuron model |\n",
    "| `TemporalEncoder` | a fixed random spike pattern per symbol |\n",
    "\n",
    "Below, eight values evenly spaced in `[0, 1]` are encoded for 200 ms by four of them. The population code encodes the single value 0.3 with 16 neurons whose preferred values tile `[0, 1]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f8252df5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:21:36.031011Z",
     "iopub.status.busy": "2026-10-19T16:21:36.030768Z",
     "iopub.status.idle": "2026-10-19T16:21:39.813139Z",
     "shell.execute_reply": "2026-10-19T16:21:39.812051Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RateEncoder (rate = 100 Hz * x)      raster (2000, 8)  counts [0, 6, 6, 9, 12, 11, 11, 23]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PoissonEncoder (normalize, 100 Hz)   raster (2000, 8)  counts [0, 3, 3, 14, 7, 16, 22, 9]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LatencyEncoder (linear)              raster (2000, 8)  counts [1, 1, 1, 1, 1, 1, 1, 1]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PopulationEncoder (value 0.3)        raster (2000, 16)  counts [2, 3, 13, 23, 35, 34, 26, 17, 3, 0, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x320 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "brainstate.random.seed(2)\n",
    "x = jnp.linspace(0., 1., 8)\n",
    "encoded = {\n",
    "    'RateEncoder (rate = 100 Hz * x)': braintools.spike.RateEncoder(gain=100.)(x, n_time=2000),\n",
    "    'PoissonEncoder (normalize, 100 Hz)': braintools.spike.PoissonEncoder(normalize=True, max_rate=100.)(x, n_time=2000),\n",
    "    'LatencyEncoder (linear)': braintools.spike.LatencyEncoder(method='linear', normalize=True)(x, n_time=2000),\n",
    "    'PopulationEncoder (value 0.3)': braintools.spike.PopulationEncoder(n_neurons=16, sigma=0.1, max_rate=200.)(0.3, n_time=2000),\n",
    "}\n",
    "fig, axes = plt.subplots(1, 4, figsize=(14, 3.2))\n",
    "for ax, (name, r) in zip(axes, encoded.items()):\n",
    "    trains_e = SpikeTrains.from_dense(r)\n",
    "    print(f'{name:36s} raster {tuple(r.shape)}  counts {np.asarray(trains_e.counts).tolist()}')\n",
    "    braintools.visualize.spike_raster(trains_e, ax=ax, markersize=30, title=name)\n",
    "    ax.set_ylim(-0.5, r.shape[1] - 0.5)\n",
    "for ax in axes[:3]:\n",
    "    ax.set_ylabel('input index (value grows upward)')\n",
    "axes[3].set_ylabel('neuron (preferred value grows upward)')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18effd31",
   "metadata": {},
   "source": [
    "The rate codes fire more often for larger values (input 0, at value 0, stays silent); the latency code fires once per input, earlier for larger values (input 7, at value 1, fires at 0 ms); and the population code peaks at neurons 4 and 5, whose preferred values 0.27 and 0.33 surround 0.3. The {doc}`spike-encoding tutorial <../misc/spike_encoding>` covers all ten encoders and checks each against the rates, timings or counts it should produce."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b135ae37",
   "metadata": {},
   "source": [
    "## 6. Bitwise spike operations\n",
    "\n",
    "`bitwise_or`, `bitwise_and`, `bitwise_xor`, `bitwise_not`, `bitwise_iand` (`(NOT x) AND y`) and `bitwise_ixor` combine spike tensors element-wise, and `bitwise(x, y, op)` dispatches by name. For 0/1 values they compute the logical operations through arithmetic identities, for example `x OR y = x + y - x y`. Here two independent 50 Hz Poisson rasters of 100 neurons over 100 ms are combined, and the counts obey the identities `|A OR B| = |A| + |B| - |A AND B|` and `|A XOR B| = |A OR B| - |A AND B|`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b80dd973",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:21:39.815852Z",
     "iopub.status.busy": "2026-10-19T16:21:39.815570Z",
     "iopub.status.idle": "2026-10-19T16:21:40.766254Z",
     "shell.execute_reply": "2026-10-19T16:21:40.765178Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|A| = 510, |B| = 533, |A OR B| = 1041, |A AND B| = 2, |A XOR B| = 1039\n",
      "OR identity : True  XOR identity: True\n",
      "NOT A       : 99490 = 100000 - 510\n",
      "bitwise(A, B, 'iand') equals (NOT A) AND B: True\n"
     ]
    }
   ],
   "source": [
    "brainstate.random.seed(3)\n",
    "A = braintools.spike.PoissonEncoder()(jnp.full(100, 50.), n_time=1000)\n",
    "B = braintools.spike.PoissonEncoder()(jnp.full(100, 50.), n_time=1000)\n",
    "n_a, n_b = int(A.sum()), int(B.sum())\n",
    "n_or = int(braintools.spike.bitwise_or(A, B).sum())\n",
    "n_and = int(braintools.spike.bitwise_and(A, B).sum())\n",
    "n_xor = int(braintools.spike.bitwise_xor(A, B).sum())\n",
    "print(f'|A| = {n_a}, |B| = {n_b}, |A OR B| = {n_or}, |A AND B| = {n_and}, |A XOR B| = {n_xor}')\n",
    "print('OR identity :', n_or == n_a + n_b - n_and, ' XOR identity:', n_xor == n_or - n_and)\n",
    "print('NOT A       :', int(braintools.spike.bitwise_not(A).sum()), '=', A.size, '-', n_a)\n",
    "print(\"bitwise(A, B, 'iand') equals (NOT A) AND B:\",\n",
    "      bool((braintools.spike.bitwise(A, B, 'iand') == braintools.spike.bitwise_and(1 - A, B)).all()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4661ac7",
   "metadata": {},
   "source": [
    "Coincidences are rare: with a spike probability of about 0.005 per step and neuron, only a handful of the 100,000 entries are 1 in both rasters.\n",
    "\n",
    "With boolean inputs the operations use the logical functions and return a boolean mask. With floating-point inputs, such as the spikes of a surrogate-gradient neuron, the identities are differentiable: the gradient of `x OR y` with respect to `x` is `1 - y`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "00f7804d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:21:40.768761Z",
     "iopub.status.busy": "2026-10-19T16:21:40.768549Z",
     "iopub.status.idle": "2026-10-19T16:21:41.059019Z",
     "shell.execute_reply": "2026-10-19T16:21:41.058276Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bool in ->  bool\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d(x OR y)/dx = [1. 1. 0. 0.]  1 - y = [1. 1. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "print('bool in -> ', braintools.spike.bitwise_or(A > 0, B > 0).dtype)\n",
    "x_s = jnp.array([0., 1., 0., 1.])\n",
    "y_s = jnp.array([0., 0., 1., 1.])\n",
    "grad_x = jax.grad(lambda a: braintools.spike.bitwise_or(a, y_s).sum())(x_s)\n",
    "print('d(x OR y)/dx =', grad_x, ' 1 - y =', 1 - y_s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48187ec6",
   "metadata": {},
   "source": [
    "## 7. Plotting a `SpikeTrains`\n",
    "\n",
    "The spike plots of `braintools.visualize` accept a `SpikeTrains` directly and label the time axis with its unit. To get data with structure, we simulate 40 noisy leaky integrate-and-fire (LIF) neurons for 2 s. Each neuron gets a constant drive near threshold plus white noise, and a stimulus raises the drive during [500, 700) ms and [1300, 1500) ms. After a spike the membrane is held at reset for a 2 ms refractory period.\n",
    "\n",
    "The 20,000 time steps run in one compiled `brainstate.transform.for_loop`. The membrane potential and the refractory timer are `brainstate.State`s, which the loop carries automatically, and the stacked spikes form the raster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "36d26722",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:21:41.060846Z",
     "iopub.status.busy": "2026-10-19T16:21:41.060658Z",
     "iopub.status.idle": "2026-10-19T16:21:42.071245Z",
     "shell.execute_reply": "2026-10-19T16:21:42.070659Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SpikeTrains(n_neurons=40, capacity=61, n_spikes=1991, t_start=0. ms, t_stop=2000. ms, overflow=False)\n",
      "mean rate: 24.9 Hz\n"
     ]
    }
   ],
   "source": [
    "N, T = 40, 20_000                      # neurons, steps of 0.1 ms (2 s)\n",
    "dt, tau = 0.1, 20.                     # ms\n",
    "v_th, v_reset, t_ref, sigma = 1., 0., 2., 0.25\n",
    "stim_on = jnp.zeros(T).at[5000:7000].set(1.).at[13000:15000].set(1.)\n",
    "\n",
    "brainstate.random.seed(4)\n",
    "drive = brainstate.random.uniform(0.9, 1.1, N)\n",
    "v = brainstate.State(jnp.zeros(N))\n",
    "refractory = brainstate.State(jnp.zeros(N))\n",
    "\n",
    "\n",
    "def lif_step(i):\n",
    "    noise = sigma * jnp.sqrt(tau / dt) * brainstate.random.randn(N)\n",
    "    I = drive + 0.6 * stim_on[i] + noise\n",
    "    v_new = jnp.where(refractory.value > 0, v_reset, v.value + dt / tau * (I - v.value))\n",
    "    spike = v_new >= v_th\n",
    "    v.value = jnp.where(spike, v_reset, v_new)\n",
    "    refractory.value = jnp.where(spike, t_ref, jnp.maximum(refractory.value - dt, 0.))\n",
    "    return spike\n",
    "\n",
    "\n",
    "lif_raster = brainstate.transform.for_loop(lif_step, jnp.arange(T))\n",
    "lif = SpikeTrains.from_dense(lif_raster)   # dt = 0.1 ms from brainstate.environ\n",
    "print(lif)\n",
    "print(f'mean rate: {float(lif.counts.mean()) / 2.0:.1f} Hz')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "589a1307",
   "metadata": {},
   "source": [
    "For comparison, a Poisson population with the same mean rate has no refractory period and no memory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "389dfa40",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:21:42.073770Z",
     "iopub.status.busy": "2026-10-19T16:21:42.073539Z",
     "iopub.status.idle": "2026-10-19T16:21:43.072683Z",
     "shell.execute_reply": "2026-10-19T16:21:43.072029Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SpikeTrains(n_neurons=40, capacity=65, n_spikes=2031, t_start=0. ms, t_stop=2000. ms, overflow=False)\n"
     ]
    }
   ],
   "source": [
    "brainstate.random.seed(5)\n",
    "mean_rate = float(lif.counts.mean()) / 2.0\n",
    "pois = SpikeTrains.from_dense(braintools.spike.PoissonEncoder()(jnp.full(N, mean_rate), n_time=T))\n",
    "print(pois)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ed08f5a",
   "metadata": {},
   "source": [
    "`spike_raster` draws the raster, `spike_histogram` the population PSTH (all neurons pooled, here in 20 ms bins), and `isi_distribution` the histogram of inter-spike intervals within each neuron, with their mean and CV in the box."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "db5561c1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:21:43.074746Z",
     "iopub.status.busy": "2026-10-19T16:21:43.074573Z",
     "iopub.status.idle": "2026-10-19T16:21:45.115259Z",
     "shell.execute_reply": "2026-10-19T16:21:45.114541Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x700 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(2, 2, figsize=(12, 7))\n",
    "braintools.visualize.spike_raster(lif, ax=axes[0, 0], markersize=4, title='LIF population')\n",
    "braintools.visualize.spike_histogram(lif, bin_size=20 * u.ms, time_range=(0 * u.ms, 2000 * u.ms),\n",
    "                                     ax=axes[1, 0], title='population PSTH (20 ms bins)')\n",
    "for ax in axes[:, 0]:\n",
    "    for t_on in (500, 1300):\n",
    "        ax.axvspan(t_on, t_on + 200, color='orange', alpha=0.2)\n",
    "isi_bins = np.arange(0, 122, 2)  # ms; the histogram shows intervals up to 120 ms\n",
    "braintools.visualize.isi_distribution(lif, bins=isi_bins, ax=axes[0, 1], xlabel='ISI (ms)',\n",
    "                                      title='ISI, LIF')\n",
    "braintools.visualize.isi_distribution(pois, bins=isi_bins, ax=axes[1, 1], color='gray',\n",
    "                                      xlabel='ISI (ms)', title='ISI, Poisson (same rate)')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7b2b8b8",
   "metadata": {},
   "source": [
    "The raster and the PSTH show the population rate rising during the two stimuli (shaded). The two ISI histograms differ in shape. After a spike, an LIF neuron must charge from reset back to threshold, so intervals shorter than about 12 ms do not occur and the histogram peaks near 20 ms. The Poisson intervals are exponential, with the most intervals in the first bins. The box reports the mean and the CV of all intervals pooled over neurons; the bins only limit what is drawn."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f30d431c",
   "metadata": {},
   "source": [
    "## 8. Spike statistics with `braintools.analysis.spike`\n",
    "\n",
    "The statistics in `braintools.analysis.spike` take a `SpikeTrains` too and return one value per neuron. They are JAX functions, so they work under `jit` and `vmap`. Three common ones:\n",
    "\n",
    "- `cv(trains)`: the coefficient of variation of the inter-spike intervals (1 for a Poisson process, 0 for a clock);\n",
    "- `fano_factor(trains, bin_size)`: the variance-to-mean ratio of the spike counts in bins (1 for a Poisson process);\n",
    "- `psth(trains, events, window, bin_size)`: the event-aligned peri-stimulus time histogram, averaged over the events, in Hz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "96813b0b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-19T16:21:45.117622Z",
     "iopub.status.busy": "2026-10-19T16:21:45.117328Z",
     "iopub.status.idle": "2026-10-19T16:21:46.984469Z",
     "shell.execute_reply": "2026-10-19T16:21:46.983710Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CV          LIF 0.55   Poisson 1.02\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fano (100 ms) LIF 0.70   Poisson 1.01\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "psth: (35, 40)  edges -200. ms ... 500. ms\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "population rate before onset: 18.9 Hz, during the stimulus: 47.2 Hz\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(f'CV          LIF {float(jnp.nanmean(spk.cv(lif))):.2f}   Poisson {float(jnp.nanmean(spk.cv(pois))):.2f}')\n",
    "print(f'Fano (100 ms) LIF {float(jnp.nanmean(spk.fano_factor(lif, 100 * u.ms))):.2f}   '\n",
    "      f'Poisson {float(jnp.nanmean(spk.fano_factor(pois, 100 * u.ms))):.2f}')\n",
    "\n",
    "onsets = jnp.array([500., 1300.]) * u.ms\n",
    "rate, edges = spk.psth(lif, onsets, window=(200 * u.ms, 500 * u.ms), bin_size=20 * u.ms)\n",
    "print('psth:', rate.shape, ' edges', edges[0], '...', edges[-1])\n",
    "centers = ((edges[:-1] + edges[1:]) / 2).to_decimal(u.ms)\n",
    "pop_rate = np.asarray(rate.mean(axis=1))\n",
    "print(f'population rate before onset: {pop_rate[centers < 0].mean():.1f} Hz, '\n",
    "      f'during the stimulus: {pop_rate[(centers > 0) & (centers < 200)].mean():.1f} Hz')\n",
    "\n",
    "plt.figure(figsize=(7, 3))\n",
    "plt.step(centers, pop_rate, where='mid', color='C3', lw=2, label='population mean')\n",
    "plt.axvspan(0, 200, color='orange', alpha=0.2, label='stimulus')\n",
    "plt.xlabel('time from stimulus onset (ms)')\n",
    "plt.ylabel('rate (Hz)')\n",
    "plt.title('event-aligned PSTH (2 onsets, 20 ms bins)')\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a835392",
   "metadata": {},
   "source": [
    "The LIF neurons fire more regularly than a Poisson process: their mean CV (0.55) and Fano factor (0.70) are below 1, while the Poisson population is close to 1 for both. The PSTH aligns the spikes to the two stimulus onsets and averages over them: the population rate jumps from about 19 Hz to about 47 Hz at onset and falls back when the stimulus ends at 200 ms.\n",
    "\n",
    "The CV printed here is the mean of the per-neuron CVs, while the box of `isi_distribution` pools the intervals of all neurons first. Pooling mixes neurons with different mean rates, which widens the distribution, so the pooled CV is a little larger.\n",
    "\n",
    "For the rest of the toolbox (correlograms, spike-train distances, synchrony, spike-triggered averages) see the {doc}`analysis tutorials <../analysis/index>`, and for the full list of spike functions the {doc}`API reference <../apis/spike>`."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}