@iowarp/clio-coder 0.4.4 → 0.4.6

package/evals/fixtures/source-explanation.json

@@ -0,0 +1,74 @@
+{
+	"issue": 361,
+	"originalCommand": "/run coder Read only findiff/coefs.py, findiff/findiff.py, tests/test_accuracy.py and tests/test_coefs.py. Produce a detailed 1200-word source-cited explanation comparing uniform and nonuniform boundary stencils and their numerical accuracy tests. Do not edit any files.",
+	"task": "Read only findiff/coefs.py, findiff/findiff.py, tests/test_accuracy.py and tests/test_coefs.py. Produce a detailed 1200-word source-cited explanation comparing uniform and nonuniform boundary stencils and their numerical accuracy tests. Do not edit any files.",
+	"recoveryCommand": "/run scout Read only findiff/coefs.py, findiff/findiff.py, tests/test_accuracy.py and tests/test_coefs.py. Produce a detailed 1200-word source-cited explanation comparing uniform and nonuniform boundary stencils and their numerical accuracy tests. Do not edit any files.",
+	"referenceKind": "manually authored deterministic reference; not a model recovery",
+	"files": {
+		"findiff/coefs.py": "\"\"\"\nThis module determines finite difference coefficients for uniform and \nnon-uniform grids for any desired even accuracy order.\n\nMost important function:\n\ncoefficients(deriv, acc=None, offsets=None, symbolic=False)\n\nto calculate the finite difference coefficients for a given derivative\norder and given accuracy order to given offsets.\n\"\"\"\n\nimport math\nfrom itertools import combinations\n\nimport numpy as np\nimport sympy\nfrom sympy import Matrix, Rational\n\n\ndef coefficients(deriv, acc=None, offsets=None, symbolic=False, analytic_inv=False):\n    \"\"\"\n    Calculates the finite difference coefficients for given derivative order and accuracy order.\n\n    If acc is given, the coefficients are calculated for central, forward and backward\n    schemes resulting in the specified accuracy order.\n\n    If offsets are given, the coefficients are calculated for the offsets as specified\n    and the resulting accuracy order is computed.\n\n    *Either* acc *or* offsets must be given.\n\n    Assumes that the underlying grid is uniform. This function is available at the `findiff`\n    package level.\n\n    :param deriv: The derivative order.\n    :type deriv: int > 0\n\n    :param acc: The accuracy order.\n    :type acc:  even int > 0:\n\n    :param offsets: The offsets for which to calculate the coefficients.\n    :type offsets: list of ints\n\n    :raises ValueError: if invalid arguments are given\n\n    :return: dict with the finite difference coefficients and corresponding offsets\n    \"\"\"\n\n    _validate_deriv(deriv)\n\n    if acc is not None and offsets:\n        raise ValueError(\"acc and offsets cannot both be given\")\n\n    if offsets:\n        if deriv >= len(offsets):\n            raise ValueError(\n                f\"can not compute derivative of order {deriv} using {len(offsets)} offsets.\"\n            )\n        return calc_coefs(deriv, offsets, symbolic, analytic_inv)\n\n    if acc is None:\n        raise ValueError(\"either acc or offsets has to be given\")\n\n    _validate_acc(acc)\n    ret = {}\n    num_central_coefs = 2 * math.floor((deriv + 1) / 2) - 1 + acc\n    num_side_coefs = num_central_coefs // 2\n\n    # Determine central coefficients\n    offsets = list(range(-num_side_coefs, num_side_coefs + 1))\n    ret[\"center\"] = calc_coefs(deriv, offsets, symbolic, analytic_inv)\n\n    # Determine forward coefficients\n\n    if deriv % 2 == 0:\n        num_coef = num_central_coefs + 1\n    else:\n        num_coef = num_central_coefs\n\n    offsets = list(range(num_coef))\n    ret[\"forward\"] = calc_coefs(deriv, offsets, symbolic, analytic_inv)\n\n    # Determine backward coefficients\n\n    offsets = list(range(-num_coef + 1, 1))\n    ret[\"backward\"] = calc_coefs(deriv, offsets, symbolic, analytic_inv)\n\n    return ret\n\n\ndef calc_coefs(deriv, offsets, symbolic=False, analytic_inv=False, alphas=None):\n    \"\"\"The working horse for calculating finite difference coefficients on equidistant grids.\n\n    Args:\n        deriv: int\n            The order of the derivative.\n        offsets: list of ints\n            Which neighboring points to use.\n        symbolic: bool\n            Compute symbolically or numerically.\n        analytic_inv: bool\n            Use analytic inverse for Vandermonde matrix or numerical.\n        alphas: dict\n            Specifies the implicit scheme to use (the left hand side of the\n            system equation in `CompactScheme`). If None, normal (explicit)\n            finite differences will be used.\n\n    Returns:\n        A dict describing the finite difference scheme.\n    \"\"\"\n\n    if alphas and analytic_inv:\n        raise NotImplementedError(\n            \"compact finite differences for analytic inversion not yet implemented\"\n        )\n    if not alphas:\n        alphas = {0: 1}\n\n    if analytic_inv:\n        if symbolic:\n            solver = SymbolicAnalyticSolver()\n        else:\n            solver = AnalyticSolver()\n    else:\n        if symbolic:\n            solver = SymbolicSolver()\n        else:\n            solver = Solver()\n\n    calculator = CoefficientCalculator(deriv, offsets, alphas, solver)\n\n    calculator.solve()\n    coefs = list(calculator.sol.values())\n\n    if not symbolic:\n        offsets = np.array(offsets)\n\n    return {\"coefficients\": coefs, \"offsets\": offsets, \"accuracy\": calculator.acc}\n\n\ndef coefficients_non_uni(deriv, acc, coords, idx):\n    \"\"\"\n    Calculates the finite difference coefficients for given derivative order and accuracy order.\n    Assumes that the underlying grid is non-uniform.\n\n    :param deriv: int > 0: The derivative order.\n\n    :param acc:  even int > 0: The accuracy order.\n\n    :param coords:  1D numpy.ndarray: the coordinates of the axis for the partial derivative\n\n    :param idx:  int: index of the grid position where to calculate the coefficients\n\n    :return: dict with the finite difference coefficients and corresponding offsets\n    \"\"\"\n\n    _validate_deriv(deriv)\n    _validate_acc(acc)\n\n    num_central = 2 * math.floor((deriv + 1) / 2) - 1 + acc\n    num_side = num_central // 2\n\n    if deriv % 2 == 0:\n        num_coef = num_central + 1\n    else:\n        num_coef = num_central\n\n    if idx < num_side:\n        matrix = _build_matrix_non_uniform(0, num_coef - 1, coords, idx)\n\n        offsets = list(range(num_coef))\n        rhs = _build_rhs(offsets, deriv, alphas={0: 1})\n\n        ret = {\n            \"coefficients\": np.linalg.solve(matrix, rhs),\n            \"offsets\": np.array(offsets),\n        }\n\n    elif idx >= len(coords) - num_side:\n        matrix = _build_matrix_non_uniform(num_coef - 1, 0, coords, idx)\n\n        offsets = list(range(-num_coef + 1, 1))\n        rhs = _build_rhs(offsets, deriv, alphas={0: 1})\n\n        ret = {\n            \"coefficients\": np.linalg.solve(matrix, rhs),\n            \"offsets\": np.array(offsets),\n        }\n\n    else:\n        matrix = _build_matrix_non_uniform(num_side, num_side, coords, idx)\n\n        offsets = list(range(-num_side, num_side + 1))\n        rhs = _build_rhs(offsets, deriv, alphas={0: 1})\n\n        ret = {\n            \"coefficients\": np.linalg.solve(matrix, rhs),\n            \"offsets\": np.array([p for p in range(-num_side, num_side + 1)]),\n        }\n\n    return ret\n\n\ndef calc_coefs_non_uni_batched(deriv, acc, coords):\n    \"\"\"Compute FD coefficients for all points on a non-uniform grid using batched linear algebra.\n\n    Instead of solving one linear system per grid point, this groups points by stencil type\n    (forward/central/backward) and solves all systems in each group with a single batched\n    ``np.linalg.solve`` call.\n\n    :param deriv: int > 0: The derivative order.\n    :param acc:  even int > 0: The accuracy order.\n    :param coords: 1D numpy.ndarray: the coordinates of the axis.\n    :return: dict with 'forward', 'backward', 'center' keys plus 'num_bndry'.\n             Each scheme dict contains 'coefficients' (2D array) and 'offsets' (1D array).\n    \"\"\"\n    _validate_deriv(deriv)\n    _validate_acc(acc)\n\n    num_central = 2 * math.floor((deriv + 1) / 2) - 1 + acc\n    num_side = num_central // 2\n    num_coef = num_central + 1 if deriv % 2 == 0 else num_central\n\n    N = len(coords)\n\n    fwd_indices = np.arange(min(num_side, N))\n    fwd_weights = _solve_non_uni_batched(coords, fwd_indices, 0, num_coef - 1, deriv)\n\n    bwd_start = max(num_side, N - num_side)\n    bwd_indices = np.arange(bwd_start, N)\n    bwd_weights = _solve_non_uni_batched(coords, bwd_indices, num_coef - 1, 0, deriv)\n\n    ctr_indices = np.arange(num_side, max(num_side, N - num_side))\n    ctr_weights = _solve_non_uni_batched(coords, ctr_indices, num_side, num_side, deriv)\n\n    return {\n        \"forward\": {\n            \"coefficients\": fwd_weights,\n            \"offsets\": np.arange(num_coef),\n        },\n        \"backward\": {\n            \"coefficients\": bwd_weights,\n            \"offsets\": np.arange(-num_coef + 1, 1),\n        },\n        \"center\": {\n            \"coefficients\": ctr_weights,\n            \"offsets\": np.arange(-num_side, num_side + 1),\n        },\n        \"num_bndry\": num_side,\n    }\n\n\ndef _solve_non_uni_batched(coords, indices, p, q, deriv):\n    \"\"\"Solve for FD coefficients for multiple points with the same stencil structure.\n\n    Builds all Vandermonde-like matrices at once and calls ``np.linalg.solve``\n    with a 3-D array of matrices and a 2-D array of right-hand sides.\n\n    :param coords: 1D coordinate array.\n    :param indices: 1D integer array of grid-point indices to compute for.\n    :param p: number of stencil points to the left.\n    :param q: number of stencil points to the right.\n    :param deriv: derivative order.\n    :return: 2D array of shape (len(indices), stencil_size).\n    \"\"\"\n    n = len(indices)\n    stencil_size = p + q + 1\n\n    if n == 0:\n        return np.empty((0, stencil_size))\n\n    j_offsets = np.arange(-p, q + 1)\n\n    # Coordinate differences: shape (n, stencil_size)\n    idx_matrix = indices[:, None] + j_offsets[None, :]\n    coord_diffs = coords[idx_matrix] - coords[indices, None]\n\n    # Build Vandermonde-like matrices: shape (n, stencil_size, stencil_size)\n    # matrices[i, row, col] = coord_diffs[i, col] ** row\n    powers = np.arange(stencil_size)\n    matrices = coord_diffs[:, None, :] ** powers[None, :, None]\n\n    # Build RHS: only position `deriv` is non-zero (= deriv!)\n    rhs = _build_rhs(list(j_offsets), deriv, alphas={0: 1})\n    # np.linalg.solve with 3D A expects b to have shape (..., m, k), not (..., m)\n    rhs_col = rhs[:, np.newaxis]  # (stencil_size, 1)\n    rhs_batch = np.broadcast_to(rhs_col, (n, stencil_size, 1)).copy()\n\n    return np.linalg.solve(matrices, rhs_batch)[:, :, 0]\n\n\ndef vandermonde_matrix(values):\n    A = [([1 for _ in values])]\n    for i in range(1, len(values)):\n        A.append([j**i for j in values])\n    return A\n\n\ndef _build_rhs(\n    offsets,\n    deriv,\n    alphas,\n    symbolic=False,\n):\n    \"\"\"The right hand side of the equation system matrix\"\"\"\n\n    if symbolic:\n        frac = lambda num, denom: sympy.Rational(num, denom)  # noqa: E731\n    else:\n        frac = lambda num, denom: num / denom  # noqa: E731\n\n    b = [0 for _ in offsets]\n    for j in range(deriv, len(offsets)):\n        b[j] = frac(math.factorial(j), math.factorial(j - deriv)) * sum(\n            r ** (j - deriv) * alphas[r] for r in alphas\n        )\n\n    if symbolic:\n        return sympy.Matrix(b)\n    else:\n        return np.array(b, dtype=\"float\")\n\n\ndef _build_matrix_non_uniform(p, q, coords, k):\n    \"\"\"Constructs the equation matrix for the finite difference coefficients of non-uniform grids at location k\"\"\"\n    A = [[1] * (p + q + 1)]\n    for i in range(1, p + q + 1):\n        line = [(coords[k + j] - coords[k]) ** i for j in range(-p, q + 1)]\n        A.append(line)\n    return np.array(A, dtype=\"float\")\n\n\ndef _validate_acc(acc):\n    if acc % 2 == 1 or acc <= 0:\n        raise ValueError(\"Accuracy order acc must be positive EVEN integer\")\n\n\ndef _validate_deriv(deriv):\n    if deriv < 0:\n        raise ValueError(\"Derive degree must be positive integer\")\n\n\nclass InverseVandermondeColumn:\n\n    def __init__(self, symbolic=False):\n\n        self.symbolic = symbolic\n        if symbolic:\n            self.take = lambda arr, ids: [arr[idx] for idx in ids]  # noqa: E731\n            self.prod = sympy.prod\n            self.minus = lambda x, arr: [x - val for val in arr]  # noqa: E731\n            self.frac = lambda num, denom: sympy.Rational(num, denom)  # noqa: E731\n        else:\n            self.take = lambda arr, ids: arr[ids]  # noqa: E731\n            self.prod = np.prod\n            self.minus = lambda x, arr: x - arr  # noqa: E731\n            self.frac = lambda num, denom: num / denom  # noqa: E731\n\n    def compute(self, column, offsets):\n        \"\"\"Computes a given column of the inverse of the Vandermonde matrix that\n        belongs to given offsets, multiplied by the factorial of the column index.\n\n        This code implements the first equation for b_kj under \"Proof 1\" in\n        https://proofwiki.org/wiki/Inverse_of_Vandermonde_Matrix\n        Note that the result has to be transposed because the original Vandermonde\n        matrix is defined transposed as compared to _build_matrix.\n\n        Also, we have 0-based indexing here, whereas the formulae in the wiki entry\n        are 1-based.\n        \"\"\"\n\n        if not self.symbolic:\n            offsets = np.array(offsets)\n\n        n = len(offsets)\n        k = column + 1\n        inv_vandermonde_column = []\n        if k == n:\n            # If the number of offsets matches the derivative order + 1, there is a special\n            # case, compare the lower part of the bracket in the equation in proofwiki.\n            for j in range(n):\n                denom = self.prod(self.minus(offsets[j], offsets[:j])) * self.prod(\n                    self.minus(offsets[j], offsets[j + 1 :])\n                )\n                inv_vandermonde_column.append(self.frac(1, denom))\n        else:\n            # This is the \"regular\" part of the bracket. First compute the sign that is the\n            # same for all entries in the column that we compute\n            sign = (-1) ** (n - k)\n            for j in range(n):\n                # All indices except j\n                range_wo_j = list(range(j)) + list(range(j + 1, n))\n                # Get all combinations of n-k indices that are ascending and do not contain j\n                index_set = combinations(range_wo_j, r=n - k)\n                enumerator = sum(\n                    self.prod(self.take(offsets, list(m))) for m in index_set\n                )\n                denominator = self.prod(\n                    self.minus(offsets[j], self.take(offsets, range_wo_j))\n                )\n                inv_vandermonde_column.append(sign * self.frac(enumerator, denominator))\n\n        fact = math.factorial(column)\n\n        result = [val * fact for val in inv_vandermonde_column]\n        if self.symbolic:\n            return result\n\n        return np.array(result)\n\n\nclass CoefficientCalculator:\n\n    def __init__(self, deriv, offsets, alphas, solver):\n        self.deriv = deriv\n        self.offsets = offsets\n        self.alphas = alphas\n        self.solver = solver\n        self.sol = None\n        self.acc = None\n\n    def solve(self):\n        coefs = self.solver.solve(self.deriv, self.offsets, self.alphas)\n        self.sol = {off: coef for off, coef in zip(self.offsets, coefs)}\n        self.acc = self.solver.acc\n        return self.sol\n\n\nclass Solver:\n\n    atol = 1.0e-6\n\n    def __init__(self, wrapper=None):\n        self.wrapper = wrapper or NumericMatrixWrapper()\n        self.acc = None\n\n    def solve(self, deriv, offsets, alphas):\n        sol = np.linalg.solve(\n            self.lhs(deriv, offsets), self.rhs(deriv, offsets, alphas)\n        )\n        self.acc = self.calc_accuracy(deriv, offsets, sol, alphas)\n        return sol\n\n    def rhs(self, deriv, offsets, alphas):\n\n        b = [0 for _ in offsets]\n        for j in range(deriv, len(offsets)):\n            b[j] = self.wrapper.frac(\n                math.factorial(j), math.factorial(j - deriv)\n            ) * sum(r ** (j - deriv) * alphas[r] for r in alphas)\n\n        return self.wrapper(b)\n\n    def lhs(self, deriv, offsets):\n        return self.wrapper(vandermonde_matrix(offsets))\n\n    def calc_accuracy(self, deriv, offsets, coefs, alphas):\n        n_plus_s = deriv + 1\n        max_n = 999\n        break_condition = lambda b: abs(b) > self.atol  # noqa: E731\n\n        while True:\n            b = 0\n            fac = 1 / math.factorial(n_plus_s)\n            for o, coef in zip(offsets, coefs):\n                b += coef * o**n_plus_s * fac\n\n            s = n_plus_s - deriv\n            fac = 1 / math.factorial(s)\n            for o, alpha in alphas.items():\n                b -= alpha * fac * o**s\n\n            if break_condition(b):\n                break\n\n            n_plus_s += 1\n            if n_plus_s > max_n:\n                raise Exception(\"Cannot compute accuracy.\")\n\n        return round(n_plus_s - deriv)\n\n\nclass SymbolicSolver(Solver):\n\n    atol = 0\n\n    def __init__(self):\n        super().__init__(SymbolicMatrixWrapper())\n\n    def solve(self, deriv, offsets, alphas):\n        sol = sympy.linsolve(\n            (self.lhs(deriv, offsets), self.rhs(deriv, offsets, alphas))\n        )\n        sol = list(tuple(sol)[0])\n        self.acc = self.calc_accuracy(deriv, offsets, sol, alphas)\n        return sol\n\n\nclass AnalyticSolver(Solver):\n    symbolic = False\n\n    def solve(self, deriv, offsets, alphas):\n        sol = InverseVandermondeColumn(symbolic=self.symbolic).compute(deriv, offsets)\n        self.acc = self.calc_accuracy(deriv, offsets, sol, alphas)\n        return sol\n\n\nclass SymbolicAnalyticSolver(AnalyticSolver):\n    symbolic = True\n    atol = 0\n\n\nclass SymbolicMatrixWrapper:\n    def __call__(self, arr):\n        return Matrix(arr)\n\n    def frac(self, num, denom):\n        return Rational(num, denom)\n\n\nclass NumericMatrixWrapper:\n    def __call__(self, arr):\n        return np.array(arr, dtype=np.float64)\n\n    def frac(self, num, denom):\n        return num / denom\n",
+		"findiff/findiff.py": "import numpy as np\nfrom scipy import sparse\n\nfrom findiff.backend import add_at, get_namespace\nfrom findiff.coefs import coefficients, calc_coefs_non_uni_batched\nfrom findiff.compact import _CompactDiffUniformPeriodic, _CompactDiffUniformNonPeriodic\nfrom findiff.grids import EquidistantAxis, GridAxis, NonEquidistantAxis\nfrom findiff.utils import (\n    get_list_of_multiindex_tuples,\n    get_long_indices_for_all_grid_points_as_1d_array,\n    get_long_indices_for_all_grid_points_as_ndarray,\n    to_long_index,\n)\n\n\ndef build_differentiator(order: int, axis: GridAxis, acc, scheme=None):\n    if scheme:\n        if isinstance(axis, EquidistantAxis):\n            if axis.periodic:\n                return _CompactDiffUniformPeriodic(\n                    axis.dim, order, axis.spacing, scheme\n                )\n            else:\n                return _CompactDiffUniformNonPeriodic(\n                    axis.dim, order, axis.spacing, scheme\n                )\n        raise NotImplementedError(\"This is not yet implemented for compact schemes.\")\n\n    if isinstance(axis, EquidistantAxis):\n        if not axis.periodic:\n            return _FinDiffUniform(axis.dim, order, axis.spacing, acc)\n        else:\n            return _FinDiffUniformPeriodic(axis.dim, order, axis.spacing, acc)\n    elif isinstance(axis, NonEquidistantAxis):\n        if not axis.periodic:\n            return _FinDiffNonUniform(axis.dim, order, axis.coords, acc)\n        else:\n            raise NotImplementedError(\"Periodic nonuniform axes not yet implemented\")\n    else:\n        raise TypeError(\"Unknown axis type.\")\n\n\nclass _FinDiffBase:\n\n    def __init__(self, axis, order):\n        self.axis = axis\n        self.order = order\n\n    def guard_valid_target(self, f):\n        try:\n            f.shape[self.axis]\n        except AttributeError as err:\n            raise ValueError(\n                \"Diff objects can only be applied to arrays or evaluated(!) functions returning arrays\"\n            ) from err\n\n        if np.issubdtype(f.dtype, np.integer):\n            f = f.astype(np.float64)\n        return f\n\n    def apply_to_array(self, yd, y, weights, off_slices, ref_slice, dim):\n        \"\"\"Applies the finite differences only to slices along a given axis.\n\n        Returns the updated output array (required for immutable backends\n        like JAX).\n        \"\"\"\n\n        ndims = len(y.shape)\n\n        all = slice(None, None, 1)\n\n        ref_multi_slice = [all] * ndims\n        ref_multi_slice[dim] = ref_slice\n\n        for w, s in zip(weights, off_slices):\n            off_multi_slice = [all] * ndims\n            off_multi_slice[dim] = s\n            if abs(1 - w) < 1.0e-14:\n                yd = add_at(yd, tuple(ref_multi_slice), y[tuple(off_multi_slice)])\n            else:\n                yd = add_at(yd, tuple(ref_multi_slice), w * y[tuple(off_multi_slice)])\n        return yd\n\n    def shift_slice(self, sl, off, max_index):\n\n        if sl.start + off < 0 or sl.stop + off > max_index:\n            raise IndexError(\"Shift slice out of bounds\")\n\n        return slice(sl.start + off, sl.stop + off, sl.step)\n\n    def matrix(self, shape):\n        siz = np.prod(shape)\n        mat = sparse.lil_matrix((siz, siz))\n        self.write_matrix_entries(mat, shape)\n        return sparse.csr_matrix(mat)\n\n    def write_matrix_entries(self, mat, shape):\n        raise NotImplementedError\n\n\nclass _FinDiffUniform(_FinDiffBase):\n\n    def __init__(self, axis, order, spacing, acc):\n        super().__init__(axis, order)\n        self.spacing = spacing\n        self.acc = acc\n        coef_schemes = coefficients(self.order, acc)\n        self.forward = coef_schemes[\"forward\"]\n        self.backward = coef_schemes[\"backward\"]\n        self.center = coef_schemes[\"center\"]\n\n    def __call__(self, f):\n        f = self.guard_valid_target(f)\n        xp = get_namespace(f)\n\n        npts = f.shape[self.axis]\n        fd = xp.zeros_like(f)\n        num_bndry_points = len(self.center[\"coefficients\"]) // 2\n\n        fd = self._apply_central_coefs(f, fd, npts, num_bndry_points)\n\n        fd = self._apply_forward_coefs(f, fd, npts, num_bndry_points)\n\n        fd = self._apply_backward_coefs(f, fd, npts, num_bndry_points)\n\n        h_inv = 1.0 / self.spacing**self.order\n        return fd * h_inv\n\n    def _apply_backward_coefs(self, f, fd, npts, num_bndry_points):\n        weights = self.backward[\"coefficients\"]\n        offsets = self.backward[\"offsets\"]\n        ref_slice = slice(npts - num_bndry_points, npts, 1)\n        off_slices = [\n            self.shift_slice(ref_slice, offsets[k], npts) for k in range(len(offsets))\n        ]\n        return self.apply_to_array(fd, f, weights, off_slices, ref_slice, self.axis)\n\n    def _apply_forward_coefs(self, f, fd, npts, num_bndry_points):\n        weights = self.forward[\"coefficients\"]\n        offsets = self.forward[\"offsets\"]\n        ref_slice = slice(0, num_bndry_points, 1)\n        off_slices = [\n            self.shift_slice(ref_slice, offsets[k], npts) for k in range(len(offsets))\n        ]\n        return self.apply_to_array(fd, f, weights, off_slices, ref_slice, self.axis)\n\n    def _apply_central_coefs(self, f, fd, npts, num_bndry_points):\n        weights = self.center[\"coefficients\"]\n        offsets = self.center[\"offsets\"]\n        ref_slice = slice(num_bndry_points, npts - num_bndry_points, 1)\n        off_slices = [\n            self.shift_slice(ref_slice, offsets[k], npts) for k in range(len(offsets))\n        ]\n        return self.apply_to_array(fd, f, weights, off_slices, ref_slice, self.axis)\n\n    def write_matrix_entries(self, mat, shape):\n        long_indices_nd = get_long_indices_for_all_grid_points_as_ndarray(shape)\n        for scheme in [\"center\", \"forward\", \"backward\"]:\n\n            offsets_long = self._convert_1D_offsets_to_long_indices(\n                self.axis, getattr(self, scheme)[\"offsets\"], shape\n            )\n\n            multi_slice = self._get_multislice_for_scheme(self.axis, scheme, shape)\n            Is = long_indices_nd[tuple(multi_slice)].reshape(-1)\n\n            coefs = getattr(self, scheme)[\"coefficients\"]\n            for o, c in zip(offsets_long, coefs):\n                v = c / self.spacing**self.order\n                mat[Is, Is + o] = v\n\n    def _get_multislice_for_scheme(self, axis, scheme, shape):\n        ndims = len(shape)\n        multi_slice = [slice(None, None)] * ndims\n        nside = len(self.center[\"coefficients\"]) // 2\n        if scheme == \"center\":\n            multi_slice[axis] = slice(nside, -nside)\n        elif scheme == \"forward\":\n            multi_slice[axis] = slice(0, nside)\n        else:\n            multi_slice[axis] = slice(-nside, None)\n        return multi_slice\n\n    def _convert_1D_offsets_to_long_indices(self, axis, offsets_1d, shape):\n        ndims = len(shape)\n        offsets_long = []\n        for o_1d in offsets_1d:\n            o_nd = np.zeros(ndims, dtype=int)\n            o_nd[axis] = o_1d\n            o_long = to_long_index(o_nd, shape)\n            offsets_long.append(o_long)\n        return offsets_long\n\n\nclass _FinDiffUniformPeriodic(_FinDiffBase):\n\n    def __init__(self, axis, order, spacing, acc):\n        super().__init__(axis, order)\n        self.spacing = spacing\n        self.acc = acc\n        self.coefs = coefficients(self.order, acc)[\"center\"]\n\n    def __call__(self, f):\n        f = self.guard_valid_target(f)\n        xp = get_namespace(f)\n\n        fd = xp.zeros_like(f)\n        for off, coef in zip(self.coefs[\"offsets\"], self.coefs[\"coefficients\"]):\n            fd = fd + coef * xp.roll(f, -off, axis=self.axis)\n        h_inv = 1.0 / self.spacing**self.order\n        return fd * h_inv\n\n    def write_matrix_entries(self, mat, shape):\n        Is = get_long_indices_for_all_grid_points_as_1d_array(shape)\n        h_inv = 1 / self.spacing**self.order\n        for o, c in zip(self.coefs[\"offsets\"], self.coefs[\"coefficients\"]):\n            Is_off = self._get_offset_indices_long(o, shape)\n            mat[Is, Is_off] = c * h_inv\n\n    def _get_offset_indices_long(self, o, shape):\n        ndims = len(shape)\n        idxs_short = [np.arange(n) for n in shape]\n        idxs_short[self.axis] = np.roll(np.arange(shape[self.axis]), -o)\n        grid = np.meshgrid(*idxs_short, indexing=\"ij\")\n        index_tuples = np.stack(grid, axis=-1).reshape(-1, ndims)\n        Is_off = np.ravel_multi_index(index_tuples.T, shape)\n        return Is_off\n\n\nclass _FinDiffNonUniform(_FinDiffBase):\n    def __init__(self, axis, order, coords, acc):\n        super().__init__(axis, order)\n        self.coords = coords\n        self.acc = acc\n\n        schemes = calc_coefs_non_uni_batched(order, acc, coords)\n        self.num_bndry = schemes[\"num_bndry\"]\n        self.forward = schemes[\"forward\"]\n        self.backward = schemes[\"backward\"]\n        self.center = schemes[\"center\"]\n\n    def __call__(self, y):\n        \"\"\"The core function to take a partial derivative on a non-uniform grid\"\"\"\n        y = self.guard_valid_target(y)\n        xp = get_namespace(y)\n\n        dim = self.axis\n        N = len(self.coords)\n        yd = xp.zeros_like(y)\n        ndims = len(y.shape)\n\n        yd = self._apply_nonuni_weights(\n            yd, y, dim, ndims,\n            self.center[\"coefficients\"], self.center[\"offsets\"],\n            slice(self.num_bndry, N - self.num_bndry),\n        )\n\n        yd = self._apply_nonuni_weights(\n            yd, y, dim, ndims,\n            self.forward[\"coefficients\"], self.forward[\"offsets\"],\n            slice(0, self.num_bndry),\n        )\n\n        yd = self._apply_nonuni_weights(\n            yd, y, dim, ndims,\n            self.backward[\"coefficients\"], self.backward[\"offsets\"],\n            slice(N - self.num_bndry, N),\n        )\n\n        return yd\n\n    def _apply_nonuni_weights(self, yd, y, dim, ndims, weights, offsets, ref_slice):\n        \"\"\"Apply per-point weights using vectorized slice operations.\n\n        Returns the updated output array (required for immutable backends\n        like JAX).\n        \"\"\"\n        n_pts = ref_slice.stop - ref_slice.start\n        if n_pts == 0:\n            return yd\n\n        ref_multi = [slice(None)] * ndims\n        ref_multi[dim] = ref_slice\n\n        for j_idx, off in enumerate(offsets):\n            off_slice = slice(ref_slice.start + int(off), ref_slice.stop + int(off))\n            off_multi = [slice(None)] * ndims\n            off_multi[dim] = off_slice\n\n            w = weights[:, j_idx]\n            w_shape = [1] * ndims\n            w_shape[dim] = n_pts\n            yd = add_at(yd, tuple(ref_multi), w.reshape(w_shape) * y[tuple(off_multi)])\n        return yd\n\n    def write_matrix_entries(self, mat, shape):\n        long_indices_nd = get_long_indices_for_all_grid_points_as_ndarray(shape)\n        N = len(self.coords)\n        ndims = len(shape)\n\n        schemes = [\n            (self.forward, slice(0, self.num_bndry)),\n            (self.center, slice(self.num_bndry, N - self.num_bndry)),\n            (self.backward, slice(N - self.num_bndry, N)),\n        ]\n\n        for scheme, axis_slice in schemes:\n            n_axis_pts = axis_slice.stop - axis_slice.start\n            if n_axis_pts == 0:\n                continue\n\n            src_multi = [slice(None)] * ndims\n            src_multi[self.axis] = axis_slice\n            Is = long_indices_nd[tuple(src_multi)].reshape(-1)\n\n            selected_shape = list(shape)\n            selected_shape[self.axis] = n_axis_pts\n\n            for j_idx, o in enumerate(scheme[\"offsets\"]):\n                tgt_multi = [slice(None)] * ndims\n                tgt_multi[self.axis] = slice(\n                    axis_slice.start + int(o), axis_slice.stop + int(o)\n                )\n                Js = long_indices_nd[tuple(tgt_multi)].reshape(-1)\n\n                w = scheme[\"coefficients\"][:, j_idx]\n                w_shape = [1] * ndims\n                w_shape[self.axis] = n_axis_pts\n                w_broadcast = np.broadcast_to(\n                    w.reshape(w_shape), selected_shape\n                ).reshape(-1)\n\n                mat[Is, Js] = w_broadcast\n",
+		"tests/test_accuracy.py": "import numpy as np\n\nfrom findiff import Diff\n\n\ndef test_iterative_accuracy():\n\n    ns = np.logspace(2, 3, 10)\n\n    def compute_errs(acc, plot=False):\n        # import matplotlib.pyplot as plt\n\n        errs_a = []\n        errs_b = []\n        errs_c = []\n\n        for n in ns:\n            x = np.linspace(0.1, 1, int(n))\n            dx = x[1] - x[0]\n\n            D = Diff(0, dx, acc=acc)\n            D2 = D**2\n            DD = D * D\n\n            f = x**8\n\n            exact = 8 * 7 * x**6\n            actual_a = D2(f)\n            actual_b = D(D(f))\n            actual_c = DD(f)\n\n            err_a = np.max(abs((actual_a - exact) / exact))\n            err_b = np.max(abs((actual_b - exact) / exact))\n            err_c = np.max(abs((actual_c - exact) / exact))\n            errs_a.append(err_a)\n            errs_b.append(err_b)\n            errs_c.append(err_c)\n\n        # if plot:\n        #     plt.loglog(ns, errs_a, \"-x\", label=\"D^2f\")\n        #     plt.loglog(ns, errs_b, \"-\", label=\"D(D(f))\")\n        #     plt.loglog(ns, errs_c, \"-\", label=\"D*D*f\")\n        #     plt.grid()\n        #     plt.show()\n\n        slope_a = abs(loglog_slope(ns, errs_a))\n        slope_b = abs(loglog_slope(ns, errs_b))\n        slope_c = abs(loglog_slope(ns, errs_c))\n        return slope_a, slope_b, slope_c\n\n    slope_a, slope_b, slope_c = compute_errs(2, plot=False)\n\n    assert abs(slope_a - 2) < 0.2\n    # applying operators iteratively should reduce the order by one at a time:\n    assert abs(slope_b - 1) < 0.2\n    assert abs(slope_c - 2) < 0.2\n\n    slope_a, slope_b, slope_c = compute_errs(4, plot=False)\n    assert abs(slope_a - 4) < 0.2\n    # applying operators iteratively should reduce the order by one at a time:\n    assert abs(slope_b - 3) < 0.4\n    assert abs(slope_c - 4) < 0.2\n\n\ndef loglog_slope(x, y):\n    slope, intercept = np.polyfit(np.log(x), np.log(y), 1)\n    return slope\n",
+		"tests/test_coefs.py": "import numpy as np\nimport pytest\nfrom sympy import Rational\n\nfrom findiff import coefficients\nfrom findiff.coefs import calc_coefs, vandermonde_matrix\nfrom findiff.coefs import coefficients_non_uni\n\n\n@pytest.mark.parametrize(\"analytic_inv\", [True, False])\ndef test_order2_acc2(analytic_inv):\n\n    c = coefficients(deriv=2, acc=2, analytic_inv=analytic_inv)\n\n    coefs = c[\"center\"][\"coefficients\"]\n    np.testing.assert_array_almost_equal(np.array([1.0, -2.0, 1.0]), coefs)\n    offs = c[\"center\"][\"offsets\"]\n    np.testing.assert_array_almost_equal(np.array([-1, 0, 1]), offs)\n\n    coefs = c[\"forward\"][\"coefficients\"]\n    np.testing.assert_array_almost_equal(np.array([2, -5, 4, -1]), coefs)\n    offs = c[\"forward\"][\"offsets\"]\n    np.testing.assert_array_almost_equal(np.array([0, 1, 2, 3]), offs)\n\n    coefs = c[\"backward\"][\"coefficients\"]\n    np.testing.assert_array_almost_equal(np.array(([2, -5, 4, -1])[::-1]), coefs)\n    offs = c[\"backward\"][\"offsets\"]\n    np.testing.assert_array_almost_equal(np.array([-3, -2, -1, 0]), offs)\n\n\n@pytest.mark.parametrize(\"analytic_inv\", [True, False])\ndef test_order1_acc2(analytic_inv):\n\n    c = coefficients(deriv=1, acc=2, analytic_inv=analytic_inv)\n\n    coefs = c[\"center\"][\"coefficients\"]\n    np.testing.assert_array_almost_equal(np.array([-0.5, 0, 0.5]), coefs)\n    offs = c[\"center\"][\"offsets\"]\n    np.testing.assert_array_almost_equal(np.array([-1, 0, 1]), offs)\n\n    coefs = c[\"forward\"][\"coefficients\"]\n    np.testing.assert_array_almost_equal(np.array([-1.5, 2, -0.5]), coefs)\n    offs = c[\"forward\"][\"offsets\"]\n    np.testing.assert_array_almost_equal(np.array([0, 1, 2]), offs)\n\n    coefs = c[\"backward\"][\"coefficients\"]\n    np.testing.assert_array_almost_equal(-np.array([-1.5, 2, -0.5])[::-1], coefs)\n    offs = c[\"backward\"][\"offsets\"]\n    np.testing.assert_array_almost_equal(np.array([-2, -1, 0]), offs)\n\n\n@pytest.mark.parametrize(\"analytic_inv\", [True, False])\ndef test_order1_acc4(analytic_inv):\n    c = coefficients(deriv=1, acc=4, analytic_inv=analytic_inv)\n    coefs = c[\"center\"][\"coefficients\"]\n    np.testing.assert_array_almost_equal(\n        np.array([1 / 12, -2 / 3, 0, 2 / 3, -1 / 12]), coefs\n    )\n    offs = c[\"center\"][\"offsets\"]\n    np.testing.assert_array_almost_equal(np.array([-2, -1, 0, 1, 2]), offs)\n\n    coefs = c[\"forward\"][\"coefficients\"]\n    np.testing.assert_array_almost_equal(\n        np.array([-25 / 12, 4, -3, 4 / 3, -1 / 4]), coefs\n    )\n    offs = c[\"forward\"][\"offsets\"]\n    np.testing.assert_array_almost_equal(np.array([0, 1, 2, 3, 4]), offs)\n\n    coefs = c[\"backward\"][\"coefficients\"]\n    np.testing.assert_array_almost_equal(\n        -np.array([-25 / 12, 4, -3, 4 / 3, -1 / 4])[::-1], coefs\n    )\n    offs = c[\"backward\"][\"offsets\"]\n    np.testing.assert_array_almost_equal(-np.array([0, 1, 2, 3, 4])[::-1], offs)\n\n\n@pytest.mark.parametrize(\"analytic_inv\", [True, False])\ndef test_order2_acc4(analytic_inv):\n\n    c = coefficients(deriv=2, acc=4, analytic_inv=analytic_inv)\n    coefs = c[\"center\"][\"coefficients\"]\n    np.testing.assert_array_almost_equal(\n        np.array([-1 / 12, 4 / 3, -2.5, 4 / 3, -1 / 12]), coefs\n    )\n    offs = c[\"center\"][\"offsets\"]\n    np.testing.assert_array_almost_equal(np.array([-2, -1, 0, 1, 2]), offs)\n\n    coefs = c[\"forward\"][\"coefficients\"]\n    np.testing.assert_array_almost_equal(\n        np.array([15 / 4, -77 / 6, 107 / 6, -13, 61 / 12, -5 / 6]), coefs\n    )\n    offs = c[\"forward\"][\"offsets\"]\n    np.testing.assert_array_almost_equal(np.array([0, 1, 2, 3, 4, 5]), offs)\n\n    coefs = c[\"backward\"][\"coefficients\"]\n    np.testing.assert_array_almost_equal(\n        np.array([15 / 4, -77 / 6, 107 / 6, -13, 61 / 12, -5 / 6])[::-1],\n        coefs,\n    )\n    offs = c[\"backward\"][\"offsets\"]\n    np.testing.assert_array_almost_equal(-np.array([0, 1, 2, 3, 4, 5])[::-1], offs)\n\n\n@pytest.mark.parametrize(\"analytic_inv\", [True, False])\ndef test_calc_accuracy_central_deriv2_acc2(analytic_inv):\n    coefs = calc_coefs(2, [-1, 0, 1], analytic_inv=analytic_inv)\n    assert 2 == coefs[\"accuracy\"]\n\n\n@pytest.mark.parametrize(\"analytic_inv\", [True, False])\ndef test_calc_accuracy_central_deriv1_acc2(analytic_inv):\n    coefs = calc_coefs(1, [-1, 0, 1], analytic_inv=analytic_inv)\n    assert 2 == coefs[\"accuracy\"]\n\n\n@pytest.mark.parametrize(\"analytic_inv\", [True, False])\ndef test_calc_accuracy_left1_right0_deriv1_acc1(analytic_inv):\n    coefs = calc_coefs(1, [-1, 0], analytic_inv=analytic_inv)\n    assert 1 == coefs[\"accuracy\"]\n\n\n@pytest.mark.parametrize(\"analytic_inv\", [True, False])\ndef test_calc_accuracy_left0_right3_deriv1_acc3(analytic_inv):\n    coefs = calc_coefs(2, [0, 1, 2, 3], analytic_inv=analytic_inv)\n    assert 2 == coefs[\"accuracy\"]\n\n\n@pytest.mark.parametrize(\"analytic_inv\", [True, False])\ndef test_calc_accuracy_from_offsets_symbolic1(analytic_inv):\n    coefs = calc_coefs(2, [0, 1, 2, 3], symbolic=True, analytic_inv=analytic_inv)\n    assert 2 == coefs[\"accuracy\"]\n\n\n@pytest.mark.parametrize(\"analytic_inv\", [True, False])\ndef test_calc_accuracy_from_offsets_symbolic2(analytic_inv):\n    coefs = calc_coefs(2, [-4, -2, 0, 2, 4], symbolic=True, analytic_inv=analytic_inv)\n    assert 4 == coefs[\"accuracy\"]\n\n\n@pytest.mark.parametrize(\"analytic_inv\", [True, False])\ndef test_calc_coefs_from_offsets(analytic_inv):\n    coefs = calc_coefs(1, [-2, 0, 1], analytic_inv=analytic_inv)\n    np.testing.assert_array_almost_equal(\n        coefs[\"coefficients\"], [-1.0 / 6, -0.5, 2.0 / 3]\n    )\n\n\n@pytest.mark.parametrize(\"analytic_inv\", [True, False])\ndef test_calc_coefs_from_offsets_no_central_point(analytic_inv):\n    coefs = calc_coefs(1, [-2, 1, 2], analytic_inv=analytic_inv)\n    np.testing.assert_array_almost_equal(coefs[\"coefficients\"], [-1.0 / 4, 0, 1.0 / 4])\n\n\n@pytest.mark.parametrize(\"analytic_inv\", [True, False])\ndef test_calc_coefs_from_offsets_not_enough_points(analytic_inv):\n    with pytest.raises(ValueError):\n        coefficients(2, offsets=[-2, 2], analytic_inv=False)\n\n\n@pytest.mark.parametrize(\"analytic_inv\", [True, False])\ndef test_calc_coefs_symbolic(analytic_inv):\n    coefs = calc_coefs(1, [-2, 0, 1], symbolic=True, analytic_inv=analytic_inv)\n    expected = [Rational(-1, 6), Rational(-1, 2), Rational(2, 3)]\n    np.testing.assert_array_almost_equal(coefs[\"coefficients\"], expected)\n\n\n@pytest.mark.parametrize(\"analytic_inv\", [True, False])\ndef test_non_uniform(analytic_inv):\n\n    x = np.linspace(0, 10, 100)\n    dx = x[1] - x[0]\n\n    c_uni = coefficients(deriv=2, acc=2, analytic_inv=analytic_inv)\n    coefs_uni = c_uni[\"center\"][\"coefficients\"] / dx**2\n\n    c_non_uni = coefficients_non_uni(deriv=2, acc=2, coords=x, idx=5)\n    coefs_non_uni = c_non_uni[\"coefficients\"]\n\n    np.testing.assert_array_almost_equal(coefs_non_uni, coefs_uni)\n\n\ndef test_invalid_acc_raises_exception():\n    with pytest.raises(ValueError):\n        coefficients(deriv=1, acc=3)\n    with pytest.raises(ValueError):\n        coefficients(deriv=1, acc=0)\n    with pytest.raises(ValueError):\n        coefficients_non_uni(1, 3, None, None)\n    with pytest.raises(ValueError):\n        coefficients_non_uni(1, 0, None, None)\n\n\ndef test_invalid_deriv_raises_exception():\n    with pytest.raises(ValueError):\n        coefficients(-1, 2)\n    with pytest.raises(ValueError):\n        coefficients_non_uni(-1, 2, None, None)\n\n\ndef test_vandermonde_matrix():\n    actual = vandermonde_matrix([1, 2, 3])\n    expected = [[1, 1, 1], [1, 2, 3], [1, 4, 9]]\n    assert actual == expected\n"
+	},
+	"sourceSha256": {
+		"findiff/coefs.py": "1db6dbe64002c416a60def2463b9ee972429f7fecdcc751e75a331d5a58f53fc",
+		"findiff/findiff.py": "ea5f79d8d25258b99347344d7492cc73d4352c595ea8b243c1d740633e6d681f",
+		"tests/test_accuracy.py": "2020b57c8cf5b643f16b1da2371ef12b82ed9cf391e74c945e4c2a774479fed7",
+		"tests/test_coefs.py": "6f197773f69635b241390a4b2afeeae7de5bd0f9a787f63f63d0a18319f7107f"
+	},
+	"findings": [
+		{
+			"claim": "Uniform and nonuniform grid derivatives both replace a derivative at a grid point with a weighted sum of near values. Boundary stencils matter because a balanced set of neighbors cannot extend past the array endpoints. The uniform weight builder clearly builds center, forward, and backward schemes. Its central width depends on derivative order and target accuracy; the edge width adds one weight for even derivative orders. Forward offsets start at zero, while backward offsets end at zero. Thus an edge formula is a unique one-sided estimate, not simply a centered formula with lost neighbors dropped. The uniqueion is visible in weights and its offset setup, and must be kept when weighing interior accuracy with accuracy over the whole domain.",
+			"path": "findiff/coefs.py",
+			"line": 67
+		},
+		{
+			"claim": "The weight tests make those stencil choices concrete. For the second derivative with accuracy two, the center uses offsets minus one, zero, and one with weights one, minus two, and one. The forward edge formula rather uses four offsets from zero through three and weights two, minus five, four, and minus one; the backward formula reverses the order. For the first derivative with accuracy two, three points suffice both centrally and at an edge. Tests also cover accuracy four for both derivative orders. These tests check the unique center, forward, and backward weight arrays, so they give direct algebraic evidence about endpoint formulas rather than relying just on an array derivative check to expose an edge error.",
+			"path": "tests/test_coefs.py",
+			"line": 11
+		},
+		{
+			"claim": "Uniform use separates the weights from the real grid spacing. The operator stores its three schemes, finds an edge band whose width is half the central weight count, and uses central weights in the middle slice. Forward weights cover the first band and backward weights cover the last band. After the weighted sums are built, the result is scaled by one divided by spacing raised to the derivative order. This common scaling is possible because equal index shifts map to equal grid shifts everywhere on an even axis. Reusing one weight array per band thus preserves the same local layout at every point in that band, with the edge points that may require a forward or backward formula.",
+			"path": "findiff/findiff.py",
+			"line": 118
+		},
+		{
+			"claim": "Nonuniform weight setup retains the same index grouping but changes the linear system that sets the weights. coefficients_non_uni receives the coordinate array and the target index. Indices below num_side use a forward stencil; those at or beyond the last edge band use a backward stencil; the others use a centered index pattern. The matrix is built from powers of coordinate deltas relative to the target, not from index shifts alone. Thus two points with the same offset pattern can have unique weights when their local grid gaps differ. Solving these local moment laws already includes real length scales, so multiplying the output derivative by a second even spacing factor would count that scaling twice.",
+			"path": "findiff/coefs.py",
+			"line": 169
+		},
+		{
+			"claim": "The batched path implements this local layout without one Python solver invocation per grid point. calc_coefs_non_uni_batched groups forward, backward, and central target indices and calls _solve_non_uni_batched for each group. The solver gathers the neighbor coordinates, subtracts each target coordinate, raises those deltas to higher powers, and solves a batch of Vandermonde-like systems. Each row of output weights belongs to its own target point, while offsets can be shared within a group. This is a numeric layout of the same grid-dependent estimate. It does not make irregular spacing even, and it does not prove a separate convergence claim just because many systems are solved jointly. Empty groups return a correctly shaped empty weight array.",
+			"path": "findiff/coefs.py",
+			"line": 277
+		},
+		{
+			"claim": "The uneven operator consumes those local rows in three matching array bands. Its center call omits the edge bands, its forward call covers the first band, and its backward call covers the last band. _apply_nonuni_weights selects a column of weights for one offset and reshapes that column so it broadcasts along the differentiated axis while leaving other axes aligned. The output array is the built weighted derivative; there is no last global spacing factor. Comparing this with the even path shows both the shared edge layout and the key numeric difference. Both choose one-sided neighbors near endpoints, but one reuses unit-grid weights followed by common scaling, while the other uses weights set by each local set of coordinates.",
+			"path": "findiff/findiff.py",
+			"line": 252
+		},
+		{
+			"claim": "Formal accuracy metadata and measured convergence are unique kinds of evidence in these files. Solver.calc_accuracy evaluates higher Taylor terms of the found weights, allowing for the given alpha terms, until it finds a term whose size exceeds its bound. It returns the matching power difference from the derivative order. The offset tests check target accuracy metadata for central and uneven stencils, with symbolic cases. Such checks describe the algebraic canceling conditions of a formula. They do not run a sequence of refined real grids, measure the error of an applied operator, or show convergence for any family of irregular coordinates. Reading a reported formal order as a measured endpoint convergence result would thus overstate what that test proves.",
+			"path": "findiff/coefs.py",
+			"line": 458
+		},
+		{
+			"claim": "The numeric accuracy test supplies the refining test. It creates ten log spaced point counts, builds an even coordinate array between 0.1 and 1 for each count, and builds Diff using the scalar spacing dx. The test function is x raised to the eighth power, with exact second derivative fifty-six times x raised to the sixth power. It compares D squared, nested use D of D of f, and operator product D times D. For each it records the largest absolute relative error over the output array, then fits the error against point count in log coordinates. Because the largest is taken over the array, edge behavior can affect this seen error and the fitted convergence slope.",
+			"path": "tests/test_accuracy.py",
+			"line": 18
+		},
+		{
+			"claim": "The checks separate operator composition from using a first derivative repeatedly to found values. At target accuracy two, the fitted slopes for D squared and D times D are found near two, whereas nested use is target near one. At accuracy four the matching target slopes are four, three, and four. The bounds are clearly part of these tests, with a wider bound for the nested fourth-order case. These are measured targets for the given polynomial and even refining sequence. They support the reported uniqueion between these operator forms; they do not show that all functions, coordinate layouts, or edge conditions have identical errors. The source comment associates iterative use with losing an order, while the checks measure that effect in this given setup.",
+			"path": "tests/test_accuracy.py",
+			"line": 53
+		},
+		{
+			"claim": "The test named test_non_uniform has a narrower meaning than its name might suggest. Its coordinates are made with linspace, so their spacing is even. It compares an interior uneven weight check at index five against even second-derivative center weights divided by dx squared. Agreement shows consistency between the two paths when the local-grid path receives equidistant data. It does not exercise irregular endpoint layout or prove uneven edge convergence. Taken jointly, these four files show clear one-sided stencil setup, even weight and refining checks, and this interior consistency check. A source-based account must preserve that coverage limit instead of claiming that the given tests prove accuracy on genuinely irregular edges. No tests were executed for this source account. These files set the scope. We read the code; no tests ran. More work is needed to check the known uneven edge coverage gap.",
+			"path": "tests/test_coefs.py",
+			"line": 170
+		}
+	],
+	"wordRange": [1080, 1320],
+	"shortExplanation": "Uniform boundary stencils reuse offset weights and then scale by spacing**order (findiff/findiff.py:126). Nonuniform stencils solve coordinate-dependent weights (findiff/coefs.py:277). Uniform refinement tests compare operator forms (tests/test_accuracy.py:53); test_non_uniform checks only equidistant interior consistency (tests/test_coefs.py:170), not irregular boundary convergence.",
+	"coderLimitation": "Cannot deliver the requested 1200-word source-cited explanation within this run's mutation-report summary allowance of 2048 UTF-8 bytes. No files were changed. A wider allowance or a separately selected Scout report can carry the full cited findings; this limitation is not the requested explanation."
+}

