Fix filtered aggregate row count.

src/verbs/reduce/util.js

@@ -67,20 +67,21 @@ export function reduceFlat(table, reducer) {
   // compute aggregate values
   // inline the following for performance:
   // table.scan((row, data) => reducer.add(cell, row, data));
-  const n = table.totalRows();
   const data = table.data();
   const bits = table.mask();
 
   if (table.isOrdered()) {
     const idx = table.indices();
-    for (let i = 0; i < n; ++i) {
+    const m = idx.length;
+    for (let i = 0; i < m; ++i) {
       reducer.add(cell, idx[i], data);
     }
   } else if (bits) {
     for (let i = bits.next(0); i >= 0; i = bits.next(i + 1)) {
       reducer.add(cell, i, data);
     }
   } else {
+    const n = table.totalRows();
     for (let i = 0; i < n; ++i) {
       reducer.add(cell, i, data);
     }

test/verbs/rollup-test.js

@@ -40,6 +40,26 @@ describe('rollup', () => {
     }, 'rollup data');
   });
 
+  it('produces filtered grouped aggregates', () => {
+    const data = {
+      k: ['a', 'a', 'b', 'b'],
+      a: [1, 3, 5, 7],
+      b: [2, 4, 6, 8]
+    };
+
+    const rt = table(data)
+      .groupby({ key: d => d.k })
+      .filter(d => d.a === 1)
+      .rollup({ cnt: op.count() });
+
+    assert.equal(rt.numRows(), 1, 'num rows');
+    assert.equal(rt.numCols(), 2, 'num cols');
+    tableEqual(rt, {
+      key: ['a'],
+      cnt: [1]
+    }, 'rollup data');
+  });
+
   it('handles empty tables', () => {
     [[], [null, null], [undefined, undefined], [NaN, NaN]].forEach(v => {
       const rt = table({ v }).rollup({

test/verbs/slice-test.js

@@ -82,4 +82,29 @@ describe('slice', () => {
       'sliced data, extreme negative start and end'
     );
   });
+
+  it('slices a grouped, ordered, and filtered table', () => {
+    const dt = table({ a: [1, 1], b: [2, 3], c: [3, 4] })
+      .groupby('a')
+      .orderby('b')
+      .filter(d => d.c === 3);
+
+    tableEqual(
+      dt.slice(),
+      { a: [1], b: [2], c: [3] },
+      'sliced data, all'
+    );
+
+    tableEqual(
+      dt.slice(0, 1),
+      { a: [1], b: [2], c: [3] },
+      'sliced data, start and end'
+    );
+
+    tableEqual(
+      dt.slice(-1),
+      { a: [1], b: [2], c: [3] },
+      'sliced data, negative start'
+    );
+  });
 });