v0.19: address PR review — restore in-place sequential build + plot_2d coverage on Spline/Slider/TT

- _build_fixed_grid: re-introduces the fast in-place np.ndindex loop for the
  n_workers=None/1 path, avoiding the unnecessary points-list materialisation
  that caused a ~2s regression for default (single-worker) users; parallel path
  unchanged.
- test_v019_build_diagnostics: adds test_plot_2d_surface_{spline,slider,tt},
  test_plot_2d_contour_{spline,slider,tt}, and test_n_workers_bool_rejected
  (7 new tests; total 990 → 997).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: 0xC000005

src/pychebyshev/barycentric.py

@@ -661,15 +661,25 @@ def _build_fixed_grid(self, verbose: bool | int = True) -> None:
         self._cached_error_estimate = None
 
         # Step 1: Evaluate at all node combinations
-        from pychebyshev._parallel import _evaluate_in_parallel
-        points = [
-            [self.nodes[d][idx[d]] for d in range(self.num_dimensions)]
-            for idx in np.ndindex(*self.n_nodes)
-        ]
-        flat = _evaluate_in_parallel(
-            self.function, points, self.additional_data, self.n_workers
-        )
-        self.tensor_values = flat.reshape(self.n_nodes)
+        if self.n_workers is None or self.n_workers == 1:
+            # Fast path: in-place fill (original behavior, no intermediate list)
+            self.tensor_values = np.zeros(self.n_nodes)
+            for idx in np.ndindex(*self.n_nodes):
+                point = [self.nodes[d][idx[d]] for d in range(self.num_dimensions)]
+                self.tensor_values[idx] = float(
+                    self.function(point, self.additional_data)
+                )
+        else:
+            # Parallel path: build points list, dispatch to pool, reshape
+            from pychebyshev._parallel import _evaluate_in_parallel
+            points = [
+                [self.nodes[d][idx[d]] for d in range(self.num_dimensions)]
+                for idx in np.ndindex(*self.n_nodes)
+            ]
+            flat = _evaluate_in_parallel(
+                self.function, points, self.additional_data, self.n_workers
+            )
+            self.tensor_values = flat.reshape(self.n_nodes)
         self.n_evaluations = total
 
         # Step 2: Pre-compute barycentric weights

tests/test_v019_build_diagnostics.py

@@ -93,6 +93,12 @@ def test_parallel_with_additional_data(self):
         # f(x, ad) = 7 * x; eval at 0.5 should be 3.5
         assert cheb.eval([0.5], [0]) == pytest.approx(3.5, abs=1e-10)
 
+    def test_n_workers_bool_rejected(self):
+        with pytest.raises(ValueError, match="n_workers"):
+            ChebyshevApproximation(
+                _t3_f_simple, 2, [[-1, 1], [-1, 1]], [4, 4], n_workers=True
+            )
+
 
 # ============================================================================
 # T4: Parallel build (Spline)
@@ -360,6 +366,36 @@ def test_plot_2d_surface_with_fixed(self, matplotlib_or_skip):
         ax = cheb.plot_2d_surface(fixed={2: 0.5}, n_points=10)
         assert ax is not None
 
+    def test_plot_2d_surface_spline(self, matplotlib_or_skip):
+        def f(x, _):
+            return abs(x[0]) + abs(x[1])
+        spl = ChebyshevSpline(
+            f, 2, [[-1, 1], [-1, 1]],
+            knots=[[0.0], [0.0]], n_nodes=[6, 6],
+        )
+        spl.build(verbose=False)
+        ax = spl.plot_2d_surface(n_points=15)
+        assert ax is not None
+
+    def test_plot_2d_surface_slider(self, matplotlib_or_skip):
+        def f(x, _):
+            return math.sin(x[0]) + math.cos(x[1])
+        slider = ChebyshevSlider(
+            f, 2, [[-1, 1], [-1, 1]], [6, 6],
+            partition=[[0], [1]], pivot_point=[0.0, 0.0],
+        )
+        slider.build(verbose=False)
+        ax = slider.plot_2d_surface(n_points=15)
+        assert ax is not None
+
+    def test_plot_2d_surface_tt(self, matplotlib_or_skip):
+        def f(x, _):
+            return x[0] * x[1]
+        tt = ChebyshevTT(f, 2, [[-1, 1], [-1, 1]], [6, 6])
+        tt.build(verbose=False)
+        ax = tt.plot_2d_surface(n_points=15)
+        assert ax is not None
+
 
 class TestPlot2DContour:
     @pytest.fixture
@@ -383,6 +419,36 @@ def test_plot_2d_contour_n_levels_kwarg(self, matplotlib_or_skip):
         ax = cheb.plot_2d_contour(n_points=15, n_levels=5)
         assert ax is not None
 
+    def test_plot_2d_contour_spline(self, matplotlib_or_skip):
+        def f(x, _):
+            return abs(x[0]) + abs(x[1])
+        spl = ChebyshevSpline(
+            f, 2, [[-1, 1], [-1, 1]],
+            knots=[[0.0], [0.0]], n_nodes=[6, 6],
+        )
+        spl.build(verbose=False)
+        ax = spl.plot_2d_contour(n_points=15, n_levels=10)
+        assert ax is not None
+
+    def test_plot_2d_contour_slider(self, matplotlib_or_skip):
+        def f(x, _):
+            return math.sin(x[0]) + math.cos(x[1])
+        slider = ChebyshevSlider(
+            f, 2, [[-1, 1], [-1, 1]], [6, 6],
+            partition=[[0], [1]], pivot_point=[0.0, 0.0],
+        )
+        slider.build(verbose=False)
+        ax = slider.plot_2d_contour(n_points=15, n_levels=10)
+        assert ax is not None
+
+    def test_plot_2d_contour_tt(self, matplotlib_or_skip):
+        def f(x, _):
+            return x[0] * x[1]
+        tt = ChebyshevTT(f, 2, [[-1, 1], [-1, 1]], [6, 6])
+        tt.build(verbose=False)
+        ax = tt.plot_2d_contour(n_points=15, n_levels=10)
+        assert ax is not None
+
 
 # ============================================================================
 # T8: Cross-feature tests