Fix BSplineApprox :Average knot distribution issue

Co-authored-by: SouthEndMusic <[email protected]>

Author: Copilot

src/interpolation_caches.jl

@@ -1098,15 +1098,33 @@ function BSplineApprox(
             k[i] = k[1] + (i - d - 1) // (h - d) * (k[end] - k[1])
         end
     elseif knotVecType == :Average
-        # NOTE: verify that average method can be applied when size of k is less than size of p
         # average spaced knot vector
-        idx = 1
-        if d + 2 <= h
+        # We need h - d - 1 internal knots distributed across the parameter domain
+        num_internal_knots = h - d - 1
+        if num_internal_knots > 0
+            # First internal knot uses the same formula as original
             k[d + 2] = 1 // d * ps[d]
-        end
-        for i in (d + 3):h
-            k[i] = 1 // d * (ps[idx + d] - ps[idx])
-            idx += 1
+            
+            # For remaining knots, distribute the sampling across the ps array
+            if num_internal_knots > 1
+                for i in 2:num_internal_knots
+                    knot_idx = d + 1 + i
+                    # In the original algorithm, idx goes from 1 to n-d-2
+                    # We want to distribute our sampling across this same range
+                    min_idx = 1
+                    max_idx = n - d - 2  # This gives us the same range as the original
+                    
+                    if max_idx >= min_idx
+                        # Linear interpolation to distribute sampling points
+                        sample_idx = min_idx + round(Int, (i - 2) * (max_idx - min_idx) / (num_internal_knots - 2))
+                        sample_idx = min(sample_idx, max_idx)
+                        
+                        # Use the difference formula: (ps[sample_idx + d] - ps[sample_idx]) / d
+                        ps_high_idx = sample_idx + d
+                        k[knot_idx] = 1 // d * (ps[ps_high_idx] - ps[sample_idx])
+                    end
+                end
+            end
         end
     end
     # control points

test/interpolation_tests.jl

@@ -914,6 +914,38 @@ end
             u_test = reduce(hcat, A.(t_test))
             @test isapprox(u_test, f_test, atol = 1e-2)
         end
+        
+        @testset ":Average knot distribution" begin
+            # Test for proper knot distribution across parameter domain (Issue #439)
+            x_test = 0:0.1:10
+            y_test = randn(101)
+            sp = BSplineApprox(y_test, x_test, 3, 20, :ArcLen, :Average)
+            
+            # Extract internal knots (skip the repeated boundary knots)
+            d = sp.d
+            h = sp.h
+            internal_knots = sp.k[(d+2):h]
+            
+            # Check that knots span a reasonable portion of the parameter domain
+            param_range = maximum(sp.p) - minimum(sp.p)
+            knot_coverage = maximum(internal_knots) - minimum(internal_knots)
+            coverage_ratio = knot_coverage / param_range
+            
+            # The coverage ratio should be at least 0.8 (80% of parameter domain)
+            # Before the fix, this was only ~0.136 (13.6%)
+            @test coverage_ratio >= 0.8
+            
+            # Test that the interpolation works correctly
+            @test sp(x_test[1]) ≈ y_test[1]
+            @test sp(x_test[end]) ≈ y_test[end]
+            
+            # Test interpolation at some intermediate points
+            test_points = [2.5, 5.0, 7.5]
+            for t in test_points
+                @test !isnan(sp(t))
+                @test isfinite(sp(t))
+            end
+        end
     end
 end