als-statistics/tests/statistics.test.js

A powerful and lightweight JavaScript library for descriptive statistics, regression, clustering, outlier detection, and noise analysis using a flexible table/column architecture.

const { describe, it } = require('node:test');
const assert = require('node:assert');
const Statistics = require('../index');
const Table = require('../lib/table/index');
const RatioColumn = require('../lib/ratio-column/index');
const Column = require('../lib/column/index');

describe('Statistics class', () => {
   it('should create an empty Statistics instance', () => {
      const stats = new Statistics();
      assert.deepStrictEqual(stats.tables, {});
   });

   it('should add tables', () => {
      const stats = new Statistics();
      const table = stats.addTable('TestTable');

      assert.strictEqual(Object.keys(stats.tables).length, 1);
      assert(stats.tables['TestTable'] instanceof Table);
   });

   it('should apply and clear filters to all tables', () => {
      const stats = new Statistics();
      const table1 = stats.addTable('Table1');
      const table2 = stats.addTable('Table2');

      table1.addColumn('Numbers', [10, 20, 30, 40]);
      table2.addColumn('Numbers', [100, 200, 300, 400]);

      stats.filterRows([1, 2]);
      assert.deepStrictEqual(table1.filtered, { 1: true, 2: true });
      assert.deepStrictEqual(table2.filtered, { 1: true, 2: true });

      stats.clearAllRowsFilters();
      assert.deepStrictEqual(table1.filtered, {});
      assert.deepStrictEqual(table2.filtered, {});
   });

   it('should compute descriptive statistics for all tables', () => {
      const stats = new Statistics();
      const table = stats.addTable('TestTable');
      table.addColumn('Numbers', [10, 20, 30, 40, 50]);

      const descTable = stats.descriptive('mean');
      assert(descTable instanceof Table);
      assert.strictEqual(descTable.n, 1);
      assert.strictEqual(descTable.columns['TestTable'].values[0], 30);
   });

   it('should transpose all tables', () => {
      const stats = new Statistics();
      const table = stats.addTable('TestTable');
      table.addColumn('Numbers', [10, 20, 30]);

      const transposedStats = stats.transpose();
      assert(transposedStats instanceof Statistics);
      assert.strictEqual(Object.keys(transposedStats.tables).length, 1);
   });

   it('should clear all filters across all tables', () => {
      const stats = new Statistics();
      const table1 = stats.addTable('Table1');
      const table2 = stats.addTable('Table2');

      table1.addColumn('Numbers', [10, 20, 30, 40]);
      table2.addColumn('Numbers', [100, 200, 300, 400]);

      stats.filterRows([1, 2]);
      stats.clearAllRowsFilters();
      assert.deepStrictEqual(table1.filtered, {});
      assert.deepStrictEqual(table2.filtered, {});
   });

   it('should transpose tables with correct naming', () => {
      const stats = new Statistics();
      const table = stats.addTable('TestTable');
      table.addColumn('Numbers', [10, 20, 30]);

      const transposedStats = stats.transpose();
      assert.strictEqual(Object.keys(transposedStats.tables)[0], 'TestTable_transposed');
      assert(transposedStats.tables['TestTable_transposed'] instanceof Table);
   });
});


describe('Statistics class static methods', () => {
   it('should access static statistics instance', () => {
      const stats = Statistics.statistics;
      assert(stats instanceof Statistics);
   });
   
   it('should create table via static method', () => {
      const table = Statistics.newTable();
      assert(table instanceof Table);
   });

   it('should create column via static method', () => {
      const column = Statistics.newColumn([1, 2, 3]);
      assert(column instanceof Object);
      assert.deepStrictEqual(column.values, [1, 2, 3]);
   });

   it('should generate range via static method', () => {
      const r = Statistics.range(1, 5);
      assert.deepStrictEqual(r, [1, 2, 3, 4]);
   });
});

describe('Statistics class - New Features', () => {
   it('should create new table with data using Statistics.newTable', () => {
      const data = {
         Values: [1, 2, 3],
         Names: ['X', 'Y', 'Z']
      };
      const table = Statistics.newTable(data);
      
      assert.ok(table instanceof Table);
      assert.strictEqual(table.n, 3);
      assert.strictEqual(table.columnsN, 2);
      assert.ok(table.columns['Values'] instanceof RatioColumn);
      assert.ok(table.columns['Names'] instanceof Column);
      assert.deepStrictEqual(table.columns['Values'].values, [1, 2, 3]);
      assert.deepStrictEqual(table.columns['Names'].values, ['X', 'Y', 'Z']);
   });
});