lockkernel 1.1.0__py3-none-any.whl

lockkernel/exact.py

@@ -0,0 +1,243 @@
+"""Exact references used to validate the cumulant solver.
+
+Two independent references are provided.
+
+DEGENERATE LINE.  When every detuning is equal the Hamiltonian reduces, on the
+maximal spin manifold that the coherent spin state occupies, to
+
+    H = chi1 S+ S- = chi1 (S^2 - S_z^2 + S_z),
+
+which is diagonal in the S_z basis.  The evolution of the coherent spin state
+is therefore exact and cheap for any emitter number: it is one axis twisting
+in disguise.  `symmetric_exact` uses this.
+
+INHOMOGENEOUS LINE.  With several distinct detunings the maximal spin manifold
+is no longer closed, and the reference is exact diagonalisation of the full
+Hamiltonian in the 2^N dimensional Hilbert space.  `full_exact` does this for
+small emitter numbers, which is enough to test the structure of the cumulant
+equations term by term.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+__all__ = ["symmetric_exact", "full_exact"]
+
+
+def _wineland_from_moments(J, Cov, N):
+    Jn = np.linalg.norm(J)
+    if Jn == 0:
+        return np.inf
+    e3 = J / Jn
+    trial = np.array([0.0, 0.0, 1.0]) if abs(e3[2]) < 0.9 else np.array([1.0, 0.0, 0.0])
+    e1 = np.cross(e3, trial)
+    e1 /= np.linalg.norm(e1)
+    e2 = np.cross(e3, e1)
+    B = np.stack([e1, e2], axis=1)
+    vals = np.linalg.eigvalsh(B.T @ Cov @ B)
+    return float(vals[0] * N / Jn ** 2)
+
+
+def symmetric_exact(N: int, chiN: float, times):
+    """Exact contrast and Wineland parameter for a degenerate line.
+
+    The state stays in the maximal spin manifold, of dimension N+1, and the
+    Hamiltonian is diagonal there, so this is exact to machine precision at
+    any emitter number.
+
+    Returns (contrast, xi2), each an array over `times`.
+    """
+    S = N / 2.0
+    m = np.arange(-S, S + 1)                      # S_z eigenvalues
+    chi1 = chiN / N
+    E = chi1 * (S * (S + 1) - m ** 2 + m)         # eigenvalues of chi1 S+ S-
+
+    # Coherent spin state along +x in the S_z basis: binomial amplitudes.
+    k = np.arange(N + 1)
+    logc = 0.5 * (np.array([_log_binom(N, kk) for kk in k]) - N * np.log(2.0))
+    amp = np.exp(logc)                            # real and positive
+
+    sp = np.sqrt(S * (S + 1) - m[:-1] * (m[:-1] + 1))   # <m+1|S+|m>
+    contrast, xi2 = [], []
+    for t in np.atleast_1d(times):
+        psi = amp * np.exp(-1j * E * t)
+        # <S+> = sum_m conj(psi_{m+1}) sp_m psi_m
+        Sp = np.sum(np.conj(psi[1:]) * sp * psi[:-1])
+        Sz = np.sum(np.abs(psi) ** 2 * m)
+        Sz2 = np.sum(np.abs(psi) ** 2 * m ** 2)
+        # <S+ S+>
+        spp = sp[:-1] * sp[1:]
+        Spp = np.sum(np.conj(psi[2:]) * spp * psi[:-2])
+        # <S+ S-> = <S^2 - S_z^2 + S_z>
+        Spm = S * (S + 1) - Sz2 + Sz
+        # <S_z S+ + S+ S_z>
+        SzSp = np.sum(np.conj(psi[1:]) * m[1:] * sp * psi[:-1])
+        SpSz = np.sum(np.conj(psi[1:]) * sp * m[:-1] * psi[:-1])
+
+        Sx = Sp.real
+        Sy = Sp.imag
+        Sxx = 0.5 * (Spp.real + Spm.real)          # (S+^2 + S-^2 + S+S- + S-S+)/4
+        Syy = 0.5 * (-Spp.real + Spm.real)
+        Sxy = 0.5 * Spp.imag                       # symmetrised
+        Sxz = 0.5 * (SzSp + SpSz).real
+        Syz = 0.5 * (SzSp + SpSz).imag
+        J = np.array([Sx, Sy, Sz.real])
+        Cov = np.array([[Sxx - Sx ** 2, Sxy - Sx * Sy, Sxz - Sx * Sz.real],
+                        [Sxy - Sx * Sy, Syy - Sy ** 2, Syz - Sy * Sz.real],
+                        [Sxz - Sx * Sz.real, Syz - Sy * Sz.real, Sz2 - Sz.real ** 2]])
+        Cov = 0.5 * (Cov + Cov.T).real
+        contrast.append(2.0 * np.hypot(Sx, Sy) / N)
+        xi2.append(_wineland_from_moments(J, Cov, N))
+    return np.array(contrast), np.array(xi2)
+
+
+def _log_binom(n, k):
+    from math import lgamma
+    return lgamma(n + 1) - lgamma(k + 1) - lgamma(n - k + 1)
+
+
+def full_exact(deltas, chiN: float, times):
+    """Exact diagonalisation of the full Hamiltonian for a small ensemble.
+
+    `deltas` lists the detuning of every individual emitter, so the emitter
+    number is len(deltas) and the Hilbert space has 2^N dimensions.  Practical
+    up to about twelve emitters.
+
+    Returns (contrast, xi2), each an array over `times`.
+    """
+    deltas = np.asarray(deltas, float)
+    N = len(deltas)
+    dim = 2 ** N
+    chi1 = chiN / N
+
+    sx = np.array([[0, 1], [1, 0]], complex)
+    sy = np.array([[0, -1j], [1j, 0]], complex)
+    sz = np.array([[1, 0], [0, -1]], complex)
+    sp = np.array([[0, 1], [0, 0]], complex)      # |up><down|
+    sm = sp.T.copy()
+
+    def op(single, j):
+        out = np.array([[1.0 + 0j]])
+        for i in range(N):
+            out = np.kron(out, single if i == j else np.eye(2))
+        return out
+
+    SP = [op(sp, j) for j in range(N)]
+    SM = [op(sm, j) for j in range(N)]
+    SZ = [op(sz, j) for j in range(N)]
+    SX = [op(sx, j) for j in range(N)]
+    SY = [op(sy, j) for j in range(N)]
+
+    H = np.zeros((dim, dim), complex)
+    for j in range(N):
+        H += 0.5 * deltas[j] * SZ[j]
+        for k in range(N):
+            H += chi1 * (SP[j] @ SM[k])
+
+    Jx = 0.5 * sum(SX)
+    Jy = 0.5 * sum(SY)
+    Jz = 0.5 * sum(SZ)
+
+    w, V = np.linalg.eigh(H)
+    psi0 = np.ones(dim, complex) / np.sqrt(dim)   # all emitters along +x
+    c0 = V.conj().T @ psi0
+
+    contrast, xi2 = [], []
+    Js = [Jx, Jy, Jz]
+    for t in np.atleast_1d(times):
+        psi = V @ (np.exp(-1j * w * t) * c0)
+        mean = np.array([np.vdot(psi, A @ psi).real for A in Js])
+        Cov = np.empty((3, 3))
+        for a in range(3):
+            for b in range(3):
+                Cov[a, b] = 0.5 * np.vdot(psi, (Js[a] @ Js[b] + Js[b] @ Js[a]) @ psi).real
+        Cov -= np.outer(mean, mean)
+        contrast.append(2.0 * np.hypot(mean[0], mean[1]) / N)
+        xi2.append(_wineland_from_moments(mean, Cov, N))
+    return np.array(contrast), np.array(xi2)
+
+
+def class_exact(deltas, populations, chiN: float, times, tol=1e-9):
+    """Exact dynamics of an inhomogeneous ensemble in the collective spin basis.
+
+    Emitters within a class are exchange symmetric and start in a symmetric
+    state, so each class stays in its maximal spin manifold of dimension
+    n_j + 1.  The Hilbert space is therefore the product of those manifolds,
+    of dimension prod(n_j + 1) rather than 2^N, which puts exact dynamics of a
+    genuinely inhomogeneous ensemble within reach for emitter numbers of a few
+    tens.  This is the reference that fixes how far the cumulant expansion can
+    be trusted at finite N.
+
+    Returns (contrast, xi2), each an array over `times`.
+    """
+    import numpy as _np
+    from scipy import sparse
+    from scipy.sparse.linalg import expm_multiply
+
+    deltas = _np.asarray(deltas, float)
+    pops = _np.asarray(populations, int)
+    M = len(pops)
+    N = int(pops.sum())
+    chi1 = chiN / N
+    dims = pops + 1
+
+    def spin_ops(n):
+        """S+, Sz for a spin of length n/2, in the S_z basis, as sparse."""
+        S = n / 2.0
+        m = _np.arange(-S, S + 1)
+        d = n + 1
+        up = _np.sqrt(S * (S + 1) - m[:-1] * (m[:-1] + 1))
+        Sp = sparse.diags(up, offsets=-1, shape=(d, d), format="csr")  # |m+1><m|
+        Sz = sparse.diags(m, format="csr")
+        return Sp, Sz
+
+    def embed(op, j):
+        out = sparse.identity(1, format="csr")
+        for i in range(M):
+            out = sparse.kron(out, op if i == j else sparse.identity(dims[i]),
+                              format="csr")
+        return out
+
+    SP, SZ = [], []
+    for j in range(M):
+        sp, sz = spin_ops(pops[j])
+        SP.append(embed(sp, j))
+        SZ.append(embed(sz, j))
+
+    Jp = sum(SP)
+    Jz = sum(SZ)
+    H = chi1 * (Jp @ Jp.getH()) + sum(deltas[j] * SZ[j] for j in range(M))
+    H = ((H + H.getH()) * 0.5).tocsr()
+
+    Jx = 0.5 * (Jp + Jp.getH())
+    Jy = -0.5j * (Jp - Jp.getH())
+    Js = [Jx.tocsr(), Jy.tocsr(), Jz.tocsr()]
+
+    # coherent spin state along +x: a product of x polarised class states
+    psi = _np.ones(1, complex)
+    for j in range(M):
+        n = pops[j]
+        k = _np.arange(n + 1)
+        amp = _np.exp(0.5 * (_np.array([_log_binom(n, kk) for kk in k])
+                             - n * _np.log(2.0)))
+        psi = _np.kron(psi, amp)
+    psi /= _np.linalg.norm(psi)
+
+    contrast, xi2 = [], []
+    prev = 0.0
+    state = psi
+    for t in _np.atleast_1d(times):
+        if t > prev:
+            state = expm_multiply(-1j * (t - prev) * H, state)
+            prev = t
+        mean = _np.array([_np.vdot(state, A @ state).real for A in Js])
+        Cov = _np.empty((3, 3))
+        for a in range(3):
+            va = Js[a] @ state
+            for b in range(a, 3):
+                vb = Js[b] @ state
+                Cov[a, b] = Cov[b, a] = _np.vdot(va, vb).real
+        Cov = 0.5 * (Cov + Cov.T) - _np.outer(mean, mean)
+        contrast.append(2.0 * _np.hypot(mean[0], mean[1]) / N)
+        xi2.append(_wineland_from_moments(mean, Cov, N))
+    return _np.array(contrast), _np.array(xi2)

lockkernel/kernels.py

@@ -0,0 +1,214 @@
+"""Locking kernels.
+
+A locking kernel W(u) is the time averaged projection of an oscillator on the
+mean field, as a function of the detuning measured in units of the locking
+bandwidth, u = delta / Omega.  It is normalised so that a resonant oscillator
+follows the field perfectly, W(0) = 1, and it is even.
+
+Two kernels matter physically.
+
+* Conservative spins.  An off resonant spin precesses about a tilted axis and
+  keeps a nonzero time averaged projection on the mean field for every
+  detuning.  The projection is
+
+      W(u) = 1 / (1 + u^2),
+
+  an ALGEBRAIC kernel with tail exponent s = 2.
+
+* Overdamped phase oscillators, the Kuramoto case.  An oscillator that cannot
+  be entrained drifts, and its time averaged contribution vanishes exactly.
+  The kernel is COMPACTLY SUPPORTED,
+
+      W(u) = sqrt(1 - u^2) for |u| < 1 and 0 otherwise.
+
+The one parameter family
+
+      W_s(u) = 1 / (1 + |u|^s),   s > 1,
+
+interpolates between them in the sense that matters here, namely the tail, and
+is what the universality line is tested against.
+"""
+from __future__ import annotations
+
+import dataclasses
+from typing import Callable
+
+import mpmath as mp
+
+__all__ = ["Kernel", "conservative", "kuramoto", "power_tail",
+           "gaussian_kernel", "KERNELS"]
+
+
+@dataclasses.dataclass(frozen=True)
+class Kernel:
+    """An even locking kernel with W(0) = 1.
+
+    Attributes
+    ----------
+    name : str
+    W : callable
+        The kernel, on `mpmath` scalars.
+    tail : float or None
+        Exponent s of the algebraic tail W ~ |u|^-s, or None for compact
+        support or faster than algebraic decay.
+    support : float or None
+        Half width of the support if compact, otherwise None.
+    """
+
+    name: str
+    W: Callable
+    tail: float = None
+    support: float = None
+
+    def __call__(self, u):
+        return self.W(u)
+
+    def mass(self) -> mp.mpf:
+        """m = int W(u) du, which fixes the threshold coupling."""
+        if self.support is not None:
+            return 2 * mp.quad(self.W, [0, self.support])
+        # A slowly decaying tail needs the decades resolved explicitly.
+        return 2 * mp.quad(self.W, [0, 1, 10, 100, 1000, mp.inf])
+
+
+def conservative() -> Kernel:
+    """The conservative spin kernel, W = 1/(1+u^2), mass pi."""
+    return Kernel("conservative", lambda u: 1 / (1 + mp.mpf(u) ** 2), tail=2.0)
+
+
+def kuramoto() -> Kernel:
+    """The Kuramoto kernel, W = sqrt(1-u^2) on |u| < 1, mass pi/2."""
+
+    def W(u):
+        u = mp.mpf(u)
+        return mp.sqrt(1 - u ** 2) if abs(u) < 1 else mp.mpf(0)
+
+    return Kernel("kuramoto", W, tail=None, support=1.0)
+
+
+def power_tail(s: float) -> Kernel:
+    """The test family W_s(u) = 1/(1+|u|^s).  Requires s > 1 for a finite mass."""
+    s = mp.mpf(s)
+    if s <= 1:
+        raise ValueError("power_tail needs s > 1 for the kernel mass to converge")
+
+    def W(u):
+        return 1 / (1 + abs(mp.mpf(u)) ** s)
+
+    return Kernel(f"power{float(s):g}", W, tail=float(s))
+
+
+def gaussian_kernel() -> Kernel:
+    """A Gaussian kernel, faster than any algebraic decay.  Control case."""
+    return Kernel("gaussian", lambda u: mp.e ** (-mp.mpf(u) ** 2), tail=None)
+
+
+KERNELS = {
+    "conservative": conservative,
+    "kuramoto": kuramoto,
+    "power_tail": power_tail,
+    "gaussian": gaussian_kernel,
+}
+
+
+def predicted_beta(s) -> float:
+    """The order parameter exponent predicted for a kernel of tail exponent s.
+
+    beta = 1/(s-1) for 1 < s < 3, and beta = 1/2 for s >= 3 or for a kernel
+    with compact support or faster than algebraic decay (s is None).  The
+    crossover at s = 3 is where the second moment of the kernel stops
+    converging, so that the leading correction to the self consistency changes
+    from being set by the tail to being set by the curvature of the line.
+    """
+    if s is None or s >= 3:
+        return 0.5
+    return 1.0 / (float(s) - 1.0)
+
+
+def heterogeneous(base: Kernel, degree_exponent: float, eta: float = 1.0,
+                  k_min: float = 1.0) -> Kernel:
+    """The kernel produced by a broad distribution of coupling strengths.
+
+    When the oscillators do not all couple with the same strength, the kernel
+    that appears in the self consistency is not the single oscillator response
+    but an average of it.  Let oscillator i carry weight k_i drawn from
+    P(k) = (gamma-1) k_min^(gamma-1) k^-gamma above k_min, let the field it
+    feels be proportional to k_i^eta, and let its contribution to the
+    collective field carry the weight k_i.  Then
+
+        Wt(v) = (1 / <k>) int P(k) k W(v / k^eta) dk,
+
+    which is again a function of v alone, so the parametric solution applies
+    unchanged with this kernel in place of W.
+
+    The tail of the average is not the tail of W.  A weight far above the
+    typical one gives that oscillator a locking bandwidth far above the
+    typical one, so it stays locked at detunings where a typical oscillator
+    has long since been released, and the heavy tail of P is inherited by the
+    kernel.  For a base kernel of tail exponent s0, including s0 = infinity for
+    compact support,
+
+        s = min(s0, (gamma - 2) / eta).
+
+    The two cases that matter are the overdamped kernel, where s0 is infinite
+    so that the coupling distribution alone sets the tail, and the
+    conservative kernel, where s0 = 2 caps it.  `eta` covers couplings that
+    themselves depend on the weight, J k^(eta-1), for which the field on an
+    oscillator scales as k^eta.
+
+    For the two base kernels the weight integral is reduced analytically to a
+    single smooth quadrature, which is what makes the exponent reachable.
+    """
+    g = mp.mpf(degree_exponent)
+    eta = mp.mpf(eta)
+    kmin = mp.mpf(k_min)
+    if g <= 2:
+        raise ValueError("the mean weight diverges unless gamma > 2")
+    s0 = mp.mpf(base.tail) if base.tail is not None else mp.inf
+    tail = min(s0, (g - 2) / eta)
+    if tail <= 1:
+        raise ValueError("the kernel mass diverges unless min(s0, (gamma-2)/eta) > 1")
+
+    if base.name == "kuramoto" and kmin == 1:
+        # W(x) = sqrt(1-x^2) on |x| < 1.  Only weights with k^eta > v are
+        # locked at detuning v, and substituting w = k^(2 eta) reduces the
+        # weight integral to a Beta function above v = 1 and to a Gauss
+        # hypergeometric below it, both exact:
+        #   a = (2-gamma)/(2 eta) < 0,
+        #   v >= 1:  Wt = (gamma-1) v^(2a) B(-a, 3/2) / (2 eta),
+        #   v <  1:  Wt = (gamma-1) 2F1(-1/2, -a; 1-a; v^2) / (2 eta (-a)).
+        # The first line shows directly that the tail is an exact power law
+        # with exponent (gamma-2)/eta.
+        a = (2 - g) / (2 * eta)
+
+        def Wt(v):
+            v = abs(mp.mpf(v))
+            if v >= 1:
+                return (g - 1) * v ** (2 * a) * mp.beta(-a, mp.mpf(3) / 2) / (2 * eta)
+            return (g - 1) * mp.hyp2f1(-mp.mpf(1) / 2, -a, 1 - a, v ** 2) \
+                / (2 * eta * (-a))
+    elif base.support is not None:
+        sup = mp.mpf(base.support)
+
+        def Wt(v):
+            v = abs(mp.mpf(v))
+            if v == 0:
+                return (g - 1) * kmin / (g - 2)
+            edge = mp.power(v / sup, 1 / eta)
+            lo = max(kmin, edge)
+            f = lambda k: k ** (1 - g) * base.W(v / k ** eta)
+            return (g - 1) * kmin ** (g - 1) * mp.quad(
+                f, [lo, 2 * lo, 10 * lo, 100 * lo, mp.inf])
+    else:
+        def Wt(v):
+            v = abs(mp.mpf(v))
+            f = lambda k: k ** (1 - g) * base.W(v / k ** eta)
+            scale = mp.power(max(v, mp.mpf("1e-40")), 1 / eta)
+            pts = sorted({kmin, max(kmin, scale), max(kmin, 10 * scale),
+                          max(kmin, 100 * scale)})
+            return (g - 1) * kmin ** (g - 1) * mp.quad(list(pts) and f,
+                                                       list(pts) + [mp.inf])
+
+    W0 = Wt(0)
+    return Kernel(f"het_{base.name}_g{float(g):g}_e{float(eta):g}",
+                  lambda u: Wt(u) / W0, tail=float(tail))

lockkernel/lineshapes.py

@@ -0,0 +1,148 @@
+"""Inhomogeneous line shapes p(delta).
+
+Each line shape is returned as a `LineShape`: a callable density together with
+the pieces the rest of the package needs, namely the density at the centre,
+a cumulative distribution and its inverse for building quadrature classes, and
+a nominal width used to set integration scales.
+
+Densities are written for `mpmath` scalars so that the same object can be used
+both in the arbitrary precision parametric solver and, through `numpy`
+broadcasting of the float path, in the finite precision dynamics.
+"""
+from __future__ import annotations
+
+import dataclasses
+from typing import Callable
+
+import mpmath as mp
+import numpy as np
+from scipy import stats
+
+__all__ = ["LineShape", "lorentzian", "gaussian", "student_t", "box",
+           "bimodal_gaussian", "LINESHAPES"]
+
+
+@dataclasses.dataclass(frozen=True)
+class LineShape:
+    """A symmetric probability density on the detuning axis.
+
+    Attributes
+    ----------
+    name : str
+        Short identifier used in output files.
+    pdf : callable
+        Density, accepting an `mpmath` scalar and returning one.
+    scale : float
+        A nominal width, used only to choose integration break points.
+    frozen : scipy.stats distribution or None
+        Float precision distribution supplying `cdf` and `ppf`.  Line shapes
+        that are only used analytically may leave this as None.
+    compact_support : float or None
+        Half width of the support when the density has compact support.
+    """
+
+    name: str
+    pdf: Callable
+    scale: float
+    frozen: object = None
+    compact_support: float = None
+
+    def __call__(self, delta):
+        return self.pdf(delta)
+
+    def p0(self):
+        """Density at the line centre."""
+        return self.pdf(mp.mpf(0))
+
+    def cdf(self, x):
+        if self.frozen is None:
+            raise NotImplementedError(f"{self.name} has no float cdf")
+        return self.frozen.cdf(x)
+
+    def ppf(self, q):
+        if self.frozen is None:
+            raise NotImplementedError(f"{self.name} has no float ppf")
+        return self.frozen.ppf(q)
+
+
+def lorentzian(fwhm: float = 1.0) -> LineShape:
+    """Lorentzian of the given full width at half maximum."""
+    g = mp.mpf(fwhm) / 2  # half width at half maximum
+
+    def pdf(d):
+        d = mp.mpf(d)
+        return g / mp.pi / (d ** 2 + g ** 2)
+
+    return LineShape("lorentzian", pdf, float(fwhm),
+                     stats.cauchy(loc=0.0, scale=float(g)))
+
+
+def gaussian(fwhm: float = 1.0) -> LineShape:
+    """Gaussian of the given full width at half maximum."""
+    sig = mp.mpf(fwhm) / (2 * mp.sqrt(2 * mp.log(2)))
+
+    def pdf(d):
+        d = mp.mpf(d)
+        return mp.e ** (-d ** 2 / (2 * sig ** 2)) / (sig * mp.sqrt(2 * mp.pi))
+
+    return LineShape("gaussian", pdf, float(fwhm),
+                     stats.norm(loc=0.0, scale=float(sig)))
+
+
+def student_t(nu: float = 3.0, scale: float = 1.0) -> LineShape:
+    """Student t density, a heavy tailed line with p(d) ~ |d|^-(nu+1)."""
+    nu = mp.mpf(nu)
+    sc = mp.mpf(scale)
+    norm = mp.gamma((nu + 1) / 2) / (mp.sqrt(nu * mp.pi) * mp.gamma(nu / 2) * sc)
+
+    def pdf(d):
+        d = mp.mpf(d) / sc
+        return norm * (1 + d ** 2 / nu) ** (-(nu + 1) / 2)
+
+    return LineShape(f"student_t{float(nu):g}", pdf, float(scale),
+                     stats.t(df=float(nu), scale=float(scale)))
+
+
+def box(halfwidth: float = 1.0) -> LineShape:
+    """Uniform line on [-w, w].  Discontinuous, kept as a stress test."""
+    w = mp.mpf(halfwidth)
+
+    def pdf(d):
+        return 1 / (2 * w) if abs(mp.mpf(d)) <= w else mp.mpf(0)
+
+    return LineShape("box", pdf, float(halfwidth),
+                     stats.uniform(loc=-float(w), scale=2 * float(w)),
+                     compact_support=float(halfwidth))
+
+
+def bimodal_gaussian(sep: float, width: float = 1.0) -> LineShape:
+    """Two equal Gaussians of standard deviation `width` at +/- sep/2.
+
+    The ratio sep/width controls the order of the transition; see
+    `lockkernel.parametric.c_coefficient`.
+    """
+    a = mp.mpf(sep) / 2
+    s = mp.mpf(width)
+
+    def pdf(d):
+        d = mp.mpf(d)
+        z = 1 / (2 * s * mp.sqrt(2 * mp.pi))
+        return z * (mp.e ** (-(d - a) ** 2 / (2 * s ** 2))
+                    + mp.e ** (-(d + a) ** 2 / (2 * s ** 2)))
+
+    return LineShape(f"bimodal{float(sep) / float(width):g}", pdf,
+                     float(width) + float(a))
+
+
+LINESHAPES = {
+    "lorentzian": lorentzian,
+    "gaussian": gaussian,
+    "student_t": student_t,
+    "box": box,
+    "bimodal_gaussian": bimodal_gaussian,
+}
+
+
+def float_pdf(line: LineShape):
+    """A vectorised float precision version of a line shape density."""
+    return np.vectorize(lambda x: float(line.pdf(mp.mpf(float(x)))))