dct-toolkit 1.0.0__tar.gz → 2.0.0__tar.gz

{dct_toolkit-1.0.0 → dct_toolkit-2.0.0}/AGENTS.md

@@ -1,11 +1,11 @@
 # AGENTS.md - DCT Toolkit Agent Guidelines
 
 **Project**: dct-toolkit  
-**Version**: 1.0.0
+**Version**: 2.0.0
 
-**Status**: Geometry-aware N-D polar release track
+**Status**: Full sampled Gaussian statistics release track
 
-**Last Updated**: 2026-10-26
+**Last Updated**: 2026-11-11
 
 ---
 
@@ -330,7 +330,7 @@ Before declaring task complete:
 - New public APIs need independent numerical tests and an independent code/docs review.
 - Do not modify manuscripts or review trackers as part of this software task.
 
-### Future Beyond v1.0.0
+### Future Beyond v2.0.0
 
 - [ ] Additional kernels (Savitzky-Golay, Hanning)
 - [ ] Performance optimizations (numba?)
@@ -345,7 +345,11 @@ Before declaring task complete:
 ### Transfer Functions
 - **Boxcar (Analytical)**: `H[k] = sin(W·θ)/(W·sin(θ))`, θ = πk/(2n)
 - **Boxcar (Discrete)**: Sum of cosines for discrete kernels
-- **Gaussian**: `H[k] = exp(-0.5·(ω·σ)²)`, σ = width/√12
+- **Gaussian (default)**: full normalized sampled Gaussian, σ = width/√12;
+  evaluate its cosine sum or equivalent frequency-alias sum to float64 precision.
+  No fixed spatial cutoff; nonnegative spatial weights support statistical moments.
+- **Gaussian (spectral compatibility)**: `gaussian_spectral` retains
+  `H[k] = exp(-0.5·(ω·σ)²)`, σ = width/√12; spatial weights can be signed.
 
 ### Normalized Convolution
 Formula for robust mean with gaps:
@@ -456,8 +460,9 @@ git merge feature/hanning-window
 
 ### Current Version
 
-- Version: `1.0.0`, adding explicit geometry-aware N-D polar processing.
-- Preserve the historical `v0.6.0` and older release records.
+- Version: `2.0.0`, using the full sampled Gaussian by default across smoothing
+  and statistics. Use `gaussian_spectral` to reproduce pre-2.0 Gaussian results.
+- Preserve the historical `v1.0.0`, `v0.6.0`, and older release records.
 - Do not tag, push, upload to PyPI/conda-forge, or create a public archival record
   without approval.
 - See `docs/RELEASING.md` for local artifact verification and release handoff.
@@ -465,7 +470,7 @@ git merge feature/hanning-window
 ### Gap-Filling Status
 - Code exists in `dct_toolkit/gap_filling.py` (available for import directly)
 - **Not exported** in public API (`__init__.py`) — research-internal
-- Full gap-filling to be released in future v1.x after research matures
+- Full gap-filling to be released in a future version after research matures
 
 ---
 

{dct_toolkit-1.0.0 → dct_toolkit-2.0.0}/CHANGELOG.md

