physicskit 0.1.0__py3-none-any.whl

physicskit/quantum/visualizers/phase_space.py

@@ -0,0 +1,179 @@
+r"""Wigner quasi-probability distribution :math:`W(x,p)` and 3D phase-space plots."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+__all__ = ["wigner_transform", "WignerVisualizer"]
+
+
+def wigner_transform(x: np.ndarray, psi: np.ndarray, hbar: float = 1.0, n_p: int = 200, p_max: float | None = None):
+    r"""Compute the Wigner quasi-probability distribution.
+
+    .. math::
+
+        W(x,p) = \frac{1}{\pi\hbar} \int_{-\infty}^{\infty}
+            \psi^*(x+y)\,\psi(x-y)\, e^{2ipy/\hbar}\, dy,
+
+    on the same x-grid the wavefunction is given on, by direct quadrature
+    over the shift :math:`y=k\,dx` (:math:`\psi` is treated as zero outside
+    the grid).
+
+    Parameters
+    ----------
+    x : numpy.ndarray
+        Positions the wavefunction is sampled on (uniform grid).
+    psi : numpy.ndarray
+        Complex-valued wavefunction sampled on ``x``.
+    hbar : float, default=1.0
+        Value of :math:`\hbar` to use.
+    n_p : int, default=200
+        Number of momentum grid points.
+    p_max : float or None, optional
+        Half-width of the momentum grid; defaults to the Nyquist limit set
+        by the position-grid spacing, :math:`\pi\hbar/(2\,dx)`.
+
+    Returns
+    -------
+    x : numpy.ndarray
+        The (unchanged) position grid.
+    p : numpy.ndarray
+        The momentum grid, shape ``(n_p,)``.
+    W : numpy.ndarray
+        The Wigner function, shape ``(len(x), n_p)``.
+    """
+    x = np.asarray(x)
+    psi = np.asarray(psi, dtype=complex)
+    N = x.shape[0]
+    dx = x[1] - x[0]
+    if p_max is None:
+        # The transform's kernel is e^{2ipy/hbar} with y=k*dx, so the
+        # conjugate variable is 2p/hbar; its Nyquist limit pi/dx gives
+        # p_max = pi*hbar/(2*dx) (using the full pi*hbar/dx aliases W(x,p)
+        # periodically back onto itself well before that point).
+        p_max = np.pi * hbar / (2 * dx)
+
+    p = np.linspace(-p_max, p_max, n_p)
+    W = np.zeros((N, n_p))
+
+    for i in range(N):
+        kmax = min(i, N - 1 - i)
+        k = np.arange(-kmax, kmax + 1)
+        integrand = np.conj(psi[i + k]) * psi[i - k]
+        phase = np.exp(2j * np.outer(p, k * dx) / hbar)  # (n_p, len(k))
+        W[i, :] = (dx / (np.pi * hbar)) * np.real(phase @ integrand)
+
+    return x, p, W
+
+
+@dataclass
+class WignerVisualizer:
+    """Convenience wrapper around :func:`wigner_transform` with plotting helpers.
+
+    Parameters
+    ----------
+    hbar : float, default=1.0
+        Value of :math:`\\hbar` to use.
+    n_p : int, default=200
+        Number of momentum grid points.
+    """
+
+    hbar: float = 1.0
+    n_p: int = 200
+
+    def compute(self, x: np.ndarray, psi: np.ndarray, p_max: float | None = None):
+        """See :func:`wigner_transform`.
+
+        Parameters
+        ----------
+        x : numpy.ndarray
+        psi : numpy.ndarray
+        p_max : float or None, optional
+
+        Returns
+        -------
+        x, p, W : numpy.ndarray
+        """
+        return wigner_transform(x, psi, self.hbar, self.n_p, p_max)
+
+    def position_marginal(self, p: np.ndarray, W: np.ndarray) -> np.ndarray:
+        r"""Integrate :math:`W(x,p)` over :math:`p`.
+
+        Should recover :math:`\lvert\psi(x)\rvert^2` -- a standard
+        correctness check for a Wigner-function implementation.
+
+        Parameters
+        ----------
+        p : numpy.ndarray
+            Momentum grid.
+        W : numpy.ndarray
+            Wigner function, shape ``(len(x), len(p))``.
+
+        Returns
+        -------
+        numpy.ndarray
+        """
+        dp = p[1] - p[0]
+        return np.sum(W, axis=1) * dp
+
+    def plot_surface(self, x: np.ndarray, p: np.ndarray, W: np.ndarray, ax=None, cmap: str = "RdBu_r"):
+        """3D surface plot of :math:`W(x,p)`.
+
+        Uses a diverging colormap so the negative (non-classical
+        interference) regions stand out from the positive ones.
+
+        Parameters
+        ----------
+        x, p : numpy.ndarray
+            Position and momentum grids.
+        W : numpy.ndarray
+            Wigner function, shape ``(len(x), len(p))``.
+        ax : matplotlib.axes.Axes or None, optional
+            A 3D axis to draw on; a new figure/axis is created if omitted.
+        cmap : str, default='RdBu_r'
+            Diverging colormap name.
+
+        Returns
+        -------
+        matplotlib.axes.Axes
+        """
+        if ax is None:
+            fig = plt.figure(figsize=(8, 6))
+            ax = fig.add_subplot(111, projection="3d")
+        X, P = np.meshgrid(x, p, indexing="ij")
+        vmax = np.abs(W).max()
+        ax.plot_surface(X, P, W, cmap=cmap, vmin=-vmax, vmax=vmax, linewidth=0, antialiased=True)
+        ax.set_xlabel("x")
+        ax.set_ylabel("p")
+        ax.set_zlabel("W(x,p)")
+        return ax
+
+    def plot_contour(self, x: np.ndarray, p: np.ndarray, W: np.ndarray, ax=None, cmap: str = "RdBu_r"):
+        """2D filled-contour plot of :math:`W(x,p)`.
+
+        Parameters
+        ----------
+        x, p : numpy.ndarray
+            Position and momentum grids.
+        W : numpy.ndarray
+            Wigner function, shape ``(len(x), len(p))``.
+        ax : matplotlib.axes.Axes or None, optional
+            Axis to draw on; a new figure/axis is created if omitted.
+        cmap : str, default='RdBu_r'
+            Diverging colormap name.
+
+        Returns
+        -------
+        matplotlib.axes.Axes
+        """
+        if ax is None:
+            _, ax = plt.subplots(figsize=(6, 5))
+        vmax = np.abs(W).max()
+        cs = ax.contourf(x, p, W.T, levels=60, cmap=cmap, vmin=-vmax, vmax=vmax)
+        ax.set_xlabel("x")
+        ax.set_ylabel("p")
+        plt.colorbar(cs, ax=ax, label="W(x,p)")
+        return ax

physicskit/quantum/visualizers/wavefunctions.py

@@ -0,0 +1,230 @@
+r"""Phase-colored HSV complex wavefunction plots and density animations."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import matplotlib.colors as mcolors
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.animation import FuncAnimation
+
+__all__ = ["complex_to_rgb", "plot_complex_wavefunction", "animate_density", "animate_density_2d"]
+
+
+def complex_to_rgb(psi: np.ndarray, max_abs: Optional[float] = None) -> np.ndarray:
+    r"""Map a complex array to RGB: hue = phase, value = amplitude.
+
+    .. math::
+
+        \text{hue} = \frac{\arg\psi + \pi}{2\pi}, \qquad
+        \text{value} = \min\!\left(\frac{\lvert\psi\rvert}{\max\lvert\psi\rvert}, 1\right).
+
+    Parameters
+    ----------
+    psi : numpy.ndarray
+        Complex-valued array.
+    max_abs : float or None, optional
+        Amplitude that maps to full brightness; defaults to ``abs(psi).max()``.
+
+    Returns
+    -------
+    numpy.ndarray
+        RGB array of shape ``(..., 3)``, suitable for ``imshow``/plotting.
+    """
+    amp = np.abs(psi)
+    phase = np.angle(psi)
+    if max_abs is None:
+        max_abs = amp.max() if amp.max() > 0 else 1.0
+    hue = (phase + np.pi) / (2 * np.pi)
+    saturation = np.ones_like(hue)
+    value = np.clip(amp / max_abs, 0, 1)
+    hsv = np.stack([hue, saturation, value], axis=-1)
+    return mcolors.hsv_to_rgb(hsv)
+
+
+def plot_complex_wavefunction(x: np.ndarray, psi: np.ndarray, ax=None, density_scale: float = 1.0):
+    r"""Plot a phase-colored probability density curve.
+
+    Plots :math:`\lvert\psi(x)\rvert^2` as a filled curve, colored by the
+    local phase :math:`\arg\psi(x)` (HSV hue) -- a compact way to show both
+    the probability density and the complex phase of a wavefunction at once.
+
+    Parameters
+    ----------
+    x : numpy.ndarray
+        Positions.
+    psi : numpy.ndarray
+        Complex-valued wavefunction sampled on ``x``.
+    ax : matplotlib.axes.Axes or None, optional
+        Axis to draw on; a new figure/axis is created if omitted.
+    density_scale : float, default=1.0
+        Multiplicative scale factor applied to the plotted density.
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+    """
+    if ax is None:
+        _, ax = plt.subplots(figsize=(7, 4))
+
+    density = np.abs(psi) ** 2 * density_scale
+    colors = complex_to_rgb(psi)
+
+    for i in range(len(x) - 1):
+        ax.fill_between(x[i : i + 2], 0, density[i : i + 2], color=colors[i], linewidth=0)
+
+    ax.set_xlabel("x")
+    ax.set_ylabel(r"$|\psi(x)|^2$")
+
+    sm = plt.cm.ScalarMappable(cmap=_phase_colormap(), norm=mcolors.Normalize(-np.pi, np.pi))
+    sm.set_array([])
+    cbar = plt.colorbar(sm, ax=ax, pad=0.02)
+    cbar.set_label(r"$\arg\,\psi(x)$")
+    return ax
+
+
+def _phase_colormap():
+    hues = np.linspace(0, 1, 256)
+    rgb = mcolors.hsv_to_rgb(np.stack([hues, np.ones_like(hues), np.ones_like(hues)], axis=-1))
+    return mcolors.ListedColormap(rgb)
+
+
+def animate_density(
+    x: np.ndarray, frames: np.ndarray, times: np.ndarray | None = None, interval: int = 30, phase_colored: bool = True, ax=None
+) -> FuncAnimation:
+    """Animate a stack of wavefunction snapshots over time.
+
+    Parameters
+    ----------
+    x : numpy.ndarray
+        Positions.
+    frames : numpy.ndarray
+        Wavefunction snapshots, shape ``(n_frames, len(x))``. May be complex
+        (density and phase both shown via :func:`complex_to_rgb`) or real
+        (plain probability density curve).
+    times : numpy.ndarray or None, optional
+        Time of each frame, used to label the animation title.
+    interval : int, default=30
+        Delay between frames, in milliseconds.
+    phase_colored : bool, default=True
+        Whether to color the curve by phase (only applies if ``frames`` is
+        complex).
+    ax : matplotlib.axes.Axes or None, optional
+        Axis to draw on; a new figure/axis is created if omitted.
+
+    Returns
+    -------
+    matplotlib.animation.FuncAnimation
+    """
+    if ax is None:
+        fig, ax = plt.subplots(figsize=(7, 4))
+    else:
+        fig = ax.figure
+
+    density = np.abs(frames) ** 2
+    ymax = density.max() * 1.1
+
+    if phase_colored and np.iscomplexobj(frames):
+        line_collections = []
+
+        def init():
+            ax.set_xlim(x.min(), x.max())
+            ax.set_ylim(0, ymax)
+            ax.set_xlabel("x")
+            ax.set_ylabel(r"$|\psi(x,t)|^2$")
+            return []
+
+        def update(i):
+            for coll in line_collections:
+                coll.remove()
+            line_collections.clear()
+            colors = complex_to_rgb(frames[i], max_abs=np.abs(frames).max())
+            for j in range(len(x) - 1):
+                line_collections.append(ax.fill_between(x[j : j + 2], 0, density[i, j : j + 2], color=colors[j], linewidth=0))
+            title = f"t = {times[i]:.3f}" if times is not None else f"frame {i}"
+            ax.set_title(title)
+            return line_collections
+
+        return FuncAnimation(fig, update, init_func=init, frames=len(frames), interval=interval, blit=False)
+
+    (line,) = ax.plot(x, density[0])
+    ax.set_xlim(x.min(), x.max())
+    ax.set_ylim(0, ymax)
+    ax.set_xlabel("x")
+    ax.set_ylabel(r"$|\psi(x,t)|^2$")
+
+    def update_simple(i):
+        line.set_ydata(density[i])
+        title = f"t = {times[i]:.3f}" if times is not None else f"frame {i}"
+        ax.set_title(title)
+        return (line,)
+
+    return FuncAnimation(fig, update_simple, frames=len(frames), interval=interval, blit=False)
+
+
+def animate_density_2d(
+    X: np.ndarray,
+    Y: np.ndarray,
+    frames: np.ndarray,
+    times: np.ndarray | None = None,
+    interval: int = 30,
+    phase_colored: bool = True,
+    cmap: str = "viridis",
+    ax=None,
+) -> FuncAnimation:
+    """Animate a stack of 2D wavefunction/density snapshots via ``imshow``.
+
+    Parameters
+    ----------
+    X, Y : numpy.ndarray
+        Coordinate meshgrid (``indexing='ij'``), e.g.
+        ``SplitOperatorSolver2D.X/.Y``.
+    frames : numpy.ndarray
+        Snapshots, shape ``(n_frames, *X.shape)``. May be complex
+        (density and phase both shown via :func:`complex_to_rgb`) or real
+        (a plain probability-density heatmap).
+    times : numpy.ndarray or None, optional
+        Time of each frame, used to label the animation title.
+    interval : int, default=30
+        Delay between frames, in milliseconds.
+    phase_colored : bool, default=True
+        Whether to color by phase (only applies if ``frames`` is complex).
+    cmap : str, default='viridis'
+        Colormap used when not phase-colored.
+    ax : matplotlib.axes.Axes or None, optional
+        Axis to draw on; a new figure/axis is created if omitted.
+
+    Returns
+    -------
+    matplotlib.animation.FuncAnimation
+    """
+    if ax is None:
+        fig, ax = plt.subplots(figsize=(6, 5))
+    else:
+        fig = ax.figure
+
+    extent = [X.min(), X.max(), Y.min(), Y.max()]
+    is_complex = phase_colored and np.iscomplexobj(frames)
+
+    if is_complex:
+        max_abs = np.abs(frames).max()
+        im = ax.imshow(np.transpose(complex_to_rgb(frames[0], max_abs=max_abs), (1, 0, 2)), origin="lower", extent=extent, aspect="auto")
+    else:
+        density = np.abs(frames) ** 2 if np.iscomplexobj(frames) else frames
+        vmax = density.max() * 1.1
+        im = ax.imshow(density[0].T, origin="lower", extent=extent, aspect="auto", cmap=cmap, vmin=0, vmax=vmax)
+
+    ax.set_xlabel("x")
+    ax.set_ylabel("y")
+
+    def update(i):
+        if is_complex:
+            im.set_data(np.transpose(complex_to_rgb(frames[i], max_abs=np.abs(frames).max()), (1, 0, 2)))
+        else:
+            im.set_data(density[i].T)
+        title = f"t = {times[i]:.3f}" if times is not None else f"frame {i}"
+        ax.set_title(title)
+        return (im,)
+
+    return FuncAnimation(fig, update, frames=len(frames), interval=interval, blit=False)

