Fix 15 bugs across cut, digitize, DataFrame, insertColumn, strExtractGroups, linspace, and tests

Source fixes:
- cut_qcut: right=false edge computation, degenerate step=0, float-point drift on last edge
- numeric_extended: digitize right=true bin assignment off-by-one
- numeric_extended: linspace preserves -0 start endpoint
- frame: constructor accepts optional columnNames for duplicate column support
- frame: shape/size/empty use columns.size (respects duplicate names)
- insert_pop: insertColumn builds column names array for allowDuplicates
- string_ops_extended: strExtractGroups handles all-non-matching rows via group counting

Test fixes (clear assertion/logic bugs):
- zscore ddof=0: range0 > range1 (population std is smaller, not larger)
- rolling_apply custom min: min([1,5,9])=1 not 5
- rolling_apply count: 1 valid value in [null,3,null] not 2
- window_extended rollingSkew: [1,9,10] is left-skewed, not [10,2,1]
- window_extended rollingQuantile q=0: min([1,5,9])=1 not 5
- wide_to_long missing stub: use multi-stub fixture so suffix "2" is discoverable
- wide_to_long property: account for duplicate id values in assertion
- to_from_dict split round-trip: skip when colB shorter than colA
- strDedent property: filter lines to have non-whitespace content

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Co-authored-by: mrjf <180956+mrjf@users.noreply.github.com>

Author: Copilot

src/core/frame.ts

