gaslamp v0.27.0 Release Notes

• Released: 2025-09-13
• gaslamp: 66 - v0.27.0
• pilotlamp: 23 - v0.27.0

🚨 BREAKING CHANGES

💥 Series Module Removal

Complete removal of Series class and all related functionality - Streamlined codebase by removing redundant Series implementation:

• Series Class Deleted: The Series class has been completely removed from the codebase
• Related Components Removed: All Series-related format strategies and utilities have been deleted
• Import Changes: Direct imports referencing Series are no longer supported
• Migration Required: Users must migrate to DataFrame-based column operations

TypeScript

// Before: Series-based operations (NO LONGER SUPPORTED)
import { Series } from 'gaslamp';
const series = new Series([1, 2, 3, 4]);

// After: DataFrame-based column operations
import { DataFrame } from 'gaslamp';
const df = new DataFrame().fromArrays([
  ['values'],
  [1], [2], [3], [4]
]);
const column = df.getColumn('values');

📦 Module Structure Reorganization

Consolidation of grouping and analysis modules - Improved module organization for better maintainability:

• Grouping Module Consolidation: analysis/grouping and analysis/grouped-dataframe consolidated into dataframe/group
• Analysis Module Restructure: Direct imports from old analysis paths no longer supported
• JestLite Import Changes: Direct imports from torch/jestlite no longer supported, use main module exports

TypeScript

// Before: Old import paths (NO LONGER SUPPORTED)
import { GroupedDataFrame } from 'gaslamp/analysis/grouped-dataframe';
import { JestLite } from 'gaslamp/torch/jestlite';

// After: New consolidated imports
import { GroupedDataFrame, JestLite } from 'gaslamp';
// or
import { GroupedDataFrame } from 'gaslamp/torch';

🚀 Enhanced Features

📊 Advanced Statistical Functions for GroupedDataFrame

Powerful statistical analysis capabilities - Added comprehensive statistical functions to GroupedDataFrame:

• Statistical Function Library: New statistical methods for advanced data analysis
• GroupedDataFrame Integration: Seamless integration with existing grouping functionality
• Enhanced Analytics: Support for complex statistical calculations on grouped data
• Performance Optimized: Efficient statistical computations with minimal overhead

TypeScript

// Advanced statistical operations on grouped data
const df = new DataFrame().fromArrays([
  ['category', 'value', 'score'],
  ['A', 100, 85],
  ['B', 150, 92],
  ['A', 120, 88],
  ['B', 180, 95]
]);

const grouped = df.groupBy('category');

// New statistical functions available
const stats = grouped.agg({
  'value': 'mean',        // Enhanced with statistical accuracy
  'score': 'std',         // Standard deviation support
  'count': 'count'        // Improved counting logic
});

🐛 Bug Fixes & Improvements

🔧 DataFrame Row Access Unification

Consistent Map.get() usage in withColumn operations - Fixed inconsistent row access patterns:

• Unified Access Pattern: All withColumn operations now use Map.get() consistently
• Type Safety Improvement: Better type safety for row data access
• Performance Consistency: Standardized access pattern improves performance predictability
• Error Handling: Improved error handling for undefined column access

TypeScript

// Fixed: Consistent row access in withColumn operations
const df = new DataFrame().fromArrays([
  ['name', 'age'],
  ['Alice', 25],
  ['Bob', 30]
]);

// Now works consistently across all scenarios
const result = df.withColumn('ageGroup', (row) => {
  const age = row.get('age'); // ✅ Consistent Map.get() usage
  return age > 25 ? 'Senior' : 'Junior';
});

🧪 Enhanced Test Coverage and API Usage

Improved pilotlamp test suite - Fixed DataFrame API usage and enhanced Torch module examples:

• API Usage Fixes: Corrected DataFrame API calls in test files
• Enhanced Examples: Better examples demonstrating Torch module capabilities
• Type Annotations: Added proper type annotations for GroupedDataFrame operations
• Test Reliability: Improved test reliability and consistency

🏗️ Architecture Improvements

🗂️ Streamlined Module Structure

Cleaner codebase architecture - Removed redundant components and improved module organization:

• Series Removal: Eliminated redundant Series class reducing codebase complexity
• Format Strategy Cleanup: Removed Series-specific format strategies
• Import Path Simplification: Consolidated import paths for better developer experience
• Module Boundary Clarity: Clearer separation between different functional modules

📁 Consolidated Grouping Architecture

Unified grouping functionality - All grouping-related functionality now centralized:

• Single Grouping Module: All GroupedDataFrame functionality in dataframe/group
• Consistent API: Unified API surface for grouping operations
• Better Maintainability: Easier to maintain with consolidated structure
• Reduced Complexity: Simplified module dependencies

🔍 Technical Implementation Details

Series Module Removal Implementation

Complete removal of Series ecosystem - Systematic cleanup of Series-related code:

TypeScript

// Removed components:
// - src/torch/series/
// - Series class implementation
// - SeriesColumnFormatStrategy
// - SeriesRowFormatStrategy
// - All Series-related tests
// - Series exports from index files

// Migration pattern for existing Series usage:
// Before (removed):
const series = new Series([1, 2, 3]);
const mean = series.mean();