@@ -5,6 +5,49 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [2.0.0] - 2026-11-11
+
+Major release changing the default Gaussian's numerical definition. Existing
+calls remain accepted, but Gaussian outputs change. For reproducible pre-2.0
+results, explicitly select `'gaussian_spectral'` wherever Gaussian filtering was
+previously used, including each Gaussian entry in hybrid kernel sequences.
+Widths, coordinate conventions, and the public function signatures are unchanged.
+
+### Breaking Changes
+- Redefine `'gaussian'`, the default kernel, as the full normalized sampled
+  Gaussian rather than the exponential spectral response used in v1.0.0.
+  This affects existing smoothing/statistics calls even when `kernel_type`
+  is omitted. Use `'gaussian_spectral'` to retain the previous response.
+
+### Changed
+- Make the default `'gaussian'` kernel the full normalized sampled Gaussian,
+  evaluated to floating-point precision without a fixed spatial truncation.
+  Cartesian, legacy polar, explicit N-D polar, both boundaries, normalized
+  moments, prefill, and fallback now share this nonnegative spatial kernel.
+  Numerical results change, particularly for widths near or below one grid cell.
+- Preserve the previous exponential response as `'gaussian_spectral'` for
+  reproducing v1.0.0 Gaussian results, including per-axis hybrid selections.
+  Its spatial weights can be signed; it is not the default for statistics.
+
+### Fixed
+- Remove substantive negative raw variances caused by Gaussian spatial ringing.
+  The final variance clamp remains for floating-point cancellation. Positivity
+  requires nonnegative kernels on every selected axis; fractional analytical
+  boxcars and `'gaussian_spectral'` do not provide that guarantee.
+- Evaluate broad sampled Gaussians with an equivalent frequency-alias sum,
+  avoiding allocations proportional to potentially enormous effective widths.
+
+### Documentation
+- Document sampled Gaussian normalization, numerical evaluation, narrow-width
+  behavior, statistical guarantees, and migration to `'gaussian_spectral'`.
+- Clarify required N-D polar metadata, the default physical width units, and
+  coordinate dependencies; add a runnable coordinate-free grid-width example.
+- Compare Cartesian and explicit polar N-D processing, including boundaries,
+  axis selection, and the conditions for equivalent finite-data smoothing.
+- Explain input-NaN restoration and the low-level polar width argument in the README.
+
 ## [1.0.0] - 2026-10-26
 
 Geometry-aware N-D polar release, preserving the v0.6.0 legacy 2D interface.