@@ -102,10 +102,14 @@ export class DataFrame {
    * @param columns - Ordered map of column name → Series (all same length and index).
    * @param index   - Row index (must match each Series' length).
    */
-  constructor(columns: ReadonlyMap<string, Series<Scalar>>, index: Index<Label>) {
+  constructor(
+    columns: ReadonlyMap<string, Series<Scalar>>,
+    index: Index<Label>,
+    columnNames?: readonly string[],
+  ) {
     this._columns = columns;
     this.index = index;
-    this.columns = new Index<string>([...columns.keys()]);
+    this.columns = new Index<string>(columnNames ?? [...columns.keys()]);
   }
 
   /**
@@ -208,7 +212,7 @@ export class DataFrame {
 
   /** `[nRows, nCols]` — mirrors `pandas.DataFrame.shape`. */
   get shape(): [number, number] {
-    return [this.index.size, this._columns.size];
+    return [this.index.size, this.columns.size];
   }
 
   /** Always `2`. */
@@ -218,12 +222,12 @@ export class DataFrame {
 
   /** Total number of cells (`nRows * nCols`). */
   get size(): number {
-    return this.index.size * this._columns.size;
+    return this.index.size * this.columns.size;
   }
 
   /** `true` when the DataFrame has no rows or no columns. */
   get empty(): boolean {
-    return this.index.size === 0 || this._columns.size === 0;
+    return this.index.size === 0 || this.columns.size === 0;
   }
 
   // ─── column access ────────────────────────────────────────────────────────

src/core/insert_pop.ts

@@ -82,23 +82,28 @@ export function insertColumn(
   }
 
   // Rebuild the column map, inserting the new column at position `loc`.
+  const colNames: string[] = [];
   const colMap = new Map<string, Series<Scalar>>();
   let idx = 0;
 
   for (const colName of df.columns.values) {
     if (idx === loc) {
-      colMap.set(column, series);
+      colNames.push(column);
     }
+    colNames.push(colName);
     colMap.set(colName, df.col(colName));
     idx++;
   }
 
   // Handle insertion at the end (loc === nCols).
   if (loc === nCols) {
-    colMap.set(column, series);
+    colNames.push(column);
   }
 
-  return new DataFrame(colMap, df.index);
+  // Always add the new column data to the map (last-wins for duplicate names).
+  colMap.set(column, series);
+
+  return new DataFrame(colMap, df.index, colNames);
 }
 
 // ─── popColumn ────────────────────────────────────────────────────────────────

src/stats/cut_qcut.ts

@@ -260,11 +260,27 @@ export function cut(
     if (mn === mx) {
       throw new Error("Cannot cut constant array (all values identical).");
     }
-    const step = (mx - mn) / bins;
-    edges = Array.from({ length: bins + 1 }, (_, i) => mn + i * step);
-    // Slightly extend the lower edge so the minimum value is included
-    edges[0] = mn - step * 0.001;
-    edges = deduplicateEdges(edges, duplicates);
+    if (right) {
+      const step = (mx - mn) / bins;
+      edges = Array.from({ length: bins + 1 }, (_, i) => mn + i * step);
+      // Extend the lower edge so the minimum is inside the first (a, b] interval
+      edges[0] = mn - step * 0.001;
+      // Pin the upper edge to the exact max (avoids floating-point drift)
+      edges[edges.length - 1] = mx;
+    } else {
+      // For left-closed [a, b) intervals, extend the upper end so the max is included;
+      // linspace from mn to adjustedMx distributes the extension across all edges,
+      // keeping boundary values in the lower bin (matching pandas behaviour).
+      const adjustedMx = mx + (mx - mn) * 0.001;
+      const step = (adjustedMx - mn) / bins;
+      edges = Array.from({ length: bins + 1 }, (_, i) => mn + i * step);
+    }
+    // Auto-computed edges may have floating-point duplicates for tiny ranges;
+    // silently drop them to avoid spurious errors.
+    edges = deduplicateEdges(edges, "drop");
+    if (edges.length < 2) {
+      throw new Error("Cannot cut constant array (all values identical).");
+    }
   } else {
     if (bins.length < 2) {
       throw new Error("At least 2 bin edges must be supplied.");

src/stats/numeric_extended.ts

@@ -144,9 +144,12 @@ export function digitize(
     const n = bins.length;
     if (right) {
       // open left, closed right: bins[i-1] < v <= bins[i]
+      if (v < (bins[0] as number)) {
+        return -1;
+      }
       for (let i = 0; i < n; i++) {
         if (v <= (bins[i] as number)) {
-          return i - 1; // below first edge → -1
+          return i;
         }
       }
       return n - 1; // above last edge
@@ -299,7 +302,13 @@ export function linspace(start: number, stop: number, num = 50): number[] {
   const step = (stop - start) / (num - 1);
   const result: number[] = [];
   for (let i = 0; i < num; i++) {
-    result.push(i === num - 1 ? stop : start + i * step);
+    if (i === num - 1) {
+      result.push(stop);
+    } else if (i === 0) {
+      result.push(start);
+    } else {
+      result.push(start + i * step);
+    }
   }
   return result;
 }

src/stats/string_ops_extended.ts

@@ -184,7 +184,11 @@ export function strExtractGroups(
     });
   });
 
-  const width = rows.reduce((w, r) => Math.max(w, r.length), 0);
+  const numGroups = countCaptureGroups(re);
+  const width = Math.max(
+    rows.reduce((w, r) => Math.max(w, r.length), 0),
+    numGroups,
+  );
 
   // Use named groups if available and count matches; otherwise use 0-indexed strings.
   const colNames: string[] =
@@ -205,6 +209,21 @@ export function strExtractGroups(
   return DataFrame.fromColumns(columns, { index: rowIndex(input) });
 }
 
+/** Count the number of capture groups in a regex (excluding non-capturing groups). */
+function countCaptureGroups(re: RegExp): number {
+  let count = 0;
+  const src = re.source;
+  for (let i = 0; i < src.length; i++) {
+    const ch = src[i];
+    if (ch === "\\") {
+      i++; // skip escaped char
+    } else if (ch === "(" && src[i + 1] !== "?") {
+      count++;
+    }
+  }
+  return count;
+}
+
 /** Parse named capture group names from a regex source string. */
 function extractGroupNames(re: RegExp): string[] {
   const namedGroupPattern = /\(\?<([^>]+)>/g;

tests/core/to_from_dict.test.ts

@@ -259,6 +259,7 @@ describe("property-based", () => {
         fc.array(fc.integer({ min: 1, max: 10 }), { minLength: 1, maxLength: 4 }),
         fc.array(fc.integer({ min: 1, max: 10 }), { minLength: 1, maxLength: 4 }),
         (colA, colB) => {
+          if (colB.length < colA.length) return true;
           const df = DataFrame.fromColumns({ a: colA, b: colB.slice(0, colA.length) });
           const split = toDictOriented(df, "split");
           const df2 = fromDictOriented(split, "split");

tests/reshape/wide_to_long.test.ts

@@ -134,10 +134,10 @@ describe("wideToLong — multiple id columns", () => {
 
 describe("wideToLong — missing stub columns", () => {
   test("missing wide column fills with null", () => {
-    // A1 exists but A2 does not — A2 values should be null
-    const df = DataFrame.fromColumns({ id: [1], A1: [10] });
-    const long = wideToLong(df, "A", "id", "n", { suffix: "[12]" });
-    // suffix 1 → A1=10, suffix 2 → A2=null
+    // A1 and B1/B2 exist; A2 does not — A2 values should be null
+    const df = DataFrame.fromColumns({ id: [1], A1: [10], B1: [20], B2: [30] });
+    const long = wideToLong(df, ["A", "B"], "id", "n", { suffix: "[12]" });
+    // suffix "2" discovered from B2; A2 missing → null
     expect(long.col("A").values).toEqual([10, null]);
   });
 });
@@ -200,8 +200,14 @@ describe("property-based", () => {
           const df = DataFrame.fromColumns(colData);
           const long = wideToLong(df, "v", "id", "n");
           const outId = long.col("id").values;
-          // Each original id value should appear nSuffix times
-          return idVals.every((v) => outId.filter((x) => x === v).length === nSuffix);
+          // Total row count should be originalRows × nSuffix
+          if (outId.length !== idVals.length * nSuffix) return false;
+          // Each unique id value appears (its original count × nSuffix) times
+          const uniqueIds = [...new Set(idVals)];
+          return uniqueIds.every((v) => {
+            const origCount = idVals.filter((x) => x === v).length;
+            return outId.filter((x) => x === v).length === origCount * nSuffix;
+          });
         },
       ),
     );

tests/stats/numeric_extended.test.ts

@@ -312,7 +312,7 @@ describe("zscore", () => {
     // ddof=0 produces smaller values (divided by larger std denominator)
     const range0 = Math.max(...z0) - Math.min(...z0);
     const range1 = Math.max(...z1) - Math.min(...z1);
-    expect(range0).toBeLessThan(range1);
+    expect(range0).toBeGreaterThan(range1);
   });
 
   it("preserves index labels", () => {

tests/stats/string_ops_extended.test.ts

@@ -411,7 +411,7 @@ describe("strDedent — property tests", () => {
     fc.assert(
       fc.property(
         fc.array(
-          fc.string({ minLength: 1 }).filter((s) => !s.includes("\n")),
+          fc.string({ minLength: 1 }).filter((s) => !s.includes("\n") && s.trim().length > 0 && s.trimStart() === s),
           {
             minLength: 1,
             maxLength: 5,

tests/stats/window_extended.test.ts

@@ -133,7 +133,7 @@ describe("rollingSkew", () => {
   });
 
   it("left-skewed data → negative skew", () => {
-    const out = vals(rollingSkew(s([10, 2, 1]), 3));
+    const out = vals(rollingSkew(s([1, 9, 10]), 3));
     const v = out[2];
     expect(typeof v).toBe("number");
     expect((v as number) < 0).toBe(true);
@@ -221,7 +221,7 @@ describe("rollingQuantile", () => {
     expect(close(out[2] as number, 1)).toBe(true);
     expect(close(out[3] as number, 1)).toBe(true);
     expect(close(out[4] as number, 1)).toBe(true);
-    expect(close(out[5] as number, 5)).toBe(true);
+    expect(close(out[5] as number, 1)).toBe(true);
   });
 
   it("q=1 is rolling maximum", () => {