Fix pre-existing test failures: digitize, zscore, linspace, cut, rollingApply, rollingQuantile, rollingSkew, strExtractGroups, to_from_dict

Source fixes:
- digitize: fix right=true bin assignment (return i not i-1 for matching edge)
- strExtractGroups: determine column count from regex groups, not just matches
  (fixes empty DataFrame when no rows match the pattern)

Test fixes:
- zscore ddof=0: population std is smaller → z-scores are larger (flip comparison)
- linspace: use toEqual instead of toBe for -0 vs 0 handling
- cut right=false: bin boundary [0.998, 3) puts v=3 in bin 1 not bin 0
- rollingApply min: window [1,5,9] min is 1 not 5
- rollingApply count: window [null,3,null] has 1 valid value not 2
- rollingQuantile q=0: last window [1,5,9] min is 1 not 5
- rollingSkew: [10,2,1] is right-skewed; use [1,9,10] for left-skewed
- to_from_dict split: ensure property test columns have same length

Agent-Logs-Url: https://github.com/githubnext/tsessebe/sessions/93a0148a-3bf6-4490-a4b9-f52f8d6a89e5

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

Author: Copilot

src/stats/numeric_extended.ts

@@ -145,8 +145,11 @@ export function digitize(
     if (right) {
       // open left, closed right: bins[i-1] < v <= bins[i]
       for (let i = 0; i < n; i++) {
-        if (v <= (bins[i] as number)) {
-          return i - 1; // below first edge → -1
+        if (v < (bins[i] as number)) {
+          return i - 1; // below edge i → bin i-1
+        }
+        if (v === (bins[i] as number)) {
+          return i; // exactly at edge i → bin i (right-inclusive)
         }
       }
       return n - 1; // above last edge

src/stats/string_ops_extended.ts

@@ -170,22 +170,27 @@ export function strExtractGroups(
   const groupNames = extractGroupNames(re);
   const vals = toValues(input);
 
+  // Determine number of capture groups by adding an empty-string alternative.
+  // This always matches, and (matchResult.length - 1) gives the group count.
+  const groupCountMatch = new RegExp(`${re.source}|`).exec("");
+  const groupCount = groupCountMatch !== null ? groupCountMatch.length - 1 : 0;
+
   const rows: (string | null)[][] = vals.map((v) => {
     const s = toStrOrNull(v);
     if (s === null) {
-      return [];
+      return Array.from({ length: groupCount }, (): null => null);
     }
     const m = re.exec(s);
     if (m === null) {
-      return [];
+      return Array.from({ length: groupCount }, (): null => null);
     }
     return Array.from({ length: m.length - 1 }, (_, i) => {
       const captured = m[i + 1];
       return captured !== undefined ? captured : null;
     });
   });
 
-  const width = rows.reduce((w, r) => Math.max(w, r.length), 0);
+  const width = groupCount > 0 ? groupCount : rows.reduce((w, r) => Math.max(w, r.length), 0);
 
   // Use named groups if available and count matches; otherwise use 0-indexed strings.
   const colNames: string[] =

tests/core/to_from_dict.test.ts

@@ -250,7 +250,9 @@ 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) => {
-          const df = DataFrame.fromColumns({ a: colA, b: colB.slice(0, colA.length) });
+          // Ensure both columns have the same length
+          const len = Math.min(colA.length, colB.length);
+          const df = DataFrame.fromColumns({ a: colA.slice(0, len), b: colB.slice(0, len) });
           const split = toDictOriented(df, "split");
           const df2 = fromDictOriented(split, "split");
           return df2.shape[0] === df.shape[0] && df2.columns.values[0] === "a";

tests/stats/cut_qcut.test.ts

@@ -24,10 +24,10 @@ describe("cut — integer bins", () => {
 
   it("right=false uses left-closed intervals", () => {
     const { codes, labels } = cut([1, 2, 3, 4, 5], 2, { right: false });
-    // [lo, hi)
+    // [lo, hi) — bin 0 is [min-ε, 3), bin 1 is [3, 5]
     expect(labels[0]).toMatch(/^\[/);
     expect(labels[0]).toMatch(/\)$/);
-    expect(codes).toEqual([0, 0, 0, 1, 1]);
+    expect(codes).toEqual([0, 0, 1, 1, 1]);
   });
 
   it("include_lowest labels the first bin with [ on both sides", () => {

tests/stats/numeric_extended.test.ts

@@ -309,10 +309,10 @@ describe("zscore", () => {
     const s = ns([1, 2, 3, 4, 5]);
     const z0 = vals(zscore(s, { ddof: 0 })).filter((v): v is number => typeof v === "number");
     const z1 = vals(zscore(s, { ddof: 1 })).filter((v): v is number => typeof v === "number");
-    // ddof=0 produces smaller values (divided by larger std denominator)
+    // ddof=0 divides by n (not n-1), producing smaller std → larger z-scores
     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", () => {
@@ -463,8 +463,9 @@ describe("property: linspace endpoints", () => {
         (start, stop, num) => {
           const r = linspace(start, stop, num);
           expect(r.length).toBe(num);
-          expect(r[0]).toBe(start);
-          expect(r.at(-1)).toBe(stop);
+          // Use toEqual to handle -0 === 0 correctly
+          expect(r[0]).toEqual(start);
+          expect(r.at(-1)).toEqual(stop);
         },
       ),
     );

tests/stats/window_extended.test.ts

@@ -133,7 +133,8 @@ describe("rollingSkew", () => {
   });
 
   it("left-skewed data → negative skew", () => {
-    const out = vals(rollingSkew(s([10, 2, 1]), 3));
+    // [1, 9, 10] has a long left tail (low outlier) → negative skewness
+    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 +222,8 @@ 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);
+    // window [1,5,9] → min is 1
+    expect(close(out[5] as number, 1)).toBe(true);
   });
 
   it("q=1 is rolling maximum", () => {

tests/window/rolling_apply.test.ts

@@ -94,7 +94,8 @@ describe("rollingApply", () => {
 
   test("custom min function", () => {
     const out = rollingApply(s(3, 1, 4, 1, 5, 9), 3, numMin);
-    expect(out.toArray()).toEqual([null, null, 1, 1, 1, 5]);
+    // window [1,5,9] → min is 1, not 5
+    expect(out.toArray()).toEqual([null, null, 1, 1, 1, 1]);
   });
 
   test("raw=true passes valid nums only (same as default)", () => {
@@ -143,9 +144,10 @@ describe("rollingApply", () => {
   });
 
   test("count function behaves correctly", () => {
-    const count = (nums: readonly number[]) => nums.length;
+    const count = (nums: readonly number[]): number => nums.length;
     const out = rollingApply(s(1, null, 3, null, 5), 3, count, { minPeriods: 1 });
-    expect(out.toArray()).toEqual([1, 1, 2, 2, 2]);
+    // window at i=3: [null,3,null] → valid=[3] → count=1
+    expect(out.toArray()).toEqual([1, 1, 2, 1, 2]);
   });
 
   test("range function over window", () => {