// After (DataFrame columns):
const df = new DataFrame().fromArrays([['values'], [1], [2], [3]]);
const values = df.getColumn('values');
const mean = values.reduce((a, b) => a + b) / values.length;

GroupedDataFrame Statistical Enhancement

Enhanced statistical capabilities - Improved statistical functions with better accuracy:

TypeScript

// Enhanced statistical implementation
class GroupedDataFrame {
  // Improved statistical accuracy
  private calculateStatistics(values: number[]): StatisticalResult {
    const n = values.length;
    const sum = values.reduce((a, b) => a + b, 0);
    const mean = sum / n;

    // Enhanced variance calculation
    const variance = values.reduce((acc, val) => acc + Math.pow(val - mean, 2), 0) / n;
    const standardDeviation = Math.sqrt(variance);

    return { mean, variance, standardDeviation };
  }
}

Map.get() Unification Implementation

Consistent row access pattern - Standardized all withColumn operations:

TypeScript

// Unified row access implementation
withColumn(columnName: string, fn: (row: Map<string, unknown>) => unknown): DataFrame {
  const newData = new Map<string, unknown[]>();

  // Initialize existing columns
  for (const [key, values] of this.data.entries()) {
    newData.set(key, [...values]);
  }

  // Process each row with consistent Map.get() access
  const newColumnValues: unknown[] = [];
  for (let i = 0; i < this.length; i++) {
    const row = new Map<string, unknown>();

    // Consistent Map.get() pattern throughout
    for (const header of this.headers) {
      const columnData = this.data.get(header);
      row.set(header, columnData?.[i]);
    }

    const newValue = fn(row); // ✅ Always receives Map with get() method
    newColumnValues.push(newValue);
  }

  newData.set(columnName, newColumnValues);
  return new DataFrame().fromMap(newData);
}

🚀 Migration Guide

Migrating from Series to DataFrame Columns

Complete migration required - Series functionality must be replaced with DataFrame operations:

TypeScript

// Before: Series usage (NO LONGER AVAILABLE)
import { Series } from 'gaslamp';

const series = new Series([1, 2, 3, 4, 5]);
const mean = series.mean();
const filtered = series.filter(x => x > 2);

// After: DataFrame column operations
import { DataFrame } from 'gaslamp';

const df = new DataFrame().fromArrays([
  ['values'],
  [1], [2], [3], [4], [5]
]);

// Column operations
const values = df.getColumn('values');
const mean = values.reduce((a, b) => a + b, 0) / values.length;

// DataFrame filtering
const filtered = df.filter((row) => {
  const value = row.get('values');
  return typeof value === 'number' && value > 2;
});

Updating Import Statements

Module import updates required - Update all import statements to use new paths:

TypeScript

// Before: Old import paths (NO LONGER SUPPORTED)
import { Series } from 'gaslamp';
import { GroupedDataFrame } from 'gaslamp/analysis/grouped-dataframe';
import { JestLite } from 'gaslamp/torch/jestlite';

// After: Updated import paths
import { DataFrame, GroupedDataFrame, JestLite } from 'gaslamp';

// Or specific module imports
import { DataFrame } from 'gaslamp/torch';
import { GroupedDataFrame } from 'gaslamp/torch';

Leveraging Enhanced Statistical Functions

Upgrade to advanced statistics - Take advantage of improved statistical capabilities:

TypeScript

// Enhanced statistical analysis
const salesData = new DataFrame().fromArrays([
  ['region', 'sales', 'profit'],
  ['North', 1000, 200],
  ['South', 1500, 300],
  ['North', 1200, 240],
  ['South', 1800, 360]
]);

const grouped = salesData.groupBy('region');

// Advanced statistical aggregation
const statistics = grouped.agg({
  'sales': 'mean',        // ✅ Enhanced accuracy
  'profit': 'std',        // ✅ New statistical functions
  'count': 'count'        // ✅ Improved counting
});

🧪 Testing & Quality

Comprehensive Breaking Change Testing

• ✅ Series Removal Validation: Confirmed all Series references removed from codebase
• ✅ Import Path Testing: Verified all new import paths work correctly
• ✅ Migration Path Testing: Tested DataFrame-based alternatives for all Series functionality
• ✅ GroupedDataFrame Enhancement Testing: Validated new statistical functions work correctly
• ✅ withColumn Consistency Testing: Verified consistent Map.get() usage across all scenarios

Quality Assurance

• ✅ Breaking Change Documentation: Complete documentation of all breaking changes with migration examples
• ✅ Backward Compatibility: Clear identification of incompatible changes with migration paths
• ✅ Performance Validation: Confirmed performance improvements from codebase streamlining
• ✅ Type Safety: Enhanced TypeScript typing throughout refactored modules

👥 Contributors

• @shotakaha - Series module removal, module structure consolidation, Map.get() unification, enhanced statistical functions, comprehensive testing and migration documentation

🔗 Links

• Documentation: https://gaslamp.readthedocs.io/
• Repository: https://gitlab.com/qumasan/gaslamp

---

Full Changelog: v0.26.0...v0.27.0