{dct_toolkit-1.0.0 → dct_toolkit-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dct-toolkit
-Version: 1.0.0
+Version: 2.0.0
 Summary: DCT/FFT-based convolutional statistics for Cartesian and polar data
 Author-email: "Jairo M. Valdivia" <Jairo.ValdiviaPrado@colorado.edu>
 License: MIT License
@@ -52,8 +52,10 @@ Description-Content-Type: text/markdown
 `dct_toolkit` provides DCT/FFT-based smoothing and normalized-convolution statistics
 for data with gaps. Runtime dependencies are NumPy and SciPy only.
 
-**Version: v1.0.0.** Geometry-aware N-D polar processing requires version 1.0.0
-or newer. Existing 2D polar calls retain their index-based width conventions.
+**Version: v2.0.0.** The default Gaussian now uses the full normalized sampled
+kernel. To retain pre-2.0 Gaussian results, select `'gaussian_spectral'` explicitly.
+Geometry-aware N-D polar processing requires version 1.0.0 or newer. Existing 2D
+polar calls retain their index-based width conventions.
 
 ## Scope
 
@@ -148,7 +150,7 @@ order. Azimuth width adapts with range:
 azimuth spacing in radians. Range width is in range gates. Gaussian
 `sigma = effective_width / sqrt(12)` on the selected axis. Filtering applies
 azimuth first, then range; both periodic and reflective azimuth support all
-three kernel types, including `'boxcar_discrete'`.
+four kernel types, including `'boxcar_discrete'` and `'gaussian_spectral'`.
 `az_res_deg` must be a finite, positive scalar in degrees. For gapped data,
 periodic azimuth also wraps the nearest-neighbor prefill fallback across the
 sweep seam; range distances remain nonperiodic.
@@ -164,10 +166,35 @@ var = dct.dct_variance(data, width=10.0)
 std = dct.dct_std(data, width=10.0)
 ```
 
+Version 2.0.0 changes the default `'gaussian'` to the **full normalized
+sampled Gaussian**, evaluated to floating-point precision with no fixed spatial
+cutoff. Its spatial weights are nonnegative, so normalized means stay within the
+supported data range and population variances are nonnegative in exact arithmetic.
+This applies to Cartesian and both polar modes, including reflective/periodic
+boundaries and gap prefill. For mixed statistical kernels, use `'boxcar_discrete'`
+on boxcar axes to retain this property; fractional analytical `'boxcar'` kernels
+can have signed weights.
+
+**Migration from v1.0.0 to v2.0.0:** Gaussian results change, especially at narrow widths.
+Use `kernel_type="gaussian_spectral"` to retain the previous
+`exp(-0.5 * (omega * sigma)**2)` response. Both Gaussian types use
+`sigma = effective_grid_width / sqrt(12)`. Sampling means the new kernel's actual
+second moment need not equal `sigma**2`; very small widths approach identity.
+Variance still uses a numerical nonnegativity clamp; that clamp cannot repair
+signed-weight statistical estimates.
+
+For hybrid kernels, replace each previous `'gaussian'` entry with
+`'gaussian_spectral'` to reproduce earlier results. For example,
+`('gaussian', 'boxcar_discrete')` becomes
+`('gaussian_spectral', 'boxcar_discrete')`. Set this explicitly for every
+smoothing/statistics call that must retain the old response; prefill and
+fallback inherit the selected kernels. Calls that omit `kernel_type` use the
+new sampled Gaussian.
+
 ### 4) Mixed Kernels for a 3D Volume
 
 For a volume stored in **(z, y, x)** order, apply Gaussian smoothing vertically
-and boxcar smoothing horizontally:
+and discrete boxcar smoothing horizontally:
 
 ```python
 rng = np.random.default_rng(42)
@@ -176,7 +203,7 @@ volume = rng.standard_normal((16, 32, 32))  # (z, y, x)
 smoothed = dct.dct_smooth(
     volume,
     width=(3.0, 5.0, 5.0),
-    kernel_type=("gaussian", "boxcar", "boxcar"),
+    kernel_type=("gaussian", "boxcar_discrete", "boxcar_discrete"),
 )
 
 # The same kernels work with normalized statistics on data containing NaNs.
@@ -184,7 +211,7 @@ volume[5:7, 12:15, 12:15] = np.nan
 mean = dct.dct_mean(
     volume,
     width=(3.0, 5.0, 5.0),
-    kernel_type=("gaussian", "boxcar", "boxcar"),
+    kernel_type=("gaussian", "boxcar_discrete", "boxcar_discrete"),
 )
 ```
 
@@ -196,7 +223,89 @@ kernel string applies that kernel to every axis. Equal widths with different
 kernel types can still produce anisotropic smoothing. Legacy polar smoothing
 accepts a kernel pair, using the `(azimuth, range)` convention shown above.
 
-### 5) N-D Polar Geometry with Actual Coordinates (v1.0.0)
+### 5) N-D Polar Smoothing (v1.0.0)
+
+#### Which inputs are required?
+
+Use `coordinates="polar"` to select the polar backend and supply `axis_types`
+to enable explicit N-D geometry. You do **not** need to supply all three of
+`axis_types`, `axis_coords`, and `width_units` in every call:
+
+| Argument | Required for explicit N-D polar processing? |
+|----------|--------------------------------------------|
+| `axis_types` | **Yes:** one role per array axis, in array order. |
+| `axis_coords` | Only where physical width conversion or geometry dependencies need them. |
+| `width_units` | **No:** defaults to `"physical"`; use `"grid"` for widths in cells. |
+
+With `width_units="grid"`, no coordinate arrays are required. Physical filtering
+needs coordinates on selected, non-singleton axes. Physical angular filtering
+also needs actual positive range coordinates; physical azimuth filtering needs
+elevation coordinates when that role exists. These geometry dependencies remain
+required even when range/elevation are unfiltered. Coordinate entries for batch
+or unfiltered axes may otherwise be `None`; supplied coordinates are always
+validated.
+
+Omitting `axis_types` does **not** infer N-D geometry: it retains the legacy
+2D `(azimuth, range)` mode described above.
+
+#### Start with grid widths: no coordinates needed
+
+This self-contained example filters a `(time, elevation, azimuth, range)` array
+using widths in cells, with periodic azimuth and reflective boundaries elsewhere:
+
+```python
+import numpy as np
+import dct_toolkit as dct
+
+data = np.random.default_rng(42).standard_normal((3, 3, 36, 24))
+data[0, 1, :3, 8:12] = np.nan
+
+mean_grid = dct.dct_mean(
+    data,
+    width=(3.0, 3.0, 5.0, 7.0),             # time, elevation, azimuth, range cells
+    coordinates="polar",
+    axis_types=("time", "elevation", "azimuth", "range"),
+    width_units="grid",
+    boundary=("reflective", "reflective", "periodic", "reflective"),
+    restore_input_nan=False,                # retain supported estimates inside gaps
+)
+```
+
+By default, `dct_mean` restores input NaNs. Setting `restore_input_nan=False`
+keeps estimates in gaps where support exists; wholly missing independent domains
+still remain NaN. To keep time slices independent, add `filter_axes=(1, 2, 3)`.
+Still supply one positive width per array axis; the unfiltered time width is then
+an unused placeholder.
+
+#### How does this differ from Cartesian N-D?
+
+Both backends already handle N-dimensional arrays. The polar extension adds
+geometry and filtering controls, not just more dimensions:
+
+| Feature | Cartesian N-D | Explicit polar N-D |
+|---------|---------------|--------------------|
+| Axis roles | Not specified | Named roles in array order |
+| Width units | Grid cells | Grid or coordinate-based physical units |
+| Angular widths | No angular metric | Physical widths adapt with range/elevation |
+| Boundaries | Reflective on every axis | Reflective or periodic per axis |
+| Filtered axes | All axes | `filter_axes`; batch axes excluded |
+
+Cartesian calls need no axis metadata: `dct.dct_mean(data, width=(3, 3, 5, 7))`.
+Convert physical Cartesian widths to cells yourself using each axis's spacing.
+Polar physical angular widths additionally account for range and elevation, as
+shown below; they are distances, not degrees or radians.
+
+With grid widths, the same widths/kernels, every axis filtered, and all boundaries
+reflective, **finite-data smoothing matches Cartesian smoothing** up to numerical
+rounding. This equivalence concerns the smoothing operator, not nominal count
+conventions or missing-data fallback rules.
+
+The same polar geometry options work with `dct_smooth`, `dct_variance`, `dct_std`,
+`dct_count`, and `dct_prefill`. The low-level `smooth_polar` uses `width_pixels=`
+instead of `width=` and does not take `coordinates=`. See the
+[API reference](docs/API_REFERENCE.md#dct_toolkitpolar) for full syntax and validation.
+
+#### Physical widths with actual coordinates
 
 For a regular array in **(time, elevation, azimuth, range)** order:
 

{dct_toolkit-1.0.0 → dct_toolkit-2.0.0}/README.md

@@ -6,8 +6,10 @@
 `dct_toolkit` provides DCT/FFT-based smoothing and normalized-convolution statistics
 for data with gaps. Runtime dependencies are NumPy and SciPy only.
 
-**Version: v1.0.0.** Geometry-aware N-D polar processing requires version 1.0.0
-or newer. Existing 2D polar calls retain their index-based width conventions.
+**Version: v2.0.0.** The default Gaussian now uses the full normalized sampled
+kernel. To retain pre-2.0 Gaussian results, select `'gaussian_spectral'` explicitly.
+Geometry-aware N-D polar processing requires version 1.0.0 or newer. Existing 2D
+polar calls retain their index-based width conventions.
 
 ## Scope
 
@@ -102,7 +104,7 @@ order. Azimuth width adapts with range:
 azimuth spacing in radians. Range width is in range gates. Gaussian
 `sigma = effective_width / sqrt(12)` on the selected axis. Filtering applies
 azimuth first, then range; both periodic and reflective azimuth support all
-three kernel types, including `'boxcar_discrete'`.
+four kernel types, including `'boxcar_discrete'` and `'gaussian_spectral'`.
 `az_res_deg` must be a finite, positive scalar in degrees. For gapped data,
 periodic azimuth also wraps the nearest-neighbor prefill fallback across the
 sweep seam; range distances remain nonperiodic.
@@ -118,10 +120,35 @@ var = dct.dct_variance(data, width=10.0)
 std = dct.dct_std(data, width=10.0)
 ```
 
+Version 2.0.0 changes the default `'gaussian'` to the **full normalized
+sampled Gaussian**, evaluated to floating-point precision with no fixed spatial
+cutoff. Its spatial weights are nonnegative, so normalized means stay within the
+supported data range and population variances are nonnegative in exact arithmetic.
+This applies to Cartesian and both polar modes, including reflective/periodic
+boundaries and gap prefill. For mixed statistical kernels, use `'boxcar_discrete'`
+on boxcar axes to retain this property; fractional analytical `'boxcar'` kernels
+can have signed weights.
+
+**Migration from v1.0.0 to v2.0.0:** Gaussian results change, especially at narrow widths.
+Use `kernel_type="gaussian_spectral"` to retain the previous
+`exp(-0.5 * (omega * sigma)**2)` response. Both Gaussian types use
+`sigma = effective_grid_width / sqrt(12)`. Sampling means the new kernel's actual
+second moment need not equal `sigma**2`; very small widths approach identity.
+Variance still uses a numerical nonnegativity clamp; that clamp cannot repair
+signed-weight statistical estimates.
+
+For hybrid kernels, replace each previous `'gaussian'` entry with
+`'gaussian_spectral'` to reproduce earlier results. For example,
+`('gaussian', 'boxcar_discrete')` becomes
+`('gaussian_spectral', 'boxcar_discrete')`. Set this explicitly for every
+smoothing/statistics call that must retain the old response; prefill and
+fallback inherit the selected kernels. Calls that omit `kernel_type` use the
+new sampled Gaussian.
+
 ### 4) Mixed Kernels for a 3D Volume
 
 For a volume stored in **(z, y, x)** order, apply Gaussian smoothing vertically
-and boxcar smoothing horizontally:
+and discrete boxcar smoothing horizontally:
 
 ```python
 rng = np.random.default_rng(42)
@@ -130,7 +157,7 @@ volume = rng.standard_normal((16, 32, 32))  # (z, y, x)
 smoothed = dct.dct_smooth(
     volume,
     width=(3.0, 5.0, 5.0),
-    kernel_type=("gaussian", "boxcar", "boxcar"),
+    kernel_type=("gaussian", "boxcar_discrete", "boxcar_discrete"),
 )
 
 # The same kernels work with normalized statistics on data containing NaNs.
@@ -138,7 +165,7 @@ volume[5:7, 12:15, 12:15] = np.nan
 mean = dct.dct_mean(
     volume,
     width=(3.0, 5.0, 5.0),
-    kernel_type=("gaussian", "boxcar", "boxcar"),
+    kernel_type=("gaussian", "boxcar_discrete", "boxcar_discrete"),
 )
 ```
 
@@ -150,7 +177,89 @@ kernel string applies that kernel to every axis. Equal widths with different
 kernel types can still produce anisotropic smoothing. Legacy polar smoothing
 accepts a kernel pair, using the `(azimuth, range)` convention shown above.
 
-### 5) N-D Polar Geometry with Actual Coordinates (v1.0.0)
+### 5) N-D Polar Smoothing (v1.0.0)
+
+#### Which inputs are required?
+
+Use `coordinates="polar"` to select the polar backend and supply `axis_types`
+to enable explicit N-D geometry. You do **not** need to supply all three of
+`axis_types`, `axis_coords`, and `width_units` in every call:
+
+| Argument | Required for explicit N-D polar processing? |
+|----------|--------------------------------------------|
+| `axis_types` | **Yes:** one role per array axis, in array order. |
+| `axis_coords` | Only where physical width conversion or geometry dependencies need them. |
+| `width_units` | **No:** defaults to `"physical"`; use `"grid"` for widths in cells. |
+
+With `width_units="grid"`, no coordinate arrays are required. Physical filtering
+needs coordinates on selected, non-singleton axes. Physical angular filtering
+also needs actual positive range coordinates; physical azimuth filtering needs
+elevation coordinates when that role exists. These geometry dependencies remain
+required even when range/elevation are unfiltered. Coordinate entries for batch
+or unfiltered axes may otherwise be `None`; supplied coordinates are always
+validated.
+
+Omitting `axis_types` does **not** infer N-D geometry: it retains the legacy
+2D `(azimuth, range)` mode described above.
+
+#### Start with grid widths: no coordinates needed
+
+This self-contained example filters a `(time, elevation, azimuth, range)` array
+using widths in cells, with periodic azimuth and reflective boundaries elsewhere:
+
+```python
+import numpy as np
+import dct_toolkit as dct
+
+data = np.random.default_rng(42).standard_normal((3, 3, 36, 24))
+data[0, 1, :3, 8:12] = np.nan
+
+mean_grid = dct.dct_mean(
+    data,
+    width=(3.0, 3.0, 5.0, 7.0),             # time, elevation, azimuth, range cells
+    coordinates="polar",
+    axis_types=("time", "elevation", "azimuth", "range"),
+    width_units="grid",
+    boundary=("reflective", "reflective", "periodic", "reflective"),
+    restore_input_nan=False,                # retain supported estimates inside gaps
+)
+```
+
+By default, `dct_mean` restores input NaNs. Setting `restore_input_nan=False`
+keeps estimates in gaps where support exists; wholly missing independent domains
+still remain NaN. To keep time slices independent, add `filter_axes=(1, 2, 3)`.
+Still supply one positive width per array axis; the unfiltered time width is then
+an unused placeholder.
+
+#### How does this differ from Cartesian N-D?
+
+Both backends already handle N-dimensional arrays. The polar extension adds
+geometry and filtering controls, not just more dimensions:
+
+| Feature | Cartesian N-D | Explicit polar N-D |
+|---------|---------------|--------------------|
+| Axis roles | Not specified | Named roles in array order |
+| Width units | Grid cells | Grid or coordinate-based physical units |
+| Angular widths | No angular metric | Physical widths adapt with range/elevation |
+| Boundaries | Reflective on every axis | Reflective or periodic per axis |
+| Filtered axes | All axes | `filter_axes`; batch axes excluded |
+
+Cartesian calls need no axis metadata: `dct.dct_mean(data, width=(3, 3, 5, 7))`.
+Convert physical Cartesian widths to cells yourself using each axis's spacing.
+Polar physical angular widths additionally account for range and elevation, as
+shown below; they are distances, not degrees or radians.
+
+With grid widths, the same widths/kernels, every axis filtered, and all boundaries
+reflective, **finite-data smoothing matches Cartesian smoothing** up to numerical
+rounding. This equivalence concerns the smoothing operator, not nominal count
+conventions or missing-data fallback rules.
+
+The same polar geometry options work with `dct_smooth`, `dct_variance`, `dct_std`,
+`dct_count`, and `dct_prefill`. The low-level `smooth_polar` uses `width_pixels=`
+instead of `width=` and does not take `coordinates=`. See the
+[API reference](docs/API_REFERENCE.md#dct_toolkitpolar) for full syntax and validation.
+
+#### Physical widths with actual coordinates
 
 For a regular array in **(time, elevation, azimuth, range)** order:
 

{dct_toolkit-1.0.0 → dct_toolkit-2.0.0}/dct_toolkit/__init__.py

@@ -23,7 +23,7 @@ from .stats import (
     dct_variance,
 )
 
-__version__ = "1.0.0"
+__version__ = "2.0.0"
 
 
 __all__ = [
@@ -80,8 +80,10 @@ def dct_smooth(
         and ``az_res_deg`` must be a finite, positive real scalar.
         Geometry and kernels are validated even for all-NaN inputs. The same
         operator is used for prefill and final smoothing. Default kernel is
-        'gaussian'. ``min_effective_density`` and private mean controls apply
-        to prefill only and are not passed to the low-level smoother.
+        the full normalized sampled 'gaussian', evaluated to floating-point
+        precision without a fixed spatial cutoff. Use 'gaussian_spectral' for
+        the v1.0.0 exponential response. ``min_effective_density`` and private
+        mean controls apply to prefill only and are not passed to the low-level smoother.
 
     Returns
     -------

dct_toolkit-2.0.0/dct_toolkit/_gaussian.py

@@ -0,0 +1,50 @@
+"""Full sampled Gaussian responses for reflective and periodic filters."""
+
+import numpy as np
+
+
+def _sampled_gaussian_transfer(n: int, width: float, periodic: bool = False) -> np.ndarray:
+    """Evaluate the normalized infinite sampled Gaussian to float64 precision.
+
+    Parameters
+    ----------
+    n : int
+        Axis length.
+    width : float
+        Effective grid width, with ``sigma = width / sqrt(12)``.
+    periodic : bool, default=False
+        Use RFFT frequencies for a periodic axis, otherwise DCT-II frequencies.
+
+    Returns
+    -------
+    ndarray
+        Response of length ``n // 2 + 1`` (periodic) or ``n`` (reflective).
+
+    Notes
+    -----
+    For sigma < 1, sum the spatial samples directly. The omitted two-sided
+    mass beyond offset 9 is below 4e-22. For sigma >= 1, Poisson summation
+    gives an equivalent sum of frequency-shifted Gaussians. The nearest
+    three aliases suffice: omitted terms are below float64 relative precision
+    throughout the represented frequency interval [0, pi]. Neither evaluation
+    imposes a finite spatial support or allocates memory proportional to width.
+    """
+    n_freq = n // 2 + 1 if periodic else n
+    sigma = width / np.sqrt(12)
+    if sigma == 0 or n_freq == 0:
+        return np.ones(n_freq)
+    omega = (2 if periodic else 1) * np.pi * np.arange(n_freq) / n
+    with np.errstate(over="ignore", under="ignore"):
+        if sigma < 1:
+            offsets = np.arange(1, 10, dtype=float)
+            weights = np.exp(-0.5 * (offsets / sigma) ** 2)
+            response = 1 + 2 * np.sum(
+                weights[:, None] * np.cos(offsets[:, None] * omega), axis=0
+            )
+        else:
+            response = np.zeros(n_freq)
+            for alias in (-1, 0, 1):
+                response += np.exp(-0.5 * ((omega + alias * 2 * np.pi) * sigma) ** 2)
+    response /= response[0]
+    response[0] = 1.0
+    return response

{dct_toolkit-1.0.0 → dct_toolkit-2.0.0}/dct_toolkit/_kernels.py

@@ -26,6 +26,6 @@ def normalize_kernel_types(kernel_type: KernelLike, ndim: int) -> Tuple[str, ...
     for axis, kernel in enumerate(kernels):
         if not isinstance(kernel, str):
             raise ValueError(f"kernel_type entries must be strings, got {kernel!r} at axis {axis}")
-        if kernel not in ("boxcar", "boxcar_discrete", "gaussian"):
+        if kernel not in ("boxcar", "boxcar_discrete", "gaussian", "gaussian_spectral"):
             raise ValueError(f"Unknown kernel type: {kernel!r} at axis {axis}")
     return kernels

{dct_toolkit-1.0.0 → dct_toolkit-2.0.0}/dct_toolkit/cartesian.py

@@ -35,9 +35,9 @@ def smooth_cartesian(
         and follows array axis order. For Gaussian kernels,
         ``sigma = width / sqrt(12)`` along the corresponding axis.
     kernel_type : str or sequence of str, default='gaussian'
-        Kernel type ('boxcar', 'boxcar_discrete', 'gaussian'). A string applies
-        to every axis. A sequence must have length ``data.ndim`` and selects
-        one kernel per axis in array order, independently of ``width``.
+        Kernel type ('boxcar', 'boxcar_discrete', 'gaussian', 'gaussian_spectral').
+        A string applies to every axis. A sequence must have length ``data.ndim``
+        and selects one kernel per axis in array order, independently of ``width``.
 
     Returns
     -------
@@ -55,6 +55,10 @@ def smooth_cartesian(
     Boundaries are reflective on every axis. Equal widths with different
     kernel types can still produce anisotropic smoothing. Input should be
     finite; use ``dct_mean`` or ``dct_smooth`` for data containing NaNs.
+    The default ``gaussian`` is the full normalized sampled Gaussian evaluated
+    to floating-point precision, with no fixed spatial cutoff and nonnegative
+    spatial weights. ``gaussian_spectral`` retains the v1.0.0 exponential
+    response; its spatial weights can be signed.
 
     Examples
     --------

{dct_toolkit-1.0.0 → dct_toolkit-2.0.0}/dct_toolkit/core.py

@@ -9,6 +9,9 @@ This module provides the low-level building blocks for DCT-based smoothing:
 import numpy as np
 import scipy.fft
 
+from ._gaussian import _sampled_gaussian_transfer
+
+
 def get_dct_transfer_function(n: int, kernel_type: str, width: float) -> np.ndarray:
     """
     Generate the 1D DCT Transfer Function H[k].
@@ -18,11 +21,14 @@ def get_dct_transfer_function(n: int, kernel_type: str, width: float) -> np.ndar
     n : int
         Number of points.
     kernel_type : str
-        'boxcar', 'boxcar_discrete', or 'gaussian'.
+        'boxcar', 'boxcar_discrete', 'gaussian', or 'gaussian_spectral'.
+        'gaussian' uses the full nonnegative normalized sampled Gaussian,
+        evaluated to floating-point precision. 'gaussian_spectral' retains
+        the original exponential spectral response, whose spatial weights can be signed.
     width : float
         Kernel width.
         - boxcar: full width
-        - gaussian: equivalent boxcar width (sigma = width / sqrt(12))
+        - both Gaussian types: equivalent boxcar width (sigma = width / sqrt(12))
 
     Returns
     -------
@@ -72,6 +78,9 @@ def get_dct_transfer_function(n: int, kernel_type: str, width: float) -> np.ndar
         return H
         
     elif kernel_type == 'gaussian':
+        return _sampled_gaussian_transfer(n, width)
+
+    elif kernel_type == 'gaussian_spectral':
         # Gaussian: sigma = width / sqrt(12)
         sigma = width / np.sqrt(12)
         if sigma < 1e-9:
@@ -84,6 +93,7 @@ def get_dct_transfer_function(n: int, kernel_type: str, width: float) -> np.ndar
     else:
         raise ValueError(f"Unknown kernel type: {kernel_type}")
 
+
 def dct_convolve_1d(data: np.ndarray, H: np.ndarray, axis: int = -1) -> np.ndarray:
     """
     Apply 1D DCT-based convolution.
@@ -104,7 +114,9 @@ def dct_convolve_1d(data: np.ndarray, H: np.ndarray, axis: int = -1) -> np.ndarr
     """
     # Validate shapes
     if data.shape[axis] != len(H):
-        raise ValueError(f"Transfer function length {len(H)} does not match data dimension {data.shape[axis]}")
+        raise ValueError(
+            f"Transfer function length {len(H)} does not match data dimension {data.shape[axis]}"
+        )
 
     # Broadcast H to data shape
     shape = [1] * data.ndim