physicskit/relativity/__init__.py

@@ -0,0 +1,61 @@
+"""physicskit.relativity: fast, visually captivating numerical General Relativity.
+
+``physicskit.relativity`` brings curved spacetime geometry, black hole physics,
+ray-traced gravitational lensing, and gravitational wave dynamics into an
+interactive, computational Python framework, in geometrized units
+(:math:`G = c = 1`; see :mod:`physicskit.relativity.utils.constants`):
+
+- **Black hole physics** (:mod:`physicskit.relativity.chapters.schwarzschild`,
+  :mod:`physicskit.relativity.chapters.kerr`): timelike orbits, perihelion precession, the
+  innermost stable circular orbit (ISCO), the photon sphere, light
+  deflection and the Shapiro delay, disk redshift, tidal forces, frame
+  dragging, the ergosphere, and the Penrose process.
+- **Spacetime geometry** (:mod:`physicskit.relativity.core.tensors`): a numerical
+  differential geometry engine computing Christoffel symbols and curvature
+  tensors for arbitrary metrics (Schwarzschild, Kerr, Reissner-Nordstrom,
+  FLRW, the Alcubierre warp drive).
+- **Gravitational lensing** (:mod:`physicskit.relativity.core.raytracer`,
+  :mod:`physicskit.relativity.core.kerr_raytracer`, :mod:`physicskit.relativity.visualizers.shadow_render`,
+  :mod:`physicskit.relativity.chapters.lensing`): Numba-accelerated backward photon
+  ray-tracers (Schwarzschild and Kerr) rendering black hole shadows and
+  redshift-shaded lensed accretion disks, plus point-source Einstein rings,
+  multiple images, and microlensing magnification.
+- **Gravitational waves** (:mod:`physicskit.relativity.chapters.gw_merger`): binary black
+  hole inspiral chirps and ringdown, and Hulse-Taylor-style orbital decay.
+- **Cosmology & compact objects** (:mod:`physicskit.relativity.chapters.cosmology`,
+  :mod:`physicskit.relativity.chapters.neutron_star`): the FLRW Friedmann equations for
+  cosmic expansion, and the Tolman-Oppenheimer-Volkoff equations for
+  neutron star structure and the maximum neutron star mass.
+- **Relativity in everyday technology** (:mod:`physicskit.relativity.chapters.timekeeping`):
+  the GPS satellite relativistic clock correction.
+
+Examples
+--------
+>>> from physicskit.relativity.chapters import SchwarzschildBlackHole
+>>> bh = SchwarzschildBlackHole(M=1.0)
+>>> bh.isco_radius
+6.0
+>>> bh.photon_sphere_radius
+3.0
+"""
+
+from physicskit.relativity.chapters import (
+    BinaryMerger,
+    FLRWCosmology,
+    KerrBlackHole,
+    NeutronStar,
+    PointMassLens,
+    SchwarzschildBlackHole,
+)
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "BinaryMerger",
+    "FLRWCosmology",
+    "KerrBlackHole",
+    "NeutronStar",
+    "PointMassLens",
+    "SchwarzschildBlackHole",
+    "__version__",
+]

