canns 0.15.0__py3-none-any.whl → 0.15.1__py3-none-any.whl

canns/analyzer/data/asa/__init__.py

@@ -2,15 +2,9 @@ from __future__ import annotations
 
 from .cohomap import (
     cohomap,
-    cohomap_upgrade,
-    ecohomap,
     fit_cohomap_stripes,
-    fit_cohomap_stripes_upgrade,
     plot_cohomap,
-    plot_cohomap_upgrade,
-    plot_ecohomap,
 )
-from .cohomap_scatter import plot_cohomap_scatter, plot_cohomap_scatter_multi
 from .cohomap_vectors import (
     cohomap_vectors,
     plot_cohomap_stripes,
@@ -18,14 +12,8 @@ from .cohomap_vectors import (
 )
 from .cohospace import (
     cohospace,
-    cohospace_upgrade,
-    ecohospace,
     plot_cohospace,
     plot_cohospace_skewed,
-    plot_cohospace_upgrade,
-    plot_cohospace_upgrade_skewed,
-    plot_ecohospace,
-    plot_ecohospace_skewed,
 )
 from .cohospace_phase_centers import (
     cohospace_phase_centers,
@@ -81,6 +69,8 @@ from .path import (
 from .plotting import (
     plot_2d_bump_on_manifold,
     plot_3d_bump_on_torus,
+    plot_cohomap_scatter,
+    plot_cohomap_scatter_multi,
     plot_path_compare_1d,
     plot_path_compare_2d,
     plot_projection,
@@ -109,22 +99,11 @@ __all__ = [
     "plot_3d_bump_on_torus",
     "plot_2d_bump_on_manifold",
     "cohomap",
-    "cohomap_upgrade",
     "fit_cohomap_stripes",
-    "fit_cohomap_stripes_upgrade",
     "plot_cohomap",
-    "plot_cohomap_upgrade",
     "cohospace",
-    "cohospace_upgrade",
     "plot_cohospace",
     "plot_cohospace_skewed",
-    "plot_cohospace_upgrade",
-    "plot_cohospace_upgrade_skewed",
-    "ecohomap",
-    "ecohospace",
-    "plot_ecohomap",
-    "plot_ecohospace",
-    "plot_ecohospace_skewed",
     "cohomap_vectors",
     "plot_cohomap_stripes",
     "plot_cohomap_vectors",

canns/analyzer/data/asa/coho.py

@@ -2,96 +2,20 @@
 
 from __future__ import annotations
 
-import os
-from typing import Any
-
-import numpy as np
-from scipy.ndimage import gaussian_filter
-
-from ...visualization.core import PlotConfig
-from .path import find_coords_matrix, find_times_box
-
-
-def _ensure_plot_config(
-    config: PlotConfig | None,
-    factory,
-    *args,
-    **defaults,
-) -> PlotConfig:
-    if config is None:
-        return factory(*args, **defaults)
-    return config
-
-
-def _ensure_parent_dir(save_path: str | None) -> None:
-    if save_path:
-        parent = os.path.dirname(save_path)
-        if parent:
-            os.makedirs(parent, exist_ok=True)
-
-
-def _circmean(x: np.ndarray) -> float:
-    return float(np.arctan2(np.mean(np.sin(x)), np.mean(np.cos(x))))
-
-
-def _smooth_circular_map(
-    mtot: np.ndarray,
-    smooth_sigma: float,
-    *,
-    fill_nan: bool = False,
-    fill_sigma: float | None = None,
-    fill_min_weight: float = 1e-3,
-) -> np.ndarray:
-    mtot = np.asarray(mtot, dtype=float)
-    nans = np.isnan(mtot)
-    mask = (~nans).astype(float)
-    sintot = np.sin(mtot)
-    costot = np.cos(mtot)
-    sintot[nans] = 0.0
-    costot[nans] = 0.0
-
-    if fill_nan:
-        if fill_sigma is None:
-            fill_sigma = smooth_sigma if smooth_sigma and smooth_sigma > 0 else 1.0
-        weight = gaussian_filter(mask, fill_sigma)
-        sintot = gaussian_filter(sintot * mask, fill_sigma)
-        costot = gaussian_filter(costot * mask, fill_sigma)
-        min_weight = max(float(fill_min_weight), 0.0)
-        valid = weight > min_weight
-        sintot = np.divide(sintot, weight, out=np.zeros_like(sintot), where=valid)
-        costot = np.divide(costot, weight, out=np.zeros_like(costot), where=valid)
-        mtot = np.arctan2(sintot, costot)
-        if fill_min_weight > 0:
-            mtot[~valid] = np.nan
-        return mtot
-
-    if smooth_sigma and smooth_sigma > 0:
-        sintot = gaussian_filter(sintot, smooth_sigma)
-        costot = gaussian_filter(costot, smooth_sigma)
-    mtot = np.arctan2(sintot, costot)
-    mtot[nans] = np.nan
-    return mtot
-
-
-def _extract_coords_and_times(
-    decoding_result: dict[str, Any],
-    coords_key: str | None = None,
-) -> tuple[np.ndarray, np.ndarray | None]:
-    if coords_key is not None:
-        if coords_key not in decoding_result:
-            raise KeyError(f"coords_key '{coords_key}' not found in decoding_result.")
-        coords = np.asarray(decoding_result[coords_key])
-    elif "coordsbox" in decoding_result:
-        coords = np.asarray(decoding_result["coordsbox"])
-    else:
-        coords, _ = find_coords_matrix(decoding_result)
-
-    times_box, _ = find_times_box(decoding_result)
-    return coords, times_box
-
-
-def _phase_map_valid_fraction(phase_map: np.ndarray) -> float:
-    valid = np.isfinite(phase_map)
-    if valid.size == 0:
-        return 0.0
-    return float(np.mean(valid))
+from .utils import (
+    _circmean,
+    _ensure_parent_dir,
+    _ensure_plot_config,
+    _extract_coords_and_times,
+    _phase_map_valid_fraction,
+    _smooth_circular_map,
+)
+
+__all__ = [
+    "_ensure_plot_config",
+    "_ensure_parent_dir",
+    "_circmean",
+    "_smooth_circular_map",
+    "_extract_coords_and_times",
+    "_phase_map_valid_fraction",
+]

canns/analyzer/data/asa/cohomap.py

@@ -57,6 +57,36 @@ def _rot_coord(
     c2: np.ndarray,
     p: tuple[int, int],
 ) -> np.ndarray:
+    """Transform and align decoded coordinates based on stripe orientation.
+
+    This function rotates and aligns coordinates to match the dominant stripe
+    orientation in the CohoMap. It handles the torus geometry by choosing the
+    appropriate coordinate system and applying reflections/rotations.
+
+    Parameters
+    ----------
+    params1 : np.ndarray
+        Stripe fit parameters for first dimension (includes orientation angle).
+    params2 : np.ndarray
+        Stripe fit parameters for second dimension (includes orientation angle).
+    c1 : np.ndarray
+        Decoded coordinates for first dimension.
+    c2 : np.ndarray
+        Decoded coordinates for second dimension.
+    p : tuple[int, int]
+        Direction indicators (1 or -1) for each dimension, controlling reflections.
+
+    Returns
+    -------
+    np.ndarray
+        Aligned coordinates of shape (N, 2), wrapped to [0, 2π).
+
+    Notes
+    -----
+    The function selects the coordinate system based on which dimension has
+    stronger horizontal alignment (larger |cos(angle)|), then applies geometric
+    transformations to align the coordinates with the stripe pattern.
+    """
     if abs(np.cos(params1[0])) < abs(np.cos(params2[0])):
         cc1 = c2.copy()
         cc2 = c1.copy()
@@ -96,6 +126,46 @@ def _toroidal_align_coords(
     trim: int,
     grid_size: int | None,
 ) -> tuple[np.ndarray, float, float]:
+    """Align decoded coordinates to CohoMap stripe patterns.
+
+    This function fits stripe patterns to both phase maps, determines the
+    optimal orientation and phase signs, then transforms the decoded coordinates
+    to align with the detected stripe structure.
+
+    Parameters
+    ----------
+    coords : np.ndarray
+        Decoded coordinates of shape (N, 2+). Only first two columns are used.
+    phase_map1 : np.ndarray
+        Phase map for first dimension (2D grid).
+    phase_map2 : np.ndarray
+        Phase map for second dimension (2D grid), must match phase_map1 shape.
+    trim : int
+        Number of edge bins to trim when fitting stripes.
+    grid_size : int, optional
+        Grid size for stripe fitting. If None, inferred from phase_map shape.
+
+    Returns
+    -------
+    aligned : np.ndarray
+        Aligned coordinates of shape (N, 2), wrapped to [0, 2π).
+    f1 : float
+        Fit quality score for first dimension (higher is better).
+    f2 : float
+        Fit quality score for second dimension (higher is better).
+
+    Raises
+    ------
+    ValueError
+        If phase_map shapes don't match or coords has wrong shape.
+
+    Notes
+    -----
+    The alignment process:
+    1. Fits stripe patterns to both phase maps using FFT-based detection
+    2. Determines phase signs (±1) for each dimension
+    3. Applies geometric transformations via `_rot_coord()` to align coordinates
+    """
     if phase_map1.shape != phase_map2.shape:
         raise ValueError("phase_map shapes do not match for alignment")
     coords = np.asarray(coords)
@@ -381,28 +451,3 @@ def plot_cohomap(
     _ensure_parent_dir(config.save_path)
     finalize_figure(fig, config)
     return fig
-
-
-def cohomap_upgrade(*args, **kwargs) -> dict[str, Any]:
-    """Legacy alias for EcohoMap (formerly cohomap_upgrade)."""
-    return cohomap(*args, **kwargs)
-
-
-def ecohomap(*args, **kwargs) -> dict[str, Any]:
-    """Alias for EcohoMap (GridCellTorus-style)."""
-    return cohomap(*args, **kwargs)
-
-
-def fit_cohomap_stripes_upgrade(*args, **kwargs) -> tuple[np.ndarray, float]:
-    """Legacy alias for EcohoMap stripe fitting."""
-    return fit_cohomap_stripes(*args, **kwargs)
-
-
-def plot_cohomap_upgrade(*args, **kwargs) -> plt.Figure:
-    """Legacy alias for EcohoMap plotting (formerly plot_cohomap_upgrade)."""
-    return plot_cohomap(*args, **kwargs)
-
-
-def plot_ecohomap(*args, **kwargs) -> plt.Figure:
-    """Alias for EcohoMap plotting."""
-    return plot_cohomap(*args, **kwargs)

canns/analyzer/data/asa/cohomap_vectors.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import os
 from typing import Any
 
 import matplotlib.pyplot as plt
@@ -11,27 +10,37 @@ from scipy.ndimage import rotate
 
 from ...visualization.core import PlotConfig, finalize_figure
 from .cohomap import fit_cohomap_stripes
-
-
-def _ensure_plot_config(
-    config: PlotConfig | None,
-    factory,
-    *args,
-    **defaults,
-) -> PlotConfig:
-    if config is None:
-        return factory(*args, **defaults)
-    return config
-
-
-def _ensure_parent_dir(save_path: str | None) -> None:
-    if save_path:
-        parent = os.path.dirname(save_path)
-        if parent:
-            os.makedirs(parent, exist_ok=True)
+from .utils import _ensure_parent_dir, _ensure_plot_config
 
 
 def _rot_para(params1: np.ndarray, params2: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """Transform stripe fit parameters to canonical orientation.
+
+    This function adjusts the orientation angles of stripe fit parameters to
+    align them with a canonical coordinate system. Unlike `_rot_coord()` which
+    transforms actual coordinate data, this operates on the fit parameters
+    themselves (orientation angles, wavelengths, etc.).
+
+    Parameters
+    ----------
+    params1 : np.ndarray
+        Stripe fit parameters for first dimension. First element is orientation angle.
+    params2 : np.ndarray
+        Stripe fit parameters for second dimension. First element is orientation angle.
+
+    Returns
+    -------
+    x : np.ndarray
+        Transformed parameters for the dimension with stronger horizontal alignment.
+    y : np.ndarray
+        Transformed parameters for the other dimension.
+
+    Notes
+    -----
+    The function selects which parameter set becomes 'x' and 'y' based on which
+    has larger |cos(angle)|, then applies angle adjustments to ensure the stripe
+    vectors are in a canonical orientation for visualization and analysis.
+    """
     if abs(np.cos(params1[0])) < abs(np.cos(params2[0])):
         y = params1.copy()
         x = params2.copy()
@@ -204,12 +213,57 @@ def plot_cohomap_vectors(
 
 
 def _resolve_grid_size(phase_map: np.ndarray, grid_size: int | None, trim: int) -> int:
+    """Determine grid size for stripe fitting.
+
+    Parameters
+    ----------
+    phase_map : np.ndarray
+        Phase map array (2D grid).
+    grid_size : int, optional
+        Explicit grid size. If None, inferred from phase_map shape.
+    trim : int
+        Number of edge bins to trim.
+
+    Returns
+    -------
+    int
+        Grid size to use for stripe fitting.
+    """
     if grid_size is None:
         return int(phase_map.shape[0]) + 2 * trim + 1
     return int(grid_size)
 
 
 def _stripe_fit_map(params: np.ndarray, grid_size: int, trim: int) -> np.ndarray:
+    """Generate a synthetic stripe pattern from fit parameters.
+
+    Creates a 2D cosine stripe pattern based on the fitted parameters (orientation,
+    phase, and spatial frequency). Used for visualizing the fitted stripe model
+    and comparing it with the actual phase map.
+
+    Parameters
+    ----------
+    params : np.ndarray
+        Stripe fit parameters: [angle, phase, frequency].
+        - angle: Orientation angle in radians
+        - phase: Phase offset in radians
+        - frequency: Spatial frequency (inverse wavelength)
+    grid_size : int
+        Size of the grid to generate (before trimming).
+    trim : int
+        Number of edge bins to trim from the generated pattern.
+
+    Returns
+    -------
+    np.ndarray
+        2D array of shape (grid_size-2*trim, grid_size-2*trim) containing
+        the cosine stripe pattern with values in [-1, 1].
+
+    Notes
+    -----
+    The pattern is generated on a [0, 3π] × [0, 3π] domain to cover the
+    extended torus space, then rotated by the fitted angle and trimmed.
+    """
     numangsint = grid_size
     x, _ = np.meshgrid(
         np.linspace(0, 3 * np.pi, numangsint - 1),

canns/analyzer/data/asa/cohospace.py

@@ -219,33 +219,3 @@ def plot_cohospace_skewed(
     _ensure_parent_dir(config.save_path)
     finalize_figure(fig, config)
     return fig
-
-
-def cohospace_upgrade(*args, **kwargs) -> dict[str, Any]:
-    """Legacy alias for EcohoSpace (formerly cohospace_upgrade)."""
-    return cohospace(*args, **kwargs)
-
-
-def ecohospace(*args, **kwargs) -> dict[str, Any]:
-    """Alias for EcohoSpace (GridCellTorus-style)."""
-    return cohospace(*args, **kwargs)
-
-
-def plot_cohospace_upgrade(*args, **kwargs) -> plt.Figure:
-    """Legacy alias for EcohoSpace plotting (formerly plot_cohospace_upgrade)."""
-    return plot_cohospace(*args, **kwargs)
-
-
-def plot_cohospace_upgrade_skewed(*args, **kwargs) -> plt.Figure:
-    """Legacy alias for EcohoSpace skewed plotting."""
-    return plot_cohospace_skewed(*args, **kwargs)
-
-
-def plot_ecohospace(*args, **kwargs) -> plt.Figure:
-    """Alias for EcohoSpace plotting."""
-    return plot_cohospace(*args, **kwargs)
-
-
-def plot_ecohospace_skewed(*args, **kwargs) -> plt.Figure:
-    """Alias for EcohoSpace skewed plotting."""
-    return plot_cohospace_skewed(*args, **kwargs)

canns/analyzer/data/asa/cohospace_phase_centers.py

@@ -2,32 +2,14 @@
 
 from __future__ import annotations
 
-import os
 from typing import Any
 
 import matplotlib.pyplot as plt
 import numpy as np
 
 from ...visualization.core import PlotConfig, finalize_figure
-from .cohospace_scatter import skew_transform_torus_scatter
-
-
-def _ensure_plot_config(
-    config: PlotConfig | None,
-    factory,
-    *args,
-    **defaults,
-) -> PlotConfig:
-    if config is None:
-        return factory(*args, **defaults)
-    return config
-
-
-def _ensure_parent_dir(save_path: str | None) -> None:
-    if save_path:
-        parent = os.path.dirname(save_path)
-        if parent:
-            os.makedirs(parent, exist_ok=True)
+from .path import skew_transform
+from .utils import _ensure_parent_dir, _ensure_plot_config
 
 
 def cohospace_phase_centers(cohospace_result: dict[str, Any]) -> dict[str, Any]:
@@ -40,7 +22,7 @@ def cohospace_phase_centers(cohospace_result: dict[str, Any]) -> dict[str, Any]:
         Output from `data.cohospace(...)` (must include `centers`).
     """
     centers = np.asarray(cohospace_result["centers"], dtype=float) % (2 * np.pi)
-    centers_skew = skew_transform_torus_scatter(centers)
+    centers_skew = skew_transform(centers)
     return {
         "centers": centers,
         "centers_skew": centers_skew,

canns/analyzer/data/asa/cohospace_scatter.py

@@ -2,38 +2,13 @@
 
 from __future__ import annotations
 
-import os
-
 import matplotlib.pyplot as plt
 import numpy as np
 from scipy.stats import circvar
 
 from ...visualization.core import PlotConfig, finalize_figure
-
-
-def _ensure_plot_config(
-    config: PlotConfig | None,
-    factory,
-    *,
-    kwargs: dict | None = None,
-    **defaults,
-) -> PlotConfig:
-    if config is None:
-        defaults.update({"kwargs": kwargs or {}})
-        return factory(**defaults)
-
-    if kwargs:
-        config_kwargs = config.kwargs or {}
-        config_kwargs.update(kwargs)
-        config.kwargs = config_kwargs
-    return config
-
-
-def _ensure_parent_dir(save_path: str | None) -> None:
-    if save_path:
-        parent = os.path.dirname(save_path)
-        if parent:
-            os.makedirs(parent, exist_ok=True)
+from .path import _align_activity_to_coords, skew_transform
+from .utils import _ensure_parent_dir, _ensure_plot_config
 
 
 # =====================================================================
@@ -48,51 +23,6 @@ def _coho_coords_to_degrees(coords: np.ndarray) -> np.ndarray:
     return np.degrees(coords % (2 * np.pi))
 
 
-def _align_activity_to_coords(
-    coords: np.ndarray,
-    activity: np.ndarray,
-    times: np.ndarray | None = None,
-    *,
-    label: str = "activity",
-    auto_filter: bool = True,
-) -> np.ndarray:
-    """
-    Align activity to coords by optional time indices and validate lengths.
-    """
-    coords = np.asarray(coords)
-    activity = np.asarray(activity)
-
-    if times is not None:
-        times = np.asarray(times)
-        try:
-            activity = activity[times]
-        except Exception as exc:
-            raise ValueError(
-                f"Failed to index {label} with `times`. Ensure `times` indexes the original time axis."
-            ) from exc
-
-    if activity.shape[0] != coords.shape[0]:
-        # Try to reproduce decode's zero-spike filtering if lengths mismatch.
-        if auto_filter and times is None and activity.ndim == 2:
-            mask = np.sum(activity > 0, axis=1) >= 1
-            if mask.sum() == coords.shape[0]:
-                activity = activity[mask]
-            else:
-                raise ValueError(
-                    f"{label} length must match coords length. Got {activity.shape[0]} vs {coords.shape[0]}. "
-                    "If coords are computed on a subset of timepoints (e.g., decode['times']), pass "
-                    "`times=decoding['times']` or slice the activity accordingly."
-                )
-        else:
-            raise ValueError(
-                f"{label} length must match coords length. Got {activity.shape[0]} vs {coords.shape[0]}. "
-                "If coords are computed on a subset of timepoints (e.g., decode['times']), pass "
-                "`times=decoding['times']` or slice the activity accordingly."
-            )
-
-    return activity
-
-
 def plot_cohospace_scatter_trajectory_2d(
     coords: np.ndarray,
     times: np.ndarray | None = None,
@@ -802,41 +732,6 @@ def compute_cohoscore_scatter_1d(
     return scores
 
 
-def skew_transform_torus_scatter(coords):
-    """
-    Convert torus angles (theta1, theta2) into coordinates in a skewed parallelogram fundamental domain.
-
-    Given theta1, theta2 in radians, map:
-        x = theta1 + 0.5 * theta2
-        y = (sqrt(3)/2) * theta2
-
-    This is a linear change of basis that turns the square [0, 2π)×[0, 2π) into a 60-degree
-    parallelogram, which is convenient for visualizing wrap-around behavior on a 2-torus.
-
-    Parameters
-    ----------
-    coords : ndarray, shape (T, 2)
-        Angles (theta1, theta2) in radians.
-
-    Returns
-    -------
-    xy : ndarray, shape (T, 2)
-        Skewed planar coordinates.
-    """
-    coords = np.asarray(coords)
-    if coords.ndim != 2 or coords.shape[1] != 2:
-        raise ValueError(f"coords must be (T,2), got {coords.shape}")
-
-    theta1 = coords[:, 0]
-    theta2 = coords[:, 1]
-
-    # Linear change of basis (NO nonlinear scaling)
-    x = theta1 + 0.5 * theta2
-    y = (np.sqrt(3) / 2.0) * theta2
-
-    return np.stack([x, y], axis=1)
-
-
 def draw_torus_parallelogram_grid_scatter(ax, n_tiles=1, color="0.7", lw=1.0, alpha=0.8):
     """
     Draw parallelogram grid corresponding to torus fundamental domain.
@@ -874,7 +769,7 @@ def tile_parallelogram_points_scatter(xy, n_tiles=1):
     Parameters
     ----------
     points : ndarray, shape (T, 2)
-        Points in the skewed plane (same coordinates as returned by `skew_transform_torus_scatter`).
+        Points in the skewed plane (same coordinates as returned by `skew_transform`).
     n_tiles : int
         Number of tiles to extend around the base domain.
         - n_tiles=1 produces a 3x3 tiling
@@ -1020,7 +915,7 @@ def plot_cohospace_scatter_neuron_skewed(
         )
 
     # --- skew transform
-    xy = skew_transform_torus_scatter(coords[mask])
+    xy = skew_transform(coords[mask])
 
     # Tiling: if points are tiled, values must be tiled too (FR mode) to keep lengths consistent
     if n_tiles and n_tiles > 0:
@@ -1165,7 +1060,7 @@ def plot_cohospace_scatter_population_skewed(
             thr = np.percentile(a, 100 - top_percent)
             mask = a >= thr
 
-        xy = skew_transform_torus_scatter(coords[mask])
+        xy = skew_transform(coords[mask])
 
         if n_tiles and n_tiles > 0:
             xy = tile_parallelogram_points_scatter(xy, n_tiles=n_tiles)

canns/analyzer/data/asa/embedding.py

@@ -6,7 +6,6 @@ import numpy as np
 from scipy.ndimage import gaussian_filter1d
 
 from .config import DataLoadError, ProcessingError, SpikeEmbeddingConfig
-from .filters import _gaussian_filter1d
 
 
 def embed_spike_trains(spike_trains, config: SpikeEmbeddingConfig | None = None, **kwargs):
@@ -262,8 +261,8 @@ def _load_pos(t, x, y, res=100000, dt=1000):
     xx = np.interp(tt, t, x)
     yy = np.interp(tt, t, y)
 
-    xxs = _gaussian_filter1d(xx - np.min(xx), sigma=100)
-    yys = _gaussian_filter1d(yy - np.min(yy), sigma=100)
+    xxs = gaussian_filter1d(xx - np.min(xx), sigma=100)
+    yys = gaussian_filter1d(yy - np.min(yy), sigma=100)
     dx = (xxs[1:] - xxs[:-1]) * 100
     dy = (yys[1:] - yys[:-1]) * 100
     speed = np.sqrt(dx**2 + dy**2) / 0.01

canns/analyzer/data/asa/fr.py

@@ -1,18 +1,11 @@
 from __future__ import annotations
 
-import os
 from dataclasses import dataclass
 
 import numpy as np
 
 from ...visualization.core import PlotConfig, finalize_figure
-
-
-def _ensure_parent_dir(save_path: str | None) -> None:
-    if save_path:
-        parent = os.path.dirname(save_path)
-        if parent:
-            os.makedirs(parent, exist_ok=True)
+from .utils import _ensure_parent_dir
 
 
 def _slice_range(r: tuple[int, int] | None, length: int) -> slice:

canns/analyzer/data/asa/path.py

@@ -240,6 +240,76 @@ def interp_coords_to_full_1d(idx_map: np.ndarray, coords1: np.ndarray, T_full: i
     return np.mod(out, 2 * np.pi)[:, None]
 
 
+def _align_activity_to_coords(
+    coords: np.ndarray,
+    activity: np.ndarray,
+    times: np.ndarray | None = None,
+    *,
+    label: str = "activity",
+    auto_filter: bool = True,
+) -> np.ndarray:
+    """
+    Align activity to coords by optional time indices and validate lengths.
+
+    Parameters
+    ----------
+    coords : ndarray
+        Decoded coordinates array.
+    activity : ndarray
+        Activity matrix (firing rate or spikes).
+    times : ndarray, optional
+        Optional time indices to align activity to coords when coords are computed
+        on a subset of timepoints.
+    label : str
+        Label for error messages (default: "activity").
+    auto_filter : bool
+        If True and lengths mismatch, auto-filter activity with activity>0 to mimic
+        decode filtering.
+
+    Returns
+    -------
+    ndarray
+        Aligned activity array.
+
+    Raises
+    ------
+    ValueError
+        If activity length doesn't match coords length after alignment attempts.
+    """
+    coords = np.asarray(coords)
+    activity = np.asarray(activity)
+
+    if times is not None:
+        times = np.asarray(times)
+        try:
+            activity = activity[times]
+        except Exception as exc:
+            raise ValueError(
+                f"Failed to index {label} with `times`. Ensure `times` indexes the original time axis."
+            ) from exc
+
+    if activity.shape[0] != coords.shape[0]:
+        # Try to reproduce decode's zero-spike filtering if lengths mismatch.
+        if auto_filter and times is None and activity.ndim == 2:
+            mask = np.sum(activity > 0, axis=1) >= 1
+            if mask.sum() == coords.shape[0]:
+                activity = activity[mask]
+            else:
+                raise ValueError(
+                    f"{label} length must match coords length. Got {activity.shape[0]} vs {coords.shape[0]}. "
+                    "If coords are computed on a subset of timepoints (e.g., decode['times']), pass "
+                    "`times=decoding['times']` or slice the activity accordingly."
+                )
+        else:
+            raise ValueError(
+                f"{label} length must match coords length. Got {activity.shape[0]} vs {coords.shape[0]}. "
+                "If coords are computed on a subset of timepoints (e.g., decode['times']), pass "
+                "`times=decoding['times']` or slice the activity accordingly."
+            )
+
+    return activity
+
+
 def align_coords_to_position_2d(
     t_full: np.ndarray,
     x_full: np.ndarray,

canns/analyzer/data/asa/plotting.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import os
 from typing import Any
 
 import matplotlib.pyplot as plt
@@ -24,31 +23,7 @@ from ...visualization.core import (
 from ...visualization.core.jupyter_utils import display_animation_in_jupyter, is_jupyter_environment
 from .config import CANN2DPlotConfig, ProcessingError, SpikeEmbeddingConfig
 from .embedding import embed_spike_trains
-
-
-def _ensure_plot_config(
-    config: PlotConfig | None,
-    factory,
-    *,
-    kwargs: dict[str, Any] | None = None,
-    **defaults: Any,
-) -> PlotConfig:
-    if config is None:
-        defaults.update({"kwargs": kwargs or {}})
-        return factory(**defaults)
-
-    if kwargs:
-        config_kwargs = config.kwargs or {}
-        config_kwargs.update(kwargs)
-        config.kwargs = config_kwargs
-    return config
-
-
-def _ensure_parent_dir(save_path: str | None) -> None:
-    if save_path:
-        parent = os.path.dirname(save_path)
-        if parent:
-            os.makedirs(parent, exist_ok=True)
+from .utils import _ensure_parent_dir, _ensure_plot_config
 
 
 def _render_torus_frame(frame_index: int, frame_data: dict[str, Any]) -> np.ndarray:

canns/analyzer/data/asa/utils.py

@@ -0,0 +1,160 @@
+"""Shared utility functions for ASA (Attractor State Analysis) modules."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import numpy as np
+from scipy.ndimage import gaussian_filter
+
+from ...visualization.core import PlotConfig
+from .path import find_coords_matrix, find_times_box
+
+
+def _ensure_plot_config(
+    config: PlotConfig | None,
+    factory,
+    *args,
+    kwargs: dict | None = None,
+    **defaults,
+) -> PlotConfig:
+    """Ensure a PlotConfig exists, creating one from factory if needed.
+
+    Args:
+        config: Optional existing PlotConfig.
+        factory: Factory function to create PlotConfig if config is None.
+        *args: Positional arguments for factory.
+        kwargs: Optional dict to merge into config.kwargs.
+        **defaults: Keyword arguments for factory.
+
+    Returns:
+        PlotConfig instance.
+    """
+    if config is None:
+        if kwargs:
+            defaults.update({"kwargs": kwargs})
+        return factory(*args, **defaults)
+
+    # If config exists and kwargs provided, merge them
+    if kwargs:
+        config_kwargs = config.kwargs or {}
+        config_kwargs.update(kwargs)
+        config.kwargs = config_kwargs
+    return config
+
+
+def _ensure_parent_dir(save_path: str | None) -> None:
+    """Create parent directory for save_path if it doesn't exist.
+
+    Args:
+        save_path: Optional file path. If provided, creates parent directory.
+    """
+    if save_path:
+        parent = os.path.dirname(save_path)
+        if parent:
+            os.makedirs(parent, exist_ok=True)
+
+
+def _circmean(x: np.ndarray) -> float:
+    """Compute circular mean of angles.
+
+    Args:
+        x: Array of angles in radians.
+
+    Returns:
+        Circular mean in radians.
+    """
+    return float(np.arctan2(np.mean(np.sin(x)), np.mean(np.cos(x))))
+
+
+def _smooth_circular_map(
+    mtot: np.ndarray,
+    smooth_sigma: float,
+    *,
+    fill_nan: bool = False,
+    fill_sigma: float | None = None,
+    fill_min_weight: float = 1e-3,
+) -> np.ndarray:
+    """Smooth a circular phase map using Gaussian filtering in sin/cos space.
+
+    Args:
+        mtot: Phase map array (angles in radians).
+        smooth_sigma: Gaussian smoothing sigma.
+        fill_nan: Whether to fill NaN values using weighted interpolation.
+        fill_sigma: Sigma for NaN filling (defaults to smooth_sigma).
+        fill_min_weight: Minimum weight threshold for valid interpolation.
+
+    Returns:
+        Smoothed phase map.
+    """
+    mtot = np.asarray(mtot, dtype=float)
+    nans = np.isnan(mtot)
+    mask = (~nans).astype(float)
+    sintot = np.sin(mtot)
+    costot = np.cos(mtot)
+    sintot[nans] = 0.0
+    costot[nans] = 0.0
+
+    if fill_nan:
+        if fill_sigma is None:
+            fill_sigma = smooth_sigma if smooth_sigma and smooth_sigma > 0 else 1.0
+        weight = gaussian_filter(mask, fill_sigma)
+        sintot = gaussian_filter(sintot * mask, fill_sigma)
+        costot = gaussian_filter(costot * mask, fill_sigma)
+        min_weight = max(float(fill_min_weight), 0.0)
+        valid = weight > min_weight
+        sintot = np.divide(sintot, weight, out=np.zeros_like(sintot), where=valid)
+        costot = np.divide(costot, weight, out=np.zeros_like(costot), where=valid)
+        mtot = np.arctan2(sintot, costot)
+        if fill_min_weight > 0:
+            mtot[~valid] = np.nan
+        return mtot
+
+    if smooth_sigma and smooth_sigma > 0:
+        sintot = gaussian_filter(sintot, smooth_sigma)
+        costot = gaussian_filter(costot, smooth_sigma)
+    mtot = np.arctan2(sintot, costot)
+    mtot[nans] = np.nan
+    return mtot
+
+
+def _extract_coords_and_times(
+    decoding_result: dict[str, Any],
+    coords_key: str | None = None,
+) -> tuple[np.ndarray, np.ndarray | None]:
+    """Extract coordinates and time indices from decoding result.
+
+    Args:
+        decoding_result: Dictionary containing decoding results.
+        coords_key: Optional key for coordinates (defaults to 'coordsbox' or auto-detect).
+
+    Returns:
+        Tuple of (coords, times_box) where coords is (T, 2) and times_box is optional.
+    """
+    if coords_key is not None:
+        if coords_key not in decoding_result:
+            raise KeyError(f"coords_key '{coords_key}' not found in decoding_result.")
+        coords = np.asarray(decoding_result[coords_key])
+    elif "coordsbox" in decoding_result:
+        coords = np.asarray(decoding_result["coordsbox"])
+    else:
+        coords, _ = find_coords_matrix(decoding_result)
+
+    times_box, _ = find_times_box(decoding_result)
+    return coords, times_box
+
+
+def _phase_map_valid_fraction(phase_map: np.ndarray) -> float:
+    """Calculate fraction of valid (non-NaN) values in phase map.
+
+    Args:
+        phase_map: Phase map array.
+
+    Returns:
+        Fraction of valid values (0.0 to 1.0).
+    """
+    valid = np.isfinite(phase_map)
+    if valid.size == 0:
+        return 0.0
+    return float(np.mean(valid))

canns/analyzer/data/cell_classification/visualization/btn_plots.py

@@ -8,6 +8,7 @@ import numpy as np
 from matplotlib import pyplot as plt
 from scipy.ndimage import gaussian_filter1d
 
+from canns.analyzer.data.asa.utils import _ensure_plot_config
 from canns.analyzer.visualization.core.config import PlotConfig, finalize_figure
 
 _DEFAULT_BTN_COLORS = {
@@ -17,24 +18,6 @@ _DEFAULT_BTN_COLORS = {
 }
 
 
-def _ensure_plot_config(
-    config: PlotConfig | None,
-    factory,
-    *,
-    kwargs: dict[str, Any] | None = None,
-    **defaults: Any,
-) -> PlotConfig:
-    if config is None:
-        defaults.update({"kwargs": kwargs or {}})
-        return factory(**defaults)
-
-    if kwargs:
-        config_kwargs = config.kwargs or {}
-        config_kwargs.update(kwargs)
-        config.kwargs = config_kwargs
-    return config
-
-
 def _canonical_label(label: str) -> str:
     lab = label.strip().lower()
     if lab in ("b", "bursty"):

{canns-0.15.0.dist-info → canns-0.15.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: canns
-Version: 0.15.0
+Version: 0.15.1
 Summary: A Python Library for Continuous Attractor Neural Networks
 Project-URL: Repository, https://github.com/routhleck/canns
 Author-email: Sichao He <sichaohe@outlook.com>

{canns-0.15.0.dist-info → canns-0.15.1.dist-info}/RECORD

@@ -3,23 +3,22 @@ canns/_version.py,sha256=zIvJPOGBFvo4VV6f586rlO_bvhuFp1fsxjf6xhsqkJY,1547
 canns/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 canns/analyzer/__init__.py,sha256=EQ02fYHkpMADp-ojpVCVtapuSPkl6j5WVfdPy0mOTs4,506
 canns/analyzer/data/__init__.py,sha256=RfS8vwApLkNF05Y_lfPaJpN_bRv-mOA_uFziaduDHgI,354
-canns/analyzer/data/asa/__init__.py,sha256=nXaRd49ePAnrjJaUO-FNkN_RlldEkC55e9jszEhmYKM,3897
-canns/analyzer/data/asa/coho.py,sha256=rYKb0ae2ZK7PX_XkDd7JOVNmPRStG6ZLCKvUsseoK1g,2884
-canns/analyzer/data/asa/cohomap.py,sha256=EmlG13f948de1O7Sm9e0YACtjbp9lEoFWeG3-hWRu6M,13437
-canns/analyzer/data/asa/cohomap_scatter.py,sha256=qu5F9UBCG-JuRrQL0Ag0ACAM61bzAGXEYpPgZ-Oqciw,231
-canns/analyzer/data/asa/cohomap_vectors.py,sha256=krzLr-MSw4Az8VD0AZruXHkv6G9i6VOE6AgavDJCGIw,9113
-canns/analyzer/data/asa/cohospace.py,sha256=dQ_HDNW6xGy6RRBUD8zK3FnQksjiupd84ORIwy6NKCE,7668
-canns/analyzer/data/asa/cohospace_phase_centers.py,sha256=JqgDH_SJZOln5wFhnNJ_qnPTlsTBFWb3M5VZX5b0Wrk,4113
-canns/analyzer/data/asa/cohospace_scatter.py,sha256=z13lLFdYkODmjKeOYildM5TgvT2QxmFSh7q8BYS5WjA,37163
+canns/analyzer/data/asa/__init__.py,sha256=JtXp1QgoqsA1_XiZ4TNFnTGP_iKo5fHeJ_V3wpdhN6g,3327
+canns/analyzer/data/asa/coho.py,sha256=775bOruTVSNRjM0A4YRTeiWKVQtEMCR3zTYXgVTeLiw,444
+canns/analyzer/data/asa/cohomap.py,sha256=ZIiH1Mu306jg1lLmeV-akEzbojXQQVKW3nl0PbFKD4M,15217
+canns/analyzer/data/asa/cohomap_vectors.py,sha256=o2eHMqiAvmhZfebOvHZ1zypqZKKgvZu0WLs3KD3Nfis,11273
+canns/analyzer/data/asa/cohospace.py,sha256=8sq1Z0QGDxzC-5YY1n-nDEtqH3vnIsVA0Q1ST7egxTE,6701
+canns/analyzer/data/asa/cohospace_phase_centers.py,sha256=ZQDhd_cBv8SFcVxgGM0nJabTLjKQZ1mg9Ho6duUG0xY,3738
+canns/analyzer/data/asa/cohospace_scatter.py,sha256=lBubii5rz-MiTT_rYa5u59nzw2vkuOcFDnM6UhvvJ9M,33893
 canns/analyzer/data/asa/config.py,sha256=qm0k0nt0xuDUK5t63MG7ii7fgs2XbxyLxKOaOKJuB_s,6398
 canns/analyzer/data/asa/decode.py,sha256=NG8vVx2cPG7uSJDovnC2vzk0dsqU8oR4jaNPxxrvCc0,16501
-canns/analyzer/data/asa/embedding.py,sha256=CupBvkqZJ7zDMQWH-aIfqrOPTdUfv6wfTtZrI4tj0f0,9623
-canns/analyzer/data/asa/filters.py,sha256=D-1mDVn4hBEAphKUgx1gQEUfgbghKcNQhZmr4xEExQA,7146
+canns/analyzer/data/asa/embedding.py,sha256=V1TzOD4wzyx3xmwCBHLLWgX92rBkMjWkFz-F-4xPPxo,9581
 canns/analyzer/data/asa/fly_roi.py,sha256=_scBOd-4t9yv_1tHk7wbXJwPieU-L-QtFJY6fhHpxDI,38031
-canns/analyzer/data/asa/fr.py,sha256=jt99H50e1RRAQgMIdkfK0rBbembZJEr9SMrxK-ZI_LA,13449
-canns/analyzer/data/asa/path.py,sha256=dL6hsqBoPFfC4ZrHDVFDWprbRfJAAYpiq4tIkZ6NvHY,15540
-canns/analyzer/data/asa/plotting.py,sha256=lpQfN55Sy8B5P1YSQhch_wc0e6SIEVCw9Wch7wHw04o,42798
+canns/analyzer/data/asa/fr.py,sha256=-MuA50eTVdVJB7CUBeLelvnm0i0c0pK5NRICLoSD7oo,13292
+canns/analyzer/data/asa/path.py,sha256=JM8NqkhwFx7qDs26n_t2bL5md9V4oR2E2ksXwYAwTug,17965
+canns/analyzer/data/asa/plotting.py,sha256=PuYGZgal67uDRZ4xBczJKbVblqbza4a03re105Wj7vA,42243
 canns/analyzer/data/asa/tda.py,sha256=7IdxhBNEE99qenG6Zi4B5tv_L9K6gAW6HHxYGiErx4c,30574
+canns/analyzer/data/asa/utils.py,sha256=s9R1d6K4op9MnjcBaI4vrnEAC-9KyZE6S9dg_zR0ONs,4899
 canns/analyzer/data/cell_classification/__init__.py,sha256=Ri0VJYn2OI3ygC4m-Xc9rjFvgPLaEykc-D94VxmUclQ,2447
 canns/analyzer/data/cell_classification/core/__init__.py,sha256=J9uqjx2wTK-uh3OWFqP8BkY_ySz3rU_VWRNQ_1t3EbM,865
 canns/analyzer/data/cell_classification/core/btn.py,sha256=rgZdEoMgqgOPah5KHEQAx7pNWDsWBzZ2pNQ5BstTYFM,8546
@@ -35,7 +34,7 @@ canns/analyzer/data/cell_classification/utils/correlation.py,sha256=57Ckn8OQGLip
 canns/analyzer/data/cell_classification/utils/geometry.py,sha256=jOLh3GeO-riR5a7r7Q7uON3HU_bYOZZJLbokU5bjCOQ,12683
 canns/analyzer/data/cell_classification/utils/image_processing.py,sha256=o9bLT4ycJ_IF7SKBe2RqSWIQwNcpi9v4AI-N5vpm_jM,12805
 canns/analyzer/data/cell_classification/visualization/__init__.py,sha256=fmEHZBcurW6y6FwySLoq65b6CH2kNUB02NCVw2ou6Nc,590
-canns/analyzer/data/cell_classification/visualization/btn_plots.py,sha256=nl29Ihe-gayCu_poJIWLN9oT6Srg1yjC-okPZ0IeRjo,7702
+canns/analyzer/data/cell_classification/visualization/btn_plots.py,sha256=wHP6jyzzqvD2bgYriQFu1tZQiHevlYDy8V1fFNBw4M0,7345
 canns/analyzer/data/cell_classification/visualization/grid_plots.py,sha256=NFtyYOe2Szt0EOIwQmZradwEvvRjjm7mm6VnnGThDQ0,7914
 canns/analyzer/data/cell_classification/visualization/hd_plots.py,sha256=nzw1jck3VHvAFsJAGelhrJf1q27A5PI0r3NKVgeea8U,5670
 canns/analyzer/metrics/__init__.py,sha256=DTsrv1HW133_RgvhWzz7Gx-bP2hOZbPO2unCPPyf9gs,178
@@ -166,8 +165,8 @@ canns/trainer/utils.py,sha256=ZdoLiRqFLfKXsWi0KX3wGUp0OqFikwiou8dPf3xvFhE,2847
 canns/typing/__init__.py,sha256=mXySdfmD8fA56WqZTb1Nj-ZovcejwLzNjuk6PRfTwmA,156
 canns/utils/__init__.py,sha256=OMyZ5jqZAIUS2Jr0qcnvvrx6YM-BZ1EJy5uZYeA3HC0,366
 canns/utils/benchmark.py,sha256=oJ7nvbvnQMh4_MZh7z160NPLp-197X0rEnmnLHYlev4,1361
-canns-0.15.0.dist-info/METADATA,sha256=18mW4kldZzRDEw-pm3KnNp_mIQWjoGbj_sFw43GnaSE,9799
-canns-0.15.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-canns-0.15.0.dist-info/entry_points.txt,sha256=57YF2HZp_BG3GeGB8L0m3wR1sSfNyMXF1q4CKEjce6U,164
-canns-0.15.0.dist-info/licenses/LICENSE,sha256=u6NJ1N-QSnf5yTwSk5UvFAdU2yKD0jxG0Xa91n1cPO4,11306
-canns-0.15.0.dist-info/RECORD,,
+canns-0.15.1.dist-info/METADATA,sha256=Rxhq9ndM1JJjHYGYaB_BjffkvlLXO-22xIzwzOm8h1I,9799
+canns-0.15.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+canns-0.15.1.dist-info/entry_points.txt,sha256=57YF2HZp_BG3GeGB8L0m3wR1sSfNyMXF1q4CKEjce6U,164
+canns-0.15.1.dist-info/licenses/LICENSE,sha256=u6NJ1N-QSnf5yTwSk5UvFAdU2yKD0jxG0Xa91n1cPO4,11306
+canns-0.15.1.dist-info/RECORD,,

canns/analyzer/data/asa/cohomap_scatter.py

@@ -1,10 +0,0 @@
-"""Scatter-style CohoMap plotting helpers."""
-
-from __future__ import annotations
-
-from .plotting import plot_cohomap_scatter, plot_cohomap_scatter_multi
-
-__all__ = [
-    "plot_cohomap_scatter",
-    "plot_cohomap_scatter_multi",
-]

canns/analyzer/data/asa/filters.py

@@ -1,208 +0,0 @@
-from __future__ import annotations
-
-import numbers
-
-import numpy as np
-from numpy.exceptions import AxisError
-from scipy.ndimage import _nd_image, _ni_support
-from scipy.ndimage._filters import _invalid_origin
-
-
-def _gaussian_filter1d(
-    input,
-    sigma,
-    axis=-1,
-    order=0,
-    output=None,
-    mode="reflect",
-    cval=0.0,
-    truncate=4.0,
-    *,
-    radius=None,
-):
-    """1-D Gaussian filter.
-
-    Parameters
-    ----------
-    %(input)s
-    sigma : scalar
-        standard deviation for Gaussian kernel
-    %(axis)s
-    order : int, optional
-        An order of 0 corresponds to convolution with a Gaussian
-        kernel. A positive order corresponds to convolution with
-        that derivative of a Gaussian.
-    %(output)s
-    %(mode_reflect)s
-    %(cval)s
-    truncate : float, optional
-        Truncate the filter at this many standard deviations.
-        Default is 4.0.
-    radius : None or int, optional
-        Radius of the Gaussian kernel. If specified, the size of
-        the kernel will be ``2*radius + 1``, and `truncate` is ignored.
-        Default is None.
-
-    Returns
-    -------
-    gaussian_filter1d : ndarray
-
-    Notes
-    -----
-    The Gaussian kernel will have size ``2*radius + 1`` along each axis. If
-    `radius` is None, a default ``radius = round(truncate * sigma)`` will be
-    used.
-
-    Examples
-    --------
-    >>> from scipy.ndimage import gaussian_filter1d
-    >>> import numpy as np
-    >>> gaussian_filter1d([1.0, 2.0, 3.0, 4.0, 5.0], 1)
-    array([ 1.42704095,  2.06782203,  3.        ,  3.93217797,  4.57295905])
-    >>> _gaussian_filter1d([1.0, 2.0, 3.0, 4.0, 5.0], 4)
-    array([ 2.91948343,  2.95023502,  3.        ,  3.04976498,  3.08051657])
-    >>> import matplotlib.pyplot as plt
-    >>> rng = np.random.default_rng()
-    >>> x = rng.standard_normal(101).cumsum()
-    >>> y3 = _gaussian_filter1d(x, 3)
-    >>> y6 = _gaussian_filter1d(x, 6)
-    >>> plt.plot(x, 'k', label='original data')
-    >>> plt.plot(y3, '--', label='filtered, sigma=3')
-    >>> plt.plot(y6, ':', label='filtered, sigma=6')
-    >>> plt.legend()
-    >>> plt.grid()
-    >>> plt.show()
-
-    """
-    sd = float(sigma)
-    # make the radius of the filter equal to truncate standard deviations
-    lw = int(truncate * sd + 0.5)
-    if radius is not None:
-        lw = radius
-    if not isinstance(lw, numbers.Integral) or lw < 0:
-        raise ValueError("Radius must be a nonnegative integer.")
-    # Since we are calling correlate, not convolve, revert the kernel
-    weights = _gaussian_kernel1d(sigma, order, lw)[::-1]
-    return _correlate1d(input, weights, axis, output, mode, cval, 0)
-
-
-def _gaussian_kernel1d(sigma, order, radius):
-    """
-    Computes a 1-D Gaussian convolution kernel.
-    """
-    if order < 0:
-        raise ValueError("order must be non-negative")
-    exponent_range = np.arange(order + 1)
-    sigma2 = sigma * sigma
-    x = np.arange(-radius, radius + 1)
-    phi_x = np.exp(-0.5 / sigma2 * x**2)
-    phi_x = phi_x / phi_x.sum()
-
-    if order == 0:
-        return phi_x
-    else:
-        # f(x) = q(x) * phi(x) = q(x) * exp(p(x))
-        # f'(x) = (q'(x) + q(x) * p'(x)) * phi(x)
-        # p'(x) = -1 / sigma ** 2
-        # Implement q'(x) + q(x) * p'(x) as a matrix operator and apply to the
-        # coefficients of q(x)
-        q = np.zeros(order + 1)
-        q[0] = 1
-        D = np.diag(exponent_range[1:], 1)  # D @ q(x) = q'(x)
-        P = np.diag(np.ones(order) / -sigma2, -1)  # P @ q(x) = q(x) * p'(x)
-        Q_deriv = D + P
-        for _ in range(order):
-            q = Q_deriv.dot(q)
-        q = (x[:, None] ** exponent_range).dot(q)
-        return q * phi_x
-
-
-def _correlate1d(input, weights, axis=-1, output=None, mode="reflect", cval=0.0, origin=0):
-    """Calculate a 1-D correlation along the given axis.
-
-    The lines of the array along the given axis are correlated with the
-    given weights.
-
-    Parameters
-    ----------
-    %(input)s
-    weights : array
-        1-D sequence of numbers.
-    %(axis)s
-    %(output)s
-    %(mode_reflect)s
-    %(cval)s
-    %(origin)s
-
-    Returns
-    -------
-    result : ndarray
-        Correlation result. Has the same shape as `input`.
-
-    Examples
-    --------
-    >>> from scipy.ndimage import correlate1d
-    >>> correlate1d([2, 8, 0, 4, 1, 9, 9, 0], weights=[1, 3])
-    array([ 8, 26,  8, 12,  7, 28, 36,  9])
-    """
-    input = np.asarray(input)
-    weights = np.asarray(weights)
-    complex_input = input.dtype.kind == "c"
-    complex_weights = weights.dtype.kind == "c"
-    if complex_input or complex_weights:
-        if complex_weights:
-            weights = weights.conj()
-            weights = weights.astype(np.complex128, copy=False)
-        kwargs = dict(axis=axis, mode=mode, origin=origin)
-        output = _ni_support._get_output(output, input, complex_output=True)
-        return _complex_via_real_components(_correlate1d, input, weights, output, cval, **kwargs)
-
-    output = _ni_support._get_output(output, input)
-    weights = np.asarray(weights, dtype=np.float64)
-    if weights.ndim != 1 or weights.shape[0] < 1:
-        raise RuntimeError("no filter weights given")
-    if not weights.flags.contiguous:
-        weights = weights.copy()
-    axis = _normalize_axis_index(axis, input.ndim)
-    if _invalid_origin(origin, len(weights)):
-        raise ValueError(
-            "Invalid origin; origin must satisfy "
-            "-(len(weights) // 2) <= origin <= "
-            "(len(weights)-1) // 2"
-        )
-    mode = _ni_support._extend_mode_to_code(mode)
-    _nd_image.correlate1d(input, weights, axis, output, mode, cval, origin)
-    return output
-
-
-def _complex_via_real_components(func, input, weights, output, cval, **kwargs):
-    """Complex convolution via a linear combination of real convolutions."""
-    complex_input = input.dtype.kind == "c"
-    complex_weights = weights.dtype.kind == "c"
-    if complex_input and complex_weights:
-        # real component of the output
-        func(input.real, weights.real, output=output.real, cval=np.real(cval), **kwargs)
-        output.real -= func(input.imag, weights.imag, output=None, cval=np.imag(cval), **kwargs)
-        # imaginary component of the output
-        func(input.real, weights.imag, output=output.imag, cval=np.real(cval), **kwargs)
-        output.imag += func(input.imag, weights.real, output=None, cval=np.imag(cval), **kwargs)
-    elif complex_input:
-        func(input.real, weights, output=output.real, cval=np.real(cval), **kwargs)
-        func(input.imag, weights, output=output.imag, cval=np.imag(cval), **kwargs)
-    else:
-        if np.iscomplexobj(cval):
-            raise ValueError("Cannot provide a complex-valued cval when the input is real.")
-        func(input, weights.real, output=output.real, cval=cval, **kwargs)
-        func(input, weights.imag, output=output.imag, cval=cval, **kwargs)
-    return output
-
-
-def _normalize_axis_index(axis, ndim):
-    # Check if `axis` is in the correct range and normalize it
-    if axis < -ndim or axis >= ndim:
-        msg = f"axis {axis} is out of bounds for array of dimension {ndim}"
-        raise AxisError(msg)
-
-    if axis < 0:
-        axis = axis + ndim
-    return axis