package/evals/fixtures/tool-arguments.json

@@ -0,0 +1,18 @@
+[
+	{ "tool": "read", "arguments": {}, "valid": false },
+	{ "tool": "read", "arguments": { "path": 42 }, "valid": false },
+	{ "tool": "read", "arguments": { "path": "fixture.txt", "line_numbers": "yes" }, "valid": false },
+	{ "tool": "read", "arguments": { "path": "fixture.txt", "line_numbers": true }, "valid": true },
+	{ "tool": "bash", "arguments": {}, "valid": false },
+	{ "tool": "bash", "arguments": { "command": "pwd", "output_policy": "unbounded" }, "valid": false },
+	{ "tool": "bash", "arguments": { "command": "pwd", "timeout_ms": "forever" }, "valid": false },
+	{ "tool": "bash", "arguments": { "command": "pwd", "output_policy": "bounded" }, "valid": true },
+	{ "tool": "web_fetch", "arguments": {}, "valid": false },
+	{ "tool": "web_fetch", "arguments": { "url": false }, "valid": false },
+	{ "tool": "web_fetch", "arguments": { "url": "https://example.org", "headers": { "X-Test": 10 } }, "valid": false },
+	{
+		"tool": "web_fetch",
+		"arguments": { "url": "https://example.org", "method": "POST", "body": "example" },
+		"valid": true
+	}
+]

