@obinexusmk2/hypernum 0.1.0 → 0.1.1

package/src/core/constants.ts

@@ -1,102 +1,102 @@
-/**
- * Core constants for Hypernum library
- * Defines fundamental values and limits used across the library
- */
-
-// Numerical limits
-export const MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
-export const MIN_SAFE_INTEGER = BigInt(Number.MIN_SAFE_INTEGER);
-export const MAX_PRECISION = 100;
-export const MAX_COMPUTATION_STEPS = 1000;
-export const MAX_BITS = 1024;
-
-// Commonly used values
-export const ZERO = BigInt(0);
-export const ONE = BigInt(1);
-export const TWO = BigInt(2);
-export const TEN = BigInt(10);
-export const NEGATIVE_ONE = BigInt(-1);
-
-// Power operation limits
-export const MAX_POWER_BASE = BigInt(2) ** BigInt(53);
-export const MAX_POWER_EXPONENT = BigInt(1000);
-export const MAX_TETRATION_HEIGHT = BigInt(4);
-export const MAX_FACTORIAL_INPUT = BigInt(1000);
-
-// Tree and heap configuration
-export const DEFAULT_TREE_MAX_DEPTH = 1000;
-export const DEFAULT_HEAP_INITIAL_CAPACITY = 16;
-export const DEFAULT_ARRAY_GROWTH_FACTOR = 2;
-export const MIN_ARRAY_CAPACITY = 16;
-
-// Formatting configuration
-export const DEFAULT_DECIMAL_SEPARATOR = '.';
-export const DEFAULT_GROUP_SEPARATOR = ',';
-export const DEFAULT_GROUP_SIZE = 3;
-export const MAX_GROUP_SIZE = 10;
-
-// Roman numeral limits
-export const MIN_ROMAN_VALUE = 1;
-export const MAX_ROMAN_VALUE = 3999;
-
-// Ackermann function limits
-export const MAX_ACKERMANN_M = 4;
-export const MAX_ACKERMANN_N = 1000;
-
-// Cache configuration
-export const DEFAULT_CACHE_SIZE = 1000;
-export const MAX_CACHE_SIZE = 10000;
-
-// Error messages
-export const ERROR_MESSAGES = {
-  OVERFLOW: 'Operation would result in overflow',
-  UNDERFLOW: 'Operation would result in underflow',
-  NEGATIVE_ROOT: 'Cannot compute root of negative number',
-  NEGATIVE_EXPONENT: 'Negative exponents not supported for integers',
-  DIVISION_BY_ZERO: 'Division by zero',
-  INVALID_PRECISION: 'Precision must be non-negative and not exceed MAX_PRECISION',
-  INVALID_BASE: 'Base must be a positive integer',
-  INVALID_ROMAN: 'Invalid Roman numeral',
-  COMPUTATION_LIMIT: 'Computation exceeded maximum allowed steps',
-  NEGATIVE_INDEX: 'Array index cannot be negative',
-  TREE_DEPTH_EXCEEDED: 'Maximum tree depth exceeded',
-  INVALID_HEAP_PROPERTY: 'Heap property violation detected'
-} as const;
-
-// Feature flags for optional functionality
-export const FEATURES = {
-  OVERFLOW_CHECKING: true,
-  AUTOMATIC_PRECISION: true,
-  MEMOIZATION: true,
-  TREE_BALANCING: true,
-  DEBUG_MODE: false
-} as const;
-
-// Default options for various operations
-export const DEFAULT_OPTIONS = {
-  precision: 0,
-  roundingMode: 'HALF_EVEN',
-  checkOverflow: true,
-  maxSteps: MAX_COMPUTATION_STEPS,
-  grouping: true,
-  uppercase: false,
-  cache: true
-} as const;
-
-// Units for number formatting (powers of 1000)
-export const NUMBER_UNITS = [
-  { value: 1n, symbol: '' },
-  { value: 1000n, symbol: 'K' },
-  { value: 1000000n, symbol: 'M' },
-  { value: 1000000000n, symbol: 'B' },
-  { value: 1000000000000n, symbol: 'T' },
-  { value: 1000000000000000n, symbol: 'Q' }
-] as const;
-
-// Performance monitoring thresholds
-export const PERFORMANCE = {
-  WARN_THRESHOLD_MS: 100,
-  ERROR_THRESHOLD_MS: 1000,
-  MAX_ARRAY_SIZE: 1000000,
-  MAX_TREE_SIZE: 1000000
+/**
+ * Core constants for Hypernum library
+ * Defines fundamental values and limits used across the library
+ */
+
+// Numerical limits
+export const MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
+export const MIN_SAFE_INTEGER = BigInt(Number.MIN_SAFE_INTEGER);
+export const MAX_PRECISION = 100;
+export const MAX_COMPUTATION_STEPS = 1000;
+export const MAX_BITS = 1024;
+
+// Commonly used values
+export const ZERO = BigInt(0);
+export const ONE = BigInt(1);
+export const TWO = BigInt(2);
+export const TEN = BigInt(10);
+export const NEGATIVE_ONE = BigInt(-1);
+
+// Power operation limits
+export const MAX_POWER_BASE = BigInt(2) ** BigInt(53);
+export const MAX_POWER_EXPONENT = BigInt(1000);
+export const MAX_TETRATION_HEIGHT = BigInt(4);
+export const MAX_FACTORIAL_INPUT = BigInt(1000);
+
+// Tree and heap configuration
+export const DEFAULT_TREE_MAX_DEPTH = 1000;
+export const DEFAULT_HEAP_INITIAL_CAPACITY = 16;
+export const DEFAULT_ARRAY_GROWTH_FACTOR = 2;
+export const MIN_ARRAY_CAPACITY = 16;
+
+// Formatting configuration
+export const DEFAULT_DECIMAL_SEPARATOR = '.';
+export const DEFAULT_GROUP_SEPARATOR = ',';
+export const DEFAULT_GROUP_SIZE = 3;
+export const MAX_GROUP_SIZE = 10;
+
+// Roman numeral limits
+export const MIN_ROMAN_VALUE = 1;
+export const MAX_ROMAN_VALUE = 3999;
+
+// Ackermann function limits
+export const MAX_ACKERMANN_M = 4;
+export const MAX_ACKERMANN_N = 1000;
+
+// Cache configuration
+export const DEFAULT_CACHE_SIZE = 1000;
+export const MAX_CACHE_SIZE = 10000;
+
+// Error messages
+export const ERROR_MESSAGES = {
+  OVERFLOW: 'Operation would result in overflow',
+  UNDERFLOW: 'Operation would result in underflow',
+  NEGATIVE_ROOT: 'Cannot compute root of negative number',
+  NEGATIVE_EXPONENT: 'Negative exponents not supported for integers',
+  DIVISION_BY_ZERO: 'Division by zero',
+  INVALID_PRECISION: 'Precision must be non-negative and not exceed MAX_PRECISION',
+  INVALID_BASE: 'Base must be a positive integer',
+  INVALID_ROMAN: 'Invalid Roman numeral',
+  COMPUTATION_LIMIT: 'Computation exceeded maximum allowed steps',
+  NEGATIVE_INDEX: 'Array index cannot be negative',
+  TREE_DEPTH_EXCEEDED: 'Maximum tree depth exceeded',
+  INVALID_HEAP_PROPERTY: 'Heap property violation detected'
+} as const;
+
+// Feature flags for optional functionality
+export const FEATURES = {
+  OVERFLOW_CHECKING: true,
+  AUTOMATIC_PRECISION: true,
+  MEMOIZATION: true,
+  TREE_BALANCING: true,
+  DEBUG_MODE: false
+} as const;
+
+// Default options for various operations
+export const DEFAULT_OPTIONS = {
+  precision: 0,
+  roundingMode: 'HALF_EVEN',
+  checkOverflow: true,
+  maxSteps: MAX_COMPUTATION_STEPS,
+  grouping: true,
+  uppercase: false,
+  cache: true
+} as const;
+
+// Units for number formatting (powers of 1000)
+export const NUMBER_UNITS = [
+  { value: 1n, symbol: '' },
+  { value: 1000n, symbol: 'K' },
+  { value: 1000000n, symbol: 'M' },
+  { value: 1000000000n, symbol: 'B' },
+  { value: 1000000000000n, symbol: 'T' },
+  { value: 1000000000000000n, symbol: 'Q' }
+] as const;
+
+// Performance monitoring thresholds
+export const PERFORMANCE = {
+  WARN_THRESHOLD_MS: 100,
+  ERROR_THRESHOLD_MS: 1000,
+  MAX_ARRAY_SIZE: 1000000,
+  MAX_TREE_SIZE: 1000000
 } as const;

package/src/core/errors.ts

@@ -1,203 +1,203 @@
-/**
- * Custom error types for Hypernum library
- * Provides specific error classes for different types of errors that can occur
- * during mathematical operations and data structure manipulations
- */
-
-import { ERROR_MESSAGES } from './constants';
-
-/**
- * Base error class for Hypernum library
- * All other error classes inherit from this
- */
-export class HypernumError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'HypernumError';
-    Object.setPrototypeOf(this, HypernumError.prototype);
-  }
-}
-
-/**
- * Error for validation failures
- */
-export class ValidationError extends HypernumError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'ValidationError';
-    Object.setPrototypeOf(this, ValidationError.prototype);
-  }
-}
-
-/**
- * Error for arithmetic overflow conditions
- */
-export class OverflowError extends HypernumError {
-  constructor(message: string = ERROR_MESSAGES.OVERFLOW) {
-    super(message);
-    this.name = 'OverflowError';
-    Object.setPrototypeOf(this, OverflowError.prototype);
-  }
-}
-
-/**
- * Error for arithmetic underflow conditions
- */
-export class UnderflowError extends HypernumError {
-  constructor(message: string = ERROR_MESSAGES.UNDERFLOW) {
-    super(message);
-    this.name = 'UnderflowError';
-    Object.setPrototypeOf(this, UnderflowError.prototype);
-  }
-}
-
-/**
- * Error for division by zero
- */
-export class DivisionByZeroError extends HypernumError {
-  constructor(message: string = ERROR_MESSAGES.DIVISION_BY_ZERO) {
-    super(message);
-    this.name = 'DivisionByZeroError';
-    Object.setPrototypeOf(this, DivisionByZeroError.prototype);
-  }
-}
-
-/**
- * Error for precision-related issues
- */
-export class PrecisionError extends HypernumError {
-  constructor(message: string = ERROR_MESSAGES.INVALID_PRECISION) {
-    super(message);
-    this.name = 'PrecisionError';
-    Object.setPrototypeOf(this, PrecisionError.prototype);
-  }
-}
-
-/**
- * Error for computation limits exceeded
- */
-export class ComputationLimitError extends HypernumError {
-  constructor(message: string = ERROR_MESSAGES.COMPUTATION_LIMIT) {
-    super(message);
-    this.name = 'ComputationLimitError';
-    Object.setPrototypeOf(this, ComputationLimitError.prototype);
-  }
-}
-
-/**
- * Error for invalid operations on data structures
- */
-export class DataStructureError extends HypernumError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'DataStructureError';
-    Object.setPrototypeOf(this, DataStructureError.prototype);
-  }
-}
-
-/**
- * Error for heap property violations
- */
-export class HeapPropertyError extends DataStructureError {
-  constructor(message: string = ERROR_MESSAGES.INVALID_HEAP_PROPERTY) {
-    super(message);
-    this.name = 'HeapPropertyError';
-    Object.setPrototypeOf(this, HeapPropertyError.prototype);
-  }
-}
-
-/**
- * Error for tree-related issues
- */
-export class TreeError extends DataStructureError {
-  constructor(message: string = ERROR_MESSAGES.TREE_DEPTH_EXCEEDED) {
-    super(message);
-    this.name = 'TreeError';
-    Object.setPrototypeOf(this, TreeError.prototype);
-  }
-}
-
-/**
- * Error for array index out of bounds
- */
-export class IndexError extends DataStructureError {
-  constructor(message: string = ERROR_MESSAGES.NEGATIVE_INDEX) {
-    super(message);
-    this.name = 'IndexError';
-    Object.setPrototypeOf(this, IndexError.prototype);
-  }
-}
-
-/**
- * Error for invalid number format or conversion
- */
-export class FormatError extends HypernumError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'FormatError';
-    Object.setPrototypeOf(this, FormatError.prototype);
-  }
-}
-
-/**
- * Error for invalid Roman numeral operations
- */
-export class RomanNumeralError extends FormatError {
-  constructor(message: string = ERROR_MESSAGES.INVALID_ROMAN) {
-    super(message);
-    this.name = 'RomanNumeralError';
-    Object.setPrototypeOf(this, RomanNumeralError.prototype);
-  }
-}
-
-/**
- * Type guard to check if an error is a Hypernum error
- */
-export function isHypernumError(error: unknown): error is HypernumError {
-  return error instanceof HypernumError;
-}
-
-/**
- * Helper function to wrap unknown errors into HypernumError
- */
-export function wrapError(error: unknown): HypernumError {
-  if (isHypernumError(error)) {
-    return error;
-  }
-  if (error instanceof Error) {
-    return new HypernumError(error.message);
-  }
-  return new HypernumError('An unknown error occurred');
-}
-
-/**
- * Helper function to create an appropriate error from a message and optional type
- */
-export function createError(message: string, type?: string): HypernumError {
-  switch (type) {
-    case 'validation':
-      return new ValidationError(message);
-    case 'overflow':
-      return new OverflowError(message);
-    case 'underflow':
-      return new UnderflowError(message);
-    case 'division':
-      return new DivisionByZeroError(message);
-    case 'precision':
-      return new PrecisionError(message);
-    case 'computation':
-      return new ComputationLimitError(message);
-    case 'heap':
-      return new HeapPropertyError(message);
-    case 'tree':
-      return new TreeError(message);
-    case 'index':
-      return new IndexError(message);
-    case 'format':
-      return new FormatError(message);
-    case 'roman':
-      return new RomanNumeralError(message);
-    default:
-      return new HypernumError(message);
-  }
+/**
+ * Custom error types for Hypernum library
+ * Provides specific error classes for different types of errors that can occur
+ * during mathematical operations and data structure manipulations
+ */
+
+import { ERROR_MESSAGES } from './constants';
+
+/**
+ * Base error class for Hypernum library
+ * All other error classes inherit from this
+ */
+export class HypernumError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'HypernumError';
+    Object.setPrototypeOf(this, HypernumError.prototype);
+  }
+}
+
+/**
+ * Error for validation failures
+ */
+export class ValidationError extends HypernumError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ValidationError';
+    Object.setPrototypeOf(this, ValidationError.prototype);
+  }
+}
+
+/**
+ * Error for arithmetic overflow conditions
+ */
+export class OverflowError extends HypernumError {
+  constructor(message: string = ERROR_MESSAGES.OVERFLOW) {
+    super(message);
+    this.name = 'OverflowError';
+    Object.setPrototypeOf(this, OverflowError.prototype);
+  }
+}
+
+/**
+ * Error for arithmetic underflow conditions
+ */
+export class UnderflowError extends HypernumError {
+  constructor(message: string = ERROR_MESSAGES.UNDERFLOW) {
+    super(message);
+    this.name = 'UnderflowError';
+    Object.setPrototypeOf(this, UnderflowError.prototype);
+  }
+}
+
+/**
+ * Error for division by zero
+ */
+export class DivisionByZeroError extends HypernumError {
+  constructor(message: string = ERROR_MESSAGES.DIVISION_BY_ZERO) {
+    super(message);
+    this.name = 'DivisionByZeroError';
+    Object.setPrototypeOf(this, DivisionByZeroError.prototype);
+  }
+}
+
+/**
+ * Error for precision-related issues
+ */
+export class PrecisionError extends HypernumError {
+  constructor(message: string = ERROR_MESSAGES.INVALID_PRECISION) {
+    super(message);
+    this.name = 'PrecisionError';
+    Object.setPrototypeOf(this, PrecisionError.prototype);
+  }
+}
+
+/**
+ * Error for computation limits exceeded
+ */
+export class ComputationLimitError extends HypernumError {
+  constructor(message: string = ERROR_MESSAGES.COMPUTATION_LIMIT) {
+    super(message);
+    this.name = 'ComputationLimitError';
+    Object.setPrototypeOf(this, ComputationLimitError.prototype);
+  }
+}
+
+/**
+ * Error for invalid operations on data structures
+ */
+export class DataStructureError extends HypernumError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'DataStructureError';
+    Object.setPrototypeOf(this, DataStructureError.prototype);
+  }
+}
+
+/**
+ * Error for heap property violations
+ */
+export class HeapPropertyError extends DataStructureError {
+  constructor(message: string = ERROR_MESSAGES.INVALID_HEAP_PROPERTY) {
+    super(message);
+    this.name = 'HeapPropertyError';
+    Object.setPrototypeOf(this, HeapPropertyError.prototype);
+  }
+}
+
+/**
+ * Error for tree-related issues
+ */
+export class TreeError extends DataStructureError {
+  constructor(message: string = ERROR_MESSAGES.TREE_DEPTH_EXCEEDED) {
+    super(message);
+    this.name = 'TreeError';
+    Object.setPrototypeOf(this, TreeError.prototype);
+  }
+}
+
+/**
+ * Error for array index out of bounds
+ */
+export class IndexError extends DataStructureError {
+  constructor(message: string = ERROR_MESSAGES.NEGATIVE_INDEX) {
+    super(message);
+    this.name = 'IndexError';
+    Object.setPrototypeOf(this, IndexError.prototype);
+  }
+}
+
+/**
+ * Error for invalid number format or conversion
+ */
+export class FormatError extends HypernumError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'FormatError';
+    Object.setPrototypeOf(this, FormatError.prototype);
+  }
+}
+
+/**
+ * Error for invalid Roman numeral operations
+ */
+export class RomanNumeralError extends FormatError {
+  constructor(message: string = ERROR_MESSAGES.INVALID_ROMAN) {
+    super(message);
+    this.name = 'RomanNumeralError';
+    Object.setPrototypeOf(this, RomanNumeralError.prototype);
+  }
+}
+
+/**
+ * Type guard to check if an error is a Hypernum error
+ */
+export function isHypernumError(error: unknown): error is HypernumError {
+  return error instanceof HypernumError;
+}
+
+/**
+ * Helper function to wrap unknown errors into HypernumError
+ */
+export function wrapError(error: unknown): HypernumError {
+  if (isHypernumError(error)) {
+    return error;
+  }
+  if (error instanceof Error) {
+    return new HypernumError(error.message);
+  }
+  return new HypernumError('An unknown error occurred');
+}
+
+/**
+ * Helper function to create an appropriate error from a message and optional type
+ */
+export function createError(message: string, type?: string): HypernumError {
+  switch (type) {
+    case 'validation':
+      return new ValidationError(message);
+    case 'overflow':
+      return new OverflowError(message);
+    case 'underflow':
+      return new UnderflowError(message);
+    case 'division':
+      return new DivisionByZeroError(message);
+    case 'precision':
+      return new PrecisionError(message);
+    case 'computation':
+      return new ComputationLimitError(message);
+    case 'heap':
+      return new HeapPropertyError(message);
+    case 'tree':
+      return new TreeError(message);
+    case 'index':
+      return new IndexError(message);
+    case 'format':
+      return new FormatError(message);
+    case 'roman':
+      return new RomanNumeralError(message);
+    default:
+      return new HypernumError(message);
+  }
 }