feat: implement filtering and selection methods

- Added methods for column selection: select, drop, selectByPattern
- Added methods for row filtering: filter, query, where
- Added methods for row selection: at, iloc, loc
- Added methods for sampling: sample, stratifiedSample
- Created comprehensive test suite for all new methods
- Fixed Excel reader syntax error
- Applied code formatting according to project standards

Author: a3ka

.gitignore

@@ -49,5 +49,6 @@ coverage/
 
 TODO.md
 CONTEXT*
-todo*
-todo.md
+#todo*
+#todo.md
+#TODO.md

output.csv

@@ -0,0 +1,3 @@
+date,open,high,low,close,volume
+2023-01-01,100.5,105.75,99.25,103.5,1000000
+2023-01-02,103.75,108.25,102.5,107.25,1500000

output.tsv

@@ -0,0 +1,3 @@
+date	open	high	low	close	volume
+2023-01-01	100.5	105.75	99.25	103.5	1000000
+2023-01-02	103.75	108.25	102.5	107.25	1500000

src/methods/filtering/at.js

@@ -0,0 +1,37 @@
+// src/methods/filtering/at.js
+
+/**
+ * Creates a function that selects a row from a DataFrame by its index.
+ *
+ * @param {Object} deps - Dependencies
+ * @returns {Function} Function that selects a row by index
+ */
+export const at = (deps) => (frame, index) => {
+  // Validate input
+  if (typeof index !== 'number' || !Number.isInteger(index)) {
+    throw new Error('Index must be an integer');
+  }
+
+  if (index < 0) {
+    throw new Error('Index must be non-negative');
+  }
+
+  // Get all column names
+  const columns = Object.keys(frame.columns);
+
+  // Get the number of rows
+  const rowCount = frame.columns[columns[0]]?.length || 0;
+
+  if (index >= rowCount) {
+    throw new Error(`Index ${index} is out of bounds (0-${rowCount - 1})`);
+  }
+
+  // Create an object with values from the specified row
+  const result = {};
+
+  columns.forEach((column) => {
+    result[column] = frame.columns[column][index];
+  });
+
+  return result;
+};

src/methods/filtering/drop.js

@@ -0,0 +1,37 @@
+// src/methods/filtering/drop.js
+
+/**
+ * Creates a function that removes specific columns from a DataFrame.
+ *
+ * @param {Object} deps - Dependencies
+ * @param {Function} deps.validateColumn - Function to validate column names
+ * @returns {Function} Function that removes columns from a DataFrame
+ */
+export const drop =
+  ({ validateColumn }) =>
+  (frame, columns) => {
+    // Validate input
+    if (!Array.isArray(columns)) {
+      throw new Error('Columns must be an array');
+    }
+
+    // Validate each column exists in the frame
+    columns.forEach((column) => validateColumn(frame, column));
+
+    // Create a new frame without the specified columns
+    const result = {
+      columns: {},
+    };
+
+    // Get all column names
+    const allColumns = Object.keys(frame.columns);
+
+    // Add only columns that are not in the drop list
+    allColumns.forEach((column) => {
+      if (!columns.includes(column)) {
+        result.columns[column] = frame.columns[column];
+      }
+    });
+
+    return result;
+  };

src/methods/filtering/filter.js

@@ -0,0 +1,57 @@
+// src/methods/filtering/filter.js
+
+/**
+ * Creates a function that filters rows in a DataFrame based on a condition.
+ *
+ * @param {Object} deps - Dependencies
+ * @returns {Function} Function that filters rows in a DataFrame
+ */
+export const filter = (deps) => (frame, condition) => {
+  // Validate input
+  if (typeof condition !== 'function') {
+    throw new Error('Condition must be a function');
+  }
+
+  // Get all column names and create a new frame
+  const columns = Object.keys(frame.columns);
+  const result = {
+    columns: {},
+  };
+
+  // Initialize empty arrays for each column
+  columns.forEach((column) => {
+    result.columns[column] = [];
+  });
+
+  // Get the number of rows
+  const rowCount = frame.columns[columns[0]]?.length || 0;
+
+  // Apply the filter condition to each row
+  for (let i = 0; i < rowCount; i++) {
+    // Create a row object for the condition function
+    const row = {};
+    columns.forEach((column) => {
+      row[column] = frame.columns[column][i];
+    });
+
+    // Check if the row passes the condition
+    if (condition(row)) {
+      // Add the row to the result
+      columns.forEach((column) => {
+        result.columns[column].push(frame.columns[column][i]);
+      });
+    }
+  }
+
+  // Convert arrays to typed arrays if the original columns were typed
+  columns.forEach((column) => {
+    const originalArray = frame.columns[column];
+    if (originalArray instanceof Float64Array) {
+      result.columns[column] = new Float64Array(result.columns[column]);
+    } else if (originalArray instanceof Int32Array) {
+      result.columns[column] = new Int32Array(result.columns[column]);
+    }
+  });
+
+  return result;
+};

src/methods/filtering/iloc.js

