[roytsmart]

The Gauss-Seidel method of regridding.fill() had five problems, found while filling the dust spots in IRIS slit-jaw images.

1. NaN neighbors spread into the fill. A missing element next to a NaN element that is not in where (for example, outside an image's field of view) became NaN. The NaN then spread through the rest of the missing region. On 31 IRIS frames, 2,057 filled pixels came out NaN. Infinite elements and NaN values in guess spread the same way.
2. The edges were periodic. The neighbors were indexed modulo the size of the array, so a missing element on one edge was filled using values from the opposite edge.
3. Non-square arrays were weighted unequally. The grid spacing came from mapping each axis onto [-1, 1]. On a (num_y, num_x) array this weighted the two axes in the ratio ((num_x - 1) / (num_y - 1))**2: 1.12 for a 548 × 518 image and 2.4 for 548 × 845. Square arrays were unaffected.
4. Slices of a broadcast a shared memory. a was copied before it was broadcast against where, so when a had fewer dimensions than where, every slice was filled in the same memory. The slices then overwrote each other from parallel threads, giving results off by up to 0.76.
5. A where with fewer dimensions than a raised a FutureWarning. It was a writeable view from np.broadcast_arrays, and numba inspects that flag.

Each missing element is now replaced by the mean of its valid nearest neighbors.

• A neighbor is valid if it is finite. Neighbors outside the array and non-finite elements not in where are left out, so the gradient of the filled elements is zero across those boundaries (a Neumann boundary).
• Non-finite elements not in where are left as they are.
• A missing element whose guess is not finite is valid only once its neighbors give it a value. As a result, guess=np.nan leaves elements cut off from every valid element as NaN. The default guess, the median of the known elements, leaves them at the median, and the docstring now says so.
• The elements are assumed to be equally spaced along both axes.
• a is copied after it is broadcast, and where is broadcast with np.broadcast_to, which returns a read-only view.
• Validity is tracked in a separate boolean array, because the kernel is compiled with fastmath, which assumes there are no NaNs or infinities.

The number of axes is now checked before any work is done, and the two error messages are fixed: one was missing an f-prefix, the other a space.

Tests

• test_fill_gauss_seidel_nan_neighbors: a harmonic function with zero gradient across a NaN region is recovered exactly, and the NaN region stays NaN.
• test_fill_gauss_seidel_infinite_neighbors: the same with ±inf, which is kept as it is.
• test_fill_gauss_seidel_edges: a strip on the edge of the array relaxes to the adjacent valid row or column, not toward the far edge. It is checked along both axes.
• test_fill_gauss_seidel_isotropic: on a 5 × 9 array, one missing element becomes the plain mean of its four neighbors.
• test_fill_gauss_seidel_no_valid_neighbors: an element with no valid neighbors is left at guess.
• test_fill_gauss_seidel_broadcast: with a 2D a and a 3D where, and the other way round, each slice equals a fill of that slice alone, with warnings as errors.
• test_fill_gauss_seidel_guess_nan: a guess array with one NaN, and guess=np.nan, both still recover a harmonic function.
• test_fill_gauss_seidel_cut_off: elements enclosed by unknown elements are left at the median, or as NaN with guess=np.nan.
• test_fill_gauss_seidel_axis, test_fill_method: the two errors.

All but test_fill_gauss_seidel_axis fail on main. The existing tests pass unchanged, including the exact recovery of a harmonic function inside a block.

Checked locally on the IRIS frames: none of the 36,945 filled pixels come out NaN, and the NaN outside the field is kept. 1000 iterations over 31 frames of 548 × 518 take 0.8 s.

This changes the filled values of elements within the relaxation length of an edge, and of elements in non-square arrays.

Regions of missing elements that touch an edge, or touch unknown elements, now converge more slowly than interior regions. At the default 100 iterations, a 15-column strip along the edge of a 51 × 51 array is still 0.33 from converged. The docstring now says these regions need more iterations. #72 tracks over-relaxation or a stopping tolerance, plus two other improvements from the review.

🤖 Generated with Claude Code

https://claude.ai/code/session_011VGPHLGJi8acbuLYSfBHTk

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 99.72%. Comparing base (91ef979) to head (8c6020c).

Additional details and impacted files

@@           Coverage Diff           @@
##             main      #71   +/-   ##
=======================================
  Coverage   99.71%   99.72%           
=======================================
  Files          65       65           
  Lines        4251     4346   +95     
=======================================
+ Hits         4239     4334   +95     
  Misses         12       12           

Flag	Coverage Δ
unittests	99.72% <100.00%> (+<0.01%)	⬆️

Flags with carried forward coverage won't be shown. Click here to find out more.

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.