physicskit/relativity/chapters/__init__.py

@@ -0,0 +1,33 @@
+"""Physics chapters: user-facing model classes built on :mod:`physicskit.relativity.core`.
+
+- :mod:`physicskit.relativity.chapters.schwarzschild` -- orbits, precession, the photon
+  sphere, light deflection, the Shapiro delay, disk redshift, and tidal
+  forces.
+- :mod:`physicskit.relativity.chapters.kerr` -- frame dragging, the ergosphere, the ISCO,
+  and the Penrose process.
+- :mod:`physicskit.relativity.chapters.lensing` -- Einstein rings, multiple images, and
+  microlensing magnification.
+- :mod:`physicskit.relativity.chapters.gw_merger` -- binary black hole inspiral chirps,
+  ringdown, and Hulse-Taylor-style orbital decay.
+- :mod:`physicskit.relativity.chapters.cosmology` -- FLRW cosmic expansion and redshift.
+- :mod:`physicskit.relativity.chapters.neutron_star` -- the Tolman-Oppenheimer-Volkoff
+  equations and the neutron star maximum mass.
+- :mod:`physicskit.relativity.chapters.timekeeping` -- relativistic satellite clock
+  corrections (GPS).
+"""
+
+from physicskit.relativity.chapters.cosmology import FLRWCosmology
+from physicskit.relativity.chapters.gw_merger import BinaryMerger
+from physicskit.relativity.chapters.kerr import KerrBlackHole
+from physicskit.relativity.chapters.lensing import PointMassLens
+from physicskit.relativity.chapters.neutron_star import NeutronStar
+from physicskit.relativity.chapters.schwarzschild import SchwarzschildBlackHole
+
+__all__ = [
+    "BinaryMerger",
+    "FLRWCosmology",
+    "KerrBlackHole",
+    "NeutronStar",
+    "PointMassLens",
+    "SchwarzschildBlackHole",
+]

