Keep the retired CSR row-sum kernels and tile_int under old-code

sum_all_rows_csr_alloc, sum_block_of_rows_csr_alloc and
sum_evenly_spaced_rows_csr_alloc are standalone CSR operations worth keeping
for a sparse linear algebra library even though the engine no longer calls
them; tile_int likewise. Moved verbatim into the old-code folder, which is
still compiled.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B6Bs765i1HTbqx3LUu6LMP

Author: dance858

include/old-code/old_CSR_sum.h

@@ -58,4 +58,23 @@ void sum_all_rows_csr_fill_values(const CSR_matrix *A, CSR_matrix *C,
 void sum_block_of_rows_csr_fill_values(const CSR_matrix *A, CSR_matrix *C,
                                        const int *idx_map);
 
+/* Row-sum kernels that also produce an idx_map (input nnz -> position in C->x),
+   so values can be filled by zeroing C->x and calling accumulator() from
+   utils/CSR_sum.h. C must be pre-allocated with capacity >= A->nnz; iwork must
+   have size max(A->n, A->nnz); idx_map must have size A->nnz. C->nnz is set. */
+
+/* All rows of A into the single row of C (C->m == 1). */
+void sum_all_rows_csr_alloc(const CSR_matrix *A, CSR_matrix *C, int *iwork,
+                            int *idx_map);
+
+/* Consecutive blocks of row_block_size rows of A into one row of C each
+   (C->m == A->m / row_block_size). */
+void sum_block_of_rows_csr_alloc(const CSR_matrix *A, CSR_matrix *C,
+                                 int row_block_size, int *iwork, int *idx_map);
+
+/* Rows of A at stride row_spacing into one row of C each (C->m == row_spacing):
+   C[j, :] = sum_{i : i % row_spacing == j} A[i, :]. */
+void sum_evenly_spaced_rows_csr_alloc(const CSR_matrix *A, CSR_matrix *C,
+                                      int row_spacing, int *iwork, int *idx_map);
+
 #endif /* OLD_CSR_SUM_H */

include/old-code/old_mini_numpy.h

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2026 Daniel Cederberg and William Zhang
+ *
+ * This file is part of the SparseDiffEngine project.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef OLD_MINI_NUMPY_H
+#define OLD_MINI_NUMPY_H
+
+/* Example: a = [1, 2], len = 2, tiles = 3, result = [1, 2, 1, 2, 1, 2].
+   Retired from utils/mini_numpy.h with the CSR broadcast kernel, its last
+   caller. */
+void tile_int(int *result, const int *a, int len, int tiles);
+
+#endif /* OLD_MINI_NUMPY_H */

src/old-code/old_CSR_sum.c

@@ -18,6 +18,7 @@
 #include "old-code/old_CSR_sum.h"
 #include "utils/CSR_matrix.h"
 #include "utils/int_double_pair.h"
+#include "utils/utils.h"
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
@@ -330,3 +331,198 @@ void sum_spaced_rows_into_row_csr(const CSR_matrix *A, CSR_matrix *C,
 
     C->p[1] = C->nnz;
 }
+
+// ------------------------------------------------------------------------------------
+// Row-sum kernels with an idx_map (input nnz -> output position), retired from the
+// engine when the sum atom moved onto the generic row_reduce primitive. Kept as
+// standalone CSR operations. Fill values with accumulator() from utils/CSR_sum.h
+// after zeroing C->x.
+// ------------------------------------------------------------------------------------
+
+/* iwork must have size max(A->n, A->nnz), and idx_map must have size A->nnz */
+void sum_all_rows_csr_alloc(const CSR_matrix *A, CSR_matrix *C, int *iwork,
+                            int *idx_map)
+{
+    // -------------------------------------------------------------------
+    //           Build sparsity pattern of the summed row
+    // -------------------------------------------------------------------
+    int *cols = iwork;
+    memcpy(cols, A->i, A->nnz * sizeof(int));
+    sort_int_array(cols, A->nnz);
+
+    int unique_nnz = 0;
+    int prev_col = -1;
+    for (int j = 0; j < A->nnz; j++)
+    {
+        if (cols[j] != prev_col)
+        {
+            C->i[unique_nnz] = cols[j];
+            prev_col = cols[j];
+            unique_nnz++;
+        }
+    }
+
+    C->p[0] = 0;
+    C->p[1] = unique_nnz;
+    C->nnz = unique_nnz;
+
+    // -------------------------------------------------------------------
+    //  Map child values to summed-row positions. col_to_pos maps
+    //  column indices to positions in C's row.
+    // -------------------------------------------------------------------
+    int *col_to_pos = iwork;
+    for (int idx = 0; idx < unique_nnz; idx++)
+    {
+        col_to_pos[C->i[idx]] = idx;
+    }
+
+    for (int i = 0; i < A->m; i++)
+    {
+        for (int j = A->p[i]; j < A->p[i + 1]; j++)
+        {
+            idx_map[j] = col_to_pos[A->i[j]];
+        }
+    }
+}
+
+/* iwork must have size max(A->n, A->nnz), and idx_map must have size A->nnz */
+void sum_block_of_rows_csr_alloc(const CSR_matrix *A, CSR_matrix *C,
+                                 int row_block_size, int *iwork, int *idx_map)
+{
+    assert(A->m % row_block_size == 0);
+    int n_blocks = A->m / row_block_size;
+    assert(C->m == n_blocks);
+
+    C->n = A->n;
+    C->p[0] = 0;
+    int cursor = 0;
+
+    int *cols = iwork;
+    int *col_to_pos = iwork;
+
+    for (int block = 0; block < n_blocks; block++)
+    {
+        int start_row = block * row_block_size;
+        int end_row = start_row + row_block_size;
+
+        // -----------------------------------------------------------------
+        // Build sparsity pattern of the row resulting from summing
+        // the block of rows from A
+        // -----------------------------------------------------------------
+        C->p[block] = cursor;
+        int count = 0;
+        for (int row = start_row; row < end_row; row++)
+        {
+            for (int j = A->p[row]; j < A->p[row + 1]; j++)
+            {
+                cols[count++] = A->i[j];
+            }
+        }
+
+        /* Sort columns and write unique pattern into C->i */
+        sort_int_array(cols, count);
+
+        int unique_nnz = 0;
+        int prev_col = -1;
+        for (int t = 0; t < count; t++)
+        {
+            int col = cols[t];
+            if (t == 0 || col != prev_col)
+            {
+                C->i[cursor + unique_nnz] = col;
+                prev_col = col;
+                unique_nnz++;
+            }
+        }
+
+        cursor += unique_nnz;
+        C->p[block + 1] = cursor;
+
+        // -----------------------------------------------------------------
+        //         Build idx_map for all entries in this block
+        // -----------------------------------------------------------------
+        int row_start = C->p[block];
+        for (int idx = 0; idx < unique_nnz; idx++)
+        {
+            col_to_pos[C->i[row_start + idx]] = row_start + idx;
+        }
+
+        for (int row = start_row; row < end_row; row++)
+        {
+            for (int j = A->p[row]; j < A->p[row + 1]; j++)
+            {
+                idx_map[j] = col_to_pos[A->i[j]];
+            }
+        }
+    }
+
+    C->nnz = cursor;
+}
+
+/* iwork must have size max(A->n, A->nnz), and idx_map must have size A->nnz */
+void sum_evenly_spaced_rows_csr_alloc(const CSR_matrix *A, CSR_matrix *C,
+                                      int row_spacing, int *iwork, int *idx_map)
+{
+    assert(C->m == row_spacing);
+    C->n = A->n;
+    C->p[0] = 0;
+    int cursor = 0;
+
+    int *cols = iwork;
+    int *col_to_pos = iwork;
+
+    for (int C_row = 0; C_row < C->m; C_row++)
+    {
+        // -----------------------------------------------------------------
+        // Build sparsity pattern of the row resulting from summing
+        // evenly spaced rows from A
+        // -----------------------------------------------------------------
+        C->p[C_row] = cursor;
+        int count = 0;
+        for (int row = C_row; row < A->m; row += row_spacing)
+        {
+            for (int j = A->p[row]; j < A->p[row + 1]; j++)
+            {
+                cols[count++] = A->i[j];
+            }
+        }
+
+        /* Sort columns and write unique pattern into C->i */
+        sort_int_array(cols, count);
+
+        int unique_nnz = 0;
+        int prev_col = -1;
+        for (int t = 0; t < count; t++)
+        {
+            int col = cols[t];
+            if (t == 0 || col != prev_col)
+            {
+                C->i[cursor + unique_nnz] = col;
+                prev_col = col;
+                unique_nnz++;
+            }
+        }
+
+        cursor += unique_nnz;
+        C->p[C_row + 1] = cursor;
+
+        // -----------------------------------------------------------------
+        //         Build idx_map for all entries in evenly spaced rows
+        // -----------------------------------------------------------------
+        int row_start = C->p[C_row];
+        for (int idx = 0; idx < unique_nnz; idx++)
+        {
+            col_to_pos[C->i[row_start + idx]] = row_start + idx;
+        }
+
+        for (int row = C_row; row < A->m; row += row_spacing)
+        {
+            for (int j = A->p[row]; j < A->p[row + 1]; j++)
+            {
+                idx_map[j] = col_to_pos[A->i[j]];
+            }
+        }
+    }
+
+    C->nnz = cursor;
+}

src/old-code/old_mini_numpy.c

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2026 Daniel Cederberg and William Zhang
+ *
+ * This file is part of the SparseDiffEngine project.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "old-code/old_mini_numpy.h"
+#include <string.h>
+
+void tile_int(int *result, const int *a, int len, int tiles)
+{
+    for (int i = 0; i < tiles; i++)
+    {
+        memcpy(result + i * len, a, len * sizeof(int));
+    }
+}