@@ -0,0 +1,81 @@
+// src/methods/filtering/iloc.js
+
+/**
+ * Creates a function that selects rows and columns by their integer positions.
+ *
+ * @param {Object} deps - Dependencies
+ * @returns {Function} Function that selects rows and columns by integer positions
+ */
+export const iloc = (deps) => (frame, rowIndices, columnIndices) => {
+  // Validate input
+  if (!Array.isArray(rowIndices)) {
+    rowIndices = [rowIndices];
+  }
+
+  if (!Array.isArray(columnIndices)) {
+    columnIndices = [columnIndices];
+  }
+
+  // Validate that all indices are numbers
+  if (!rowIndices.every((idx) => typeof idx === 'number' && idx >= 0)) {
+    throw new Error('Row indices must be non-negative numbers');
+  }
+
+  if (!columnIndices.every((idx) => typeof idx === 'number' && idx >= 0)) {
+    throw new Error('Column indices must be non-negative numbers');
+  }
+
+  // Get all column names
+  const allColumns = Object.keys(frame.columns);
+
+  // Get the number of rows
+  const rowCount = frame.columns[allColumns[0]]?.length || 0;
+
+  // Check if row indices are valid
+  const maxRowIndex = Math.max(...rowIndices);
+  if (maxRowIndex >= rowCount) {
+    throw new Error(
+      `Row index ${maxRowIndex} is out of bounds (0-${rowCount - 1})`,
+    );
+  }
+
+  // Check if column indices are valid
+  const maxColumnIndex = Math.max(...columnIndices);
+  if (maxColumnIndex >= allColumns.length) {
+    throw new Error(
+      `Column index ${maxColumnIndex} is out of bounds (0-${allColumns.length - 1})`,
+    );
+  }
+
+  // Map column indices to column names
+  const selectedColumns = columnIndices.map((idx) => allColumns[idx]);
+
+  // Create a new frame with selected rows and columns
+  const result = {
+    columns: {},
+  };
+
+  // Initialize columns in the result
+  selectedColumns.forEach((column) => {
+    result.columns[column] = [];
+  });
+
+  // Add selected rows to the result
+  rowIndices.forEach((rowIdx) => {
+    selectedColumns.forEach((column) => {
+      result.columns[column].push(frame.columns[column][rowIdx]);
+    });
+  });
+
+  // Convert arrays to typed arrays if the original columns were typed
+  selectedColumns.forEach((column) => {
+    const originalArray = frame.columns[column];
+    if (originalArray instanceof Float64Array) {
+      result.columns[column] = new Float64Array(result.columns[column]);
+    } else if (originalArray instanceof Int32Array) {
+      result.columns[column] = new Int32Array(result.columns[column]);
+    }
+  });
+
+  return result;
+};

src/methods/filtering/index.js

@@ -0,0 +1,13 @@
+// src/methods/filtering/index.js
+
+export { select } from './select.js';
+export { drop } from './drop.js';
+export { selectByPattern } from './selectByPattern.js';
+export { filter } from './filter.js';
+export { query } from './query.js';
+export { where } from './where.js';
+export { at } from './at.js';
+export { iloc } from './iloc.js';
+export { loc } from './loc.js';
+export { sample } from './sample.js';
+export { stratifiedSample } from './stratifiedSample.js';

src/methods/filtering/loc.js

@@ -0,0 +1,69 @@
+// src/methods/filtering/loc.js
+
+/**
+ * Creates a function that selects rows and columns by their labels.
+ *
+ * @param {Object} deps - Dependencies
+ * @param {Function} deps.validateColumn - Function to validate column names
+ * @returns {Function} Function that selects rows and columns by labels
+ */
+export const loc =
+  ({ validateColumn }) =>
+  (frame, rowIndices, columnNames) => {
+    // Validate input
+    if (!Array.isArray(rowIndices)) {
+      rowIndices = [rowIndices];
+    }
+
+    if (!Array.isArray(columnNames)) {
+      columnNames = [columnNames];
+    }
+
+    // Validate that all row indices are numbers
+    if (!rowIndices.every((idx) => typeof idx === 'number' && idx >= 0)) {
+      throw new Error('Row indices must be non-negative numbers');
+    }
+
+    // Validate that all column names exist
+    columnNames.forEach((column) => validateColumn(frame, column));
+
+    // Get the number of rows
+    const rowCount = frame.columns[columnNames[0]]?.length || 0;
+
+    // Check if row indices are valid
+    const maxRowIndex = Math.max(...rowIndices);
+    if (maxRowIndex >= rowCount) {
+      throw new Error(
+        `Row index ${maxRowIndex} is out of bounds (0-${rowCount - 1})`,
+      );
+    }
+
+    // Create a new frame with selected rows and columns
+    const result = {
+      columns: {},
+    };
+
+    // Initialize columns in the result
+    columnNames.forEach((column) => {
+      result.columns[column] = [];
+    });
+
+    // Add selected rows to the result
+    rowIndices.forEach((rowIdx) => {
+      columnNames.forEach((column) => {
+        result.columns[column].push(frame.columns[column][rowIdx]);
+      });
+    });
+
+    // Convert arrays to typed arrays if the original columns were typed
+    columnNames.forEach((column) => {
+      const originalArray = frame.columns[column];
+      if (originalArray instanceof Float64Array) {
+        result.columns[column] = new Float64Array(result.columns[column]);
+      } else if (originalArray instanceof Int32Array) {
+        result.columns[column] = new Int32Array(result.columns[column]);
+      }
+    });
+
+    return result;
+  };