physicskit/relativity/chapters/cosmology.py

@@ -0,0 +1,190 @@
+"""FLRW cosmology: the Friedmann equations, cosmic expansion, and redshift.
+
+The Friedmann-Lemaitre-Robertson-Walker (FLRW) metric is the unique
+spacetime describing a homogeneous, isotropic universe -- an excellent
+approximation to our own on large scales. Plugging it into Einstein's field
+equations yields the Friedmann equation, which governs how the universe's
+scale factor :math:`a(t)` evolves under the combined gravity of radiation,
+matter, curvature, and dark energy (:math:`\\Lambda`). This single equation
+explains Hubble's 1929 discovery of cosmic expansion, predicts the
+universe's age, and -- through the distance-redshift relation -- underlies
+the 1998 discovery (via observations of distant supernovae) that this
+expansion is accelerating.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from scipy.integrate import quad
+
+from physicskit.relativity.utils.constants import C_SI, PARSEC_M
+
+__all__ = ["FLRWCosmology"]
+
+_MPC_M = PARSEC_M * 1.0e6
+_GYR_S = 365.25 * 24.0 * 3600.0 * 1.0e9
+
+
+class FLRWCosmology:
+    """A flat or curved FLRW universe with radiation, matter, curvature, and dark energy.
+
+    Parameters
+    ----------
+    H0 : float, default=70.0
+        Hubble constant today, in km/s/Mpc.
+    Omega_m : float, default=0.3
+        Matter density parameter today.
+    Omega_r : float, default=1e-4
+        Radiation density parameter today.
+    Omega_Lambda : float, default=0.7
+        Dark energy (cosmological constant) density parameter today.
+
+    Attributes
+    ----------
+    Omega_k : float
+        Curvature density parameter, :math:`1 - \\Omega_m - \\Omega_r - \\Omega_\\Lambda`
+        (computed so all density parameters sum to 1, as required by the
+        Friedmann equation at :math:`a=1`).
+    """
+
+    def __init__(self, H0=70.0, Omega_m=0.3, Omega_r=1.0e-4, Omega_Lambda=0.7):
+        self.H0 = H0
+        self.Omega_m = Omega_m
+        self.Omega_r = Omega_r
+        self.Omega_Lambda = Omega_Lambda
+        self.Omega_k = 1.0 - Omega_m - Omega_r - Omega_Lambda
+
+    def _H0_si(self):
+        return self.H0 * 1.0e3 / _MPC_M  # km/s/Mpc -> 1/s
+
+    def E(self, a):
+        """Dimensionless expansion rate :math:`E(a) = H(a)/H_0`.
+
+        .. math::
+
+            E(a) = \\sqrt{\\Omega_r a^{-4} + \\Omega_m a^{-3} + \\Omega_k a^{-2} + \\Omega_\\Lambda}
+
+        Parameters
+        ----------
+        a : float or array_like
+            Scale factor (:math:`a=1` today).
+
+        Returns
+        -------
+        float or ndarray
+        """
+        a = np.asarray(a, dtype=np.float64)
+        return np.sqrt(self.Omega_r * a**-4 + self.Omega_m * a**-3 + self.Omega_k * a**-2 + self.Omega_Lambda)
+
+    def hubble_parameter(self, a):
+        """Hubble parameter :math:`H(a) = H_0 E(a)`, in km/s/Mpc.
+
+        Parameters
+        ----------
+        a : float or array_like
+            Scale factor.
+
+        Returns
+        -------
+        float or ndarray
+        """
+        return self.H0 * self.E(a)
+
+    def redshift_to_scale_factor(self, z):
+        """Convert redshift to scale factor, :math:`a = 1/(1+z)`."""
+        return 1.0 / (1.0 + np.asarray(z, dtype=np.float64))
+
+    def scale_factor_to_redshift(self, a):
+        """Convert scale factor to redshift, :math:`z = 1/a - 1`."""
+        return 1.0 / np.asarray(a, dtype=np.float64) - 1.0
+
+    def comoving_distance_mpc(self, z):
+        """Comoving distance to redshift ``z``, in Mpc.
+
+        .. math::
+
+            D_C(z) = c \\int_0^z \\frac{dz'}{H(z')}
+
+        Parameters
+        ----------
+        z : float
+            Redshift.
+
+        Returns
+        -------
+        float
+        """
+        H0_si = self._H0_si()
+
+        def integrand(zp):
+            a = 1.0 / (1.0 + zp)
+            return 1.0 / (H0_si * self.E(a))
+
+        distance_m = C_SI * quad(integrand, 0.0, z)[0]
+        return distance_m / _MPC_M
+
+    def luminosity_distance_mpc(self, z):
+        """Luminosity distance to redshift ``z``, in Mpc, :math:`D_L = (1+z) D_C` (flat-sky FLRW).
+
+        Parameters
+        ----------
+        z : float
+            Redshift.
+
+        Returns
+        -------
+        float
+        """
+        return (1.0 + z) * self.comoving_distance_mpc(z)
+
+    def age_gyr(self, a=1.0):
+        """Cosmic age at scale factor ``a``, in Gyr.
+
+        .. math::
+
+            t(a) = \\int_0^a \\frac{da'}{a' H(a')}
+
+        Parameters
+        ----------
+        a : float, default=1.0
+            Scale factor at which to evaluate the age (``a=1`` gives the
+            current age of the universe).
+
+        Returns
+        -------
+        float
+
+        Examples
+        --------
+        >>> cosmo = FLRWCosmology(H0=70.0, Omega_m=0.3, Omega_r=0.0, Omega_Lambda=0.7)
+        >>> 12.0 < cosmo.age_gyr() < 15.0
+        True
+        """
+        H0_si = self._H0_si()
+
+        def integrand(ap):
+            return 1.0 / (ap * H0_si * self.E(ap))
+
+        age_s = quad(integrand, 1.0e-8, a, limit=200)[0]
+        return age_s / _GYR_S
+
+    def scale_factor_history(self, n_points=200, a_min=1.0e-3, a_max=3.0):
+        """Tabulate the age of the universe at a range of scale factors, for plotting :math:`a(t)`.
+
+        Parameters
+        ----------
+        n_points : int, default=200
+            Number of scale-factor grid points.
+        a_min, a_max : float
+            Range of scale factors to tabulate.
+
+        Returns
+        -------
+        t_gyr : ndarray of shape (n_points,)
+            Cosmic age at each scale factor, in Gyr.
+        a : ndarray of shape (n_points,)
+            The scale factor grid.
+        """
+        a_grid = np.linspace(a_min, a_max, n_points)
+        t_gyr = np.array([self.age_gyr(a) for a in a_grid])
+        return t_gyr, a_grid