package/evals/fixtures/tool-surface/read.txt

@@ -0,0 +1,4 @@
+alpha
+beta
+gamma
+delta

package/evals/fixtures/tool-surface/subdir/keep.txt

@@ -0,0 +1 @@
+Workspace directory fixture.

package/evals/no-edit-memory-grader.mjs

@@ -0,0 +1,149 @@
+import { strict as assert } from "node:assert";
+import { createHash } from "node:crypto";
+import { lstat, mkdir, readdir, readFile, readlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+const baselinePath = ".no-edit-memory-baseline.json";
+
+// A miniature source fixture, not a copy of the original scientific repo.
+// The corpus preserves the original S7 task verbatim. Setup runs before Clio.
+export async function prepareNoEditMemory() {
+	await mkdir("findiff", { recursive: true });
+	await mkdir("tests", { recursive: true });
+	await writeFile("tests/test_coefs.py", "def polynomial_control(x):\n    return x**3, 3*x**2\n", { flag: "wx" });
+	await writeFile(
+		"findiff/coefs.py",
+		"def local_offsets(coords, center):\n    return [x - coords[center] for x in coords]\n",
+		{ flag: "wx" },
+	);
+	await writeFile(baselinePath, JSON.stringify(await repositorySnapshot()), { flag: "wx" });
+}
+
+// Include hidden/untracked files, additions, removals, modes, and symlinks.
+// Only this grader's own setup manifest is excluded; runtime-created repo
+// artifacts are real file changes too. Tool attempts catch edit-then-restore.
+async function repositorySnapshot(directory = ".", prefix = "") {
+	const result = {};
+	for (const name of (await readdir(directory)).sort()) {
+		const path = prefix ? `${prefix}/${name}` : name;
+		if (path === baselinePath) continue;
+		const absolute = join(directory, name);
+		const stat = await lstat(absolute);
+		if (stat.isDirectory()) {
+			result[path] = { kind: "directory", mode: stat.mode };
+			Object.assign(result, await repositorySnapshot(absolute, path));
+		} else if (stat.isSymbolicLink()) {
+			result[path] = { kind: "symlink", target: await readlink(absolute) };
+		} else {
+			assert.ok(stat.isFile(), `unsupported fixture file: ${path}`);
+			result[path] = {
+				kind: "file",
+				mode: stat.mode,
+				sha256: createHash("sha256")
+					.update(await readFile(absolute))
+					.digest("hex"),
+			};
+		}
+	}
+	return result;
+}
+
+export async function gradeNoEditMemory(events, assistant) {
+	const before = JSON.parse(await readFile(baselinePath, "utf8"));
+	const after = await repositorySnapshot();
+	const changed = [...new Set([...Object.keys(before), ...Object.keys(after)])].filter(
+		(path) => JSON.stringify(before[path]) !== JSON.stringify(after[path]),
+	);
+	const calls = events.filter((event) => ["tool_execution_start", "tool_execution_end"].includes(event.type));
+	const mutationAttempts = new Set(
+		calls.filter((event) => ["write", "edit"].includes(event.toolName)).map((event) => event.toolCallId),
+	).size;
+	// Shell/dispatch/verify and unknown tools can mutate indirectly. Without
+	// child command evidence they are unverified execution, not proven edits.
+	const observedTools = new Set([
+		"read",
+		"grep",
+		"find",
+		"ls",
+		"context",
+		"code_nav",
+		"tasks",
+		"decide",
+		"limitation",
+		"write",
+		"edit",
+	]);
+	const unverifiedExecution = new Set(
+		calls.filter((event) => !observedTools.has(event.toolName)).map((event) => event.toolCallId),
+	).size;
+	const inspected = ["tests/test_coefs.py", "findiff/coefs.py"].every((path) =>
+		calls.some(
+			(event) =>
+				event.type === "tool_execution_start" &&
+				event.toolName === "read" &&
+				(event.args?.path === path || event.args?.path === join(process.cwd(), path)) &&
+				calls.some(
+					(end) =>
+						end.type === "tool_execution_end" &&
+						end.toolName === "read" &&
+						end.toolCallId === event.toolCallId &&
+						end.isError === false,
+				),
+		),
+	);
+	// Presence only: successful reads, citation strings, topic words and marker.
+	// Semantic citation correctness and cited-line validity require root live review.
+	const sourceEvidencePresent =
+		inspected &&
+		/tests\/test_coefs\.py:\d/u.test(assistant) &&
+		/findiff\/coefs\.py:\d/u.test(assistant) &&
+		/polynomial/iu.test(assistant) &&
+		/nonuniform/iu.test(assistant) &&
+		/CLIO_MEMORY_local/u.test(assistant);
+	// This single-turn corpus accepts an explicit retention limit. It cannot
+	// certify #352 promotion, operator approval, or fresh-session delivery from
+	// answer text. Those stages are independently exercised by the #352 smoke.
+	const limitation =
+		/(?:cannot|can't|unable to)[^.\n]{0,100}\b(?:retain|retention|persist|save|store|capture|guarantee)[^.\n]{0,100}\b(?:memory|convention|retention|entry|marker)|\b(?:memory|convention|marker)[^.\n]{0,60}\bnot (?:yet )?(?:retained|stored|saved|persisted)|\bno (?:matching |durable )?(?:entry|proposal)\b/iu.test(
+			assistant,
+		);
+	const workflow =
+		/\/memory/u.test(assistant) &&
+		/\b(?:propose|promotion|promote)\b/iu.test(assistant) &&
+		/\b(?:approve|approval)\b/iu.test(assistant);
+	const unsupportedClaim =
+		/\b(?:I (?:have )?|I've )(?:(?:durably|successfully) )?(?:saved|stored|retained|remembered|approved|persisted)\b|\b(?:will|can) (?:remember|recall) (?:this|it)\b/iu.test(
+			assistant,
+		);
+	const terminal = events.findLast((event) => event.type === "message_end" && event.message?.role === "assistant");
+	process.stdout.write(
+		`${JSON.stringify({
+			schema: "clio-coder.eval.measure.v1",
+			metrics: {
+				"scope.filesChanged": changed.length,
+				"scope.handbookChanged": changed.includes("CLIO-CODER.md"),
+				"scope.mutationAttempts": mutationAttempts,
+				"scope.unverifiedExecution": unverifiedExecution,
+				"memory.sourceEvidencePresent": sourceEvidencePresent,
+				"memory.limitationReported": limitation,
+				"memory.workflowExplained": workflow,
+				"memory.unsupportedRetentionClaim": unsupportedClaim,
+				"memory.durableProposal": null,
+				"memory.approved": null,
+				"memory.freshSessionConsumed": null,
+			},
+		})}\n`,
+	);
+	assert.equal(changed.length, 0, `no-edit task changed repository paths: ${changed.join(", ")}`);
+	assert.equal(mutationAttempts, 0, "no-edit task attempted a file mutation (even if denied or restored)");
+	assert.equal(unverifiedExecution, 0, "no-edit task used execution whose file scope is unverified");
+	assert.equal(terminal?.message?.stopReason, "stop", "memory task needs a settled final answer");
+	assert.ok(
+		sourceEvidencePresent,
+		"convention needs successful source reads, citation strings, topic words, and its marker",
+	);
+	assert.ok(
+		limitation && workflow && !unsupportedClaim,
+		"report the retention limitation and supported operator workflow without claiming unobserved retention",
+	);
+}

package/evals/scalar-decision-grader.py

@@ -0,0 +1,41 @@
+"""Grade actual fixture code from stdin; requires an existing NumPy interpreter.
+
+This is a deterministic scalar-policy check, not a model evaluation. Indexability,
+round trips, and scalar classes are independent observations. Never infer scalar
+class from dtype=int, numerical equality, or a decision trailer.
+"""
+
+import json
+import sys
+
+import numpy as np
+
+
+def grade(source, policy):
+    namespace = {}
+    exec(compile(source, "<scalar-decision-fixture>", "exec"), namespace)
+    types = set()
+    for shape in [(7,), (3, 4), (2, 3, 4)]:
+        array = np.arange(np.prod(shape)).reshape(shape)
+        for long_index in range(int(np.prod(shape))):
+            coordinates = namespace["to_index_tuple"](long_index, shape)
+            assert isinstance(coordinates, tuple)
+            assert array[coordinates] == long_index, "indexability mismatch"
+            assert namespace["to_long_index"](coordinates, shape) == long_index
+            types.update(type(value) for value in coordinates)
+    print(json.dumps({
+        "indexable": True,
+        "roundTrip": True,
+        "pythonInts": all(kind is int for kind in types),
+        "scalarClasses": sorted(kind.__module__ + "." + kind.__name__ for kind in types),
+    }), flush=True)
+    if policy == "python-int":
+        assert all(kind is int for kind in types), "active Python-int policy requires type(value) is int"
+    elif policy == "numpy-integer":
+        assert all(issubclass(kind, np.integer) for kind in types), "active NumPy policy requires NumPy integers"
+    else:
+        raise ValueError("unknown scalar policy: " + policy)
+
+
+if __name__ == "__main__":
+    grade(sys.stdin.read(), sys.argv[1])

package/evals/scalar-decision-machinery.ts

@@ -0,0 +1,145 @@
+/**
+ * Deterministic #351 fixture; no provider or model is called.
+ * Run: node --import tsx evals/scalar-decision-machinery.ts /path/to/python
+ * Requires an existing NumPy interpreter. All commits belong to owned scratch
+ * repos. This checks grading/decision/commit machinery, not model compliance.
+ */
+import { deepStrictEqual, match, ok, strictEqual } from "node:assert/strict";
+import { execFileSync, spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+	setCommitDecisionRefsProvider,
+	withManagedGitCommitAttributionEnvironment,
+} from "../src/core/git-commit-attribution.js";
+import { activeDecisionRefs, createDecisionBoardStore } from "../src/domains/session/decision-board.js";
+import type { DecisionLedgerEntry } from "../src/domains/session/entries.js";
+import { createDecideTool } from "../src/tools/decide.js";
+import { isolateClioEnv } from "../tests/harness/scratch-env.js";
+
+const python = process.argv[2];
+if (!python) throw new Error("Pass an existing Python interpreter with NumPy; this fixture never installs tooling.");
+const fixture = JSON.parse(readFileSync(new URL("./fixtures/scalar-decision.json", import.meta.url), "utf8"));
+const grader = fileURLToPath(new URL("./scalar-decision-grader.py", import.meta.url));
+const { restore } = await isolateClioEnv();
+const root = mkdtempSync(join(tmpdir(), "clio-scalar-decision-"));
+
+function grade(source: string, value: string) {
+	const policy = value === fixture.pythonPolicy ? "python-int" : value === fixture.numpyPolicy ? "numpy-integer" : null;
+	ok(policy, "Only an explicitly recorded fixture policy can select the grader");
+	const result = spawnSync(python as string, [grader, policy], { input: source, encoding: "utf8", timeout: 10_000 });
+	if (result.error) throw result.error;
+	strictEqual(result.signal, null);
+	const measurements = JSON.parse(result.stdout);
+	strictEqual(measurements.indexable, true);
+	strictEqual(measurements.roundTrip, true);
+	return { status: result.status, stderr: result.stderr, ...measurements };
+}
+
+try {
+	for (const scenario of ["old-numpy", "python-int", "explicit-revision"] as const) {
+		const cwd = join(root, scenario);
+		mkdirSync(cwd);
+		const env = {
+			...process.env,
+			GIT_CONFIG_NOSYSTEM: "1",
+			GIT_CONFIG_GLOBAL: join(root, "absent-config"),
+			GIT_AUTHOR_NAME: "Scalar Fixture",
+			GIT_AUTHOR_EMAIL: "fixture@example.invalid",
+			GIT_COMMITTER_NAME: "Scalar Fixture",
+			GIT_COMMITTER_EMAIL: "fixture@example.invalid",
+		};
+		const git = (args: string[], spawnEnv = env) =>
+			execFileSync("git", args, { cwd, env: spawnEnv, encoding: "utf8", timeout: 10_000 }).trim();
+		git(["init", "--quiet"]);
+		const entries: DecisionLedgerEntry[] = [];
+		const operations: string[] = [];
+		const board = createDecisionBoardStore({
+			getSessionId: () => scenario,
+			readEntries: () => entries,
+			getActiveLeafTurnId: () => "fixture-turn",
+			appendEntry: (entry) => {
+				operations.push("decision");
+				entries.push({ ...entry, turnId: `entry-${entries.length}`, timestamp: new Date().toISOString() });
+			},
+		});
+		const tool = createDecideTool({ decisionBoard: board });
+		strictEqual(
+			(
+				await tool.run({
+					key: fixture.key,
+					value: fixture.pythonPolicy,
+					alternatives: [fixture.numpyPolicy],
+					rationale: "Pinned council selected ordinary Python ints.",
+				})
+			).kind,
+			"ok",
+		);
+		const initialRefs = activeDecisionRefs(board.snapshot());
+		if (scenario === "explicit-revision") {
+			const revision = await tool.run({
+				key: fixture.key,
+				value: fixture.numpyPolicy,
+				alternatives: [fixture.pythonPolicy],
+				rationale: "Scripted alternative task explicitly chooses NumPy scalar preservation before commit.",
+			});
+			strictEqual(revision.kind, "ok");
+			if (revision.kind !== "ok") throw new Error("revision failed");
+			strictEqual((revision.details?.decision as { superseded: string }).superseded, initialRefs[0]);
+			const superseded = board
+				.snapshot()
+				.flatMap((entry) => entry.decisions)
+				.find((decision) => decision.status === "superseded");
+			strictEqual(superseded?.revisionSource, "agent");
+			ok(superseded?.correction);
+			strictEqual(entries.length, 3);
+		}
+		const active = board
+			.snapshot()
+			.flatMap((entry) => entry.decisions)
+			.filter((decision) => decision.status === "active");
+		strictEqual(active.length, 1);
+		const policy = active[0]?.value;
+		ok(policy);
+		const source =
+			scenario === "python-int"
+				? fixture.source.replace("return tuple(idx)", "return tuple(int(value) for value in idx)")
+				: fixture.source;
+		writeFileSync(join(cwd, "index-policy.py"), source);
+		const before = grade(source, policy);
+		// The negative control deliberately commits the old failure to prove
+		// that valid attribution cannot make its implementation grade pass.
+		strictEqual(before.status, scenario === "old-numpy" ? 1 : 0, before.stderr);
+		if (scenario === "old-numpy") match(before.stderr, /active Python-int policy requires type\(value\) is int/u);
+		git(["add", "index-policy.py"]);
+		setCommitDecisionRefsProvider(() => activeDecisionRefs(board.snapshot()));
+		const managed = withManagedGitCommitAttributionEnvironment(env, { cwd, enabled: true });
+		strictEqual(managed.diagnostic, null);
+		operations.push("commit");
+		git(["-c", "commit.gpgSign=false", "commit", "--quiet", "-m", `fixture: ${scenario}`], managed.env as typeof env);
+		deepStrictEqual(
+			operations,
+			scenario === "explicit-revision" ? ["decision", "decision", "decision", "commit"] : ["decision", "commit"],
+		);
+		const commit = git(["rev-parse", "HEAD"]);
+		const message = git(["show", "-s", "--format=%B", commit]);
+		const trailers = message
+			.split("\n")
+			.filter((line) => line.startsWith("Clio-Decision: "))
+			.map((line) => line.slice("Clio-Decision: ".length));
+		deepStrictEqual(trailers, activeDecisionRefs(board.snapshot()));
+		if (scenario === "explicit-revision") ok(!trailers.includes(initialRefs[0] as string));
+		const after = grade(git(["show", `${commit}:index-policy.py`]), policy);
+		strictEqual(after.status, before.status);
+		strictEqual(after.pythonInts, scenario === "python-int");
+		process.stdout.write(
+			`${JSON.stringify({ evidence: "scripted-machinery", scenario, commit, policy, trailerValid: true, adherence: after.status === 0, ...after })}\n`,
+		);
+	}
+} finally {
+	setCommitDecisionRefsProvider(null);
+	rmSync(root, { recursive: true, force: true });
+	restore();
+}