@obinexusmk2/hypernum 0.1.0

package/dist/types/operations/conversion.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Conversion operations module for Hypernum library
+ * Provides functions for converting numbers between different formats and bases
+ */
+import { RoundingMode } from '../utils/precision';
+/**
+ * Options for conversion operations
+ */
+export interface ConversionOptions {
+    /** Precision for decimal operations */
+    precision?: number;
+    /** Rounding mode for decimal operations */
+    roundingMode?: RoundingMode;
+    /** Whether to use uppercase for hex/base-N output */
+    uppercase?: boolean;
+    /** Whether to add prefix for base-N output (0x, 0b, etc.) */
+    prefix?: boolean;
+    /** Minimum number of digits (pad with zeros) */
+    minDigits?: number;
+}
+/**
+ * Converts number to binary string representation
+ */
+export declare function toBinary(value: bigint | string | number, options?: ConversionOptions): string;
+/**
+ * Converts number to octal string representation
+ */
+export declare function toOctal(value: bigint | string | number, options?: ConversionOptions): string;
+/**
+ * Converts number to hexadecimal string representation
+ */
+export declare function toHexadecimal(value: bigint | string | number, options?: ConversionOptions): string;
+/**
+ * Converts number to string in specified base
+ */
+export declare function toBase(value: bigint | string | number, base: number, options?: ConversionOptions): string;
+/**
+ * Converts string from specified base to bigint
+ */
+export declare function fromBase(value: string, base: number): bigint;
+/**
+ * Converts decimal string to fraction representation
+ */
+export declare function toFraction(value: string): [bigint, bigint];
+/**
+ * Converts fraction to decimal string with specified precision
+ */
+export declare function fromFraction(numerator: bigint | string | number, denominator: bigint | string | number, options?: ConversionOptions): string;
+/**
+ * Converts scientific notation to decimal string
+ */
+export declare function fromScientific(value: string): string;
+/**
+ * Converts decimal to scientific notation
+ */
+export declare function toScientific(value: bigint | string | number, options?: ConversionOptions): string;
+/**
+* Converts Roman numeral to number
+*/
+export declare function fromRoman(value: string): bigint;
+/**
+ * Converts number to Roman numeral
+ */
+export declare function toRoman(value: bigint | string | number, options?: ConversionOptions): string;
+declare const _default: {
+    toBinary: typeof toBinary;
+    toOctal: typeof toOctal;
+    toHexadecimal: typeof toHexadecimal;
+    toBase: typeof toBase;
+    fromBase: typeof fromBase;
+    toFraction: typeof toFraction;
+    fromFraction: typeof fromFraction;
+    fromScientific: typeof fromScientific;
+    toScientific: typeof toScientific;
+    fromRoman: typeof fromRoman;
+    toRoman: typeof toRoman;
+};
+export default _default;
+//# sourceMappingURL=conversion.d.ts.map

package/dist/types/operations/conversion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversion.d.ts","sourceRoot":"","sources":["../../../src/operations/conversion.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOD,OAAO,EACL,YAAY,EAEb,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,uCAAuC;IACvC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2CAA2C;IAC3C,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,qDAAqD;IACrD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,6DAA6D;IAC7D,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,gDAAgD;IAChD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAUD;;GAEG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC/B,OAAO,GAAE,iBAAsB,GAC9B,MAAM,CAYR;AAED;;GAEG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC/B,OAAO,GAAE,iBAAsB,GAC9B,MAAM,CAWR;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC/B,OAAO,GAAE,iBAAsB,GAC9B,MAAM,CAeR;AAED;;GAEG;AACH,wBAAgB,MAAM,CACpB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC/B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,iBAAsB,GAC9B,MAAM,CAmBR;AAED;;GAEG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,GACX,MAAM,CAgBR;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,GACZ,CAAC,MAAM,EAAE,MAAM,CAAC,CAiBlB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EACnC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EACrC,OAAO,GAAE,iBAAsB,GAC9B,MAAM,CAqBR;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,GACZ,MAAM,CAyBR;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC/B,OAAO,GAAE,iBAAsB,GAC9B,MAAM,CAyBR;AAmBD;;EAEC;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAiC7C;AAED;;GAEG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC/B,OAAO,GAAE,iBAAsB,GAC9B,MAAM,CAqDR;;;;;;;;;;;;;;AACD,wBAYE"}

package/dist/types/operations/factorial.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Factorial operations module for Hypernum library
+ * Provides efficient implementations for factorial and related computations
+ */
+/**
+ * Options for factorial operations
+ */
+export interface FactorialOptions {
+    /** Maximum allowed computation value */
+    maxValue?: number;
+    /** Whether to check for overflow */
+    checkOverflow?: boolean;
+    /** Cache computed values */
+    useCache?: boolean;
+}
+/**
+ * Calculates factorial of a number (n!)
+ */
+export declare function factorial(value: bigint | string | number, options?: FactorialOptions): bigint;
+/**
+ * Calculates binomial coefficient (n choose k)
+ */
+export declare function binomial(n: bigint | string | number, k: bigint | string | number, options?: FactorialOptions): bigint;
+/**
+ * Calculates subfactorial (derangement number)
+ * Number of permutations of n elements with no fixed points
+ */
+export declare function subfactorial(value: bigint | string | number, options?: FactorialOptions): bigint;
+/**
+ * Calculates rising factorial (Pochhammer symbol)
+ * x^(n) = x(x+1)(x+2)...(x+n-1)
+ */
+export declare function risingFactorial(x: bigint | string | number, n: bigint | string | number, options?: FactorialOptions): bigint;
+/**
+ * Calculates falling factorial
+ * x_(n) = x(x-1)(x-2)...(x-n+1)
+ */
+export declare function fallingFactorial(x: bigint | string | number, n: bigint | string | number, options?: FactorialOptions): bigint;
+/**
+ * Calculates multifactorial (n!!)
+ * Product of numbers from 1 to n that leave the same remainder as n when divided by k
+ */
+export declare function multiFactorial(value: bigint | string | number, k?: bigint | string | number, options?: FactorialOptions): bigint;
+/**
+ * Calculates primorial (product of primes up to n)
+ */
+export declare function primorial(value: bigint | string | number, options?: FactorialOptions): bigint;
+declare const _default: {
+    factorial: typeof factorial;
+    binomial: typeof binomial;
+    subfactorial: typeof subfactorial;
+    risingFactorial: typeof risingFactorial;
+    fallingFactorial: typeof fallingFactorial;
+    multiFactorial: typeof multiFactorial;
+    primorial: typeof primorial;
+};
+export default _default;
+//# sourceMappingURL=factorial.d.ts.map

package/dist/types/operations/factorial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factorial.d.ts","sourceRoot":"","sources":["../../../src/operations/factorial.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oCAAoC;IACpC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,4BAA4B;IAC5B,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAWD;;GAEG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC/B,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CAgCR;AAED;;GAEG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC3B,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC3B,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CAwBR;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC/B,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CAwBR;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC3B,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC3B,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CAiBR;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC3B,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC3B,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CAiBR;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC/B,CAAC,GAAE,MAAM,GAAG,MAAM,GAAG,MAAW,EAChC,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CAuBR;AAED;;GAEG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC/B,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CAkCR;;;;;;;;;;AAID,wBAQE"}

package/dist/types/operations/index.d.ts

@@ -0,0 +1,6 @@
+export * from './arithmetic';
+export * from './comparison';
+export * from './conversion';
+export * from './bitwise';
+export * from './factorial';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/operations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/operations/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAA"}

package/dist/types/operations/power.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Power operations module for Hypernum library
+ * Provides efficient implementations for exponentiation and related operations
+ */
+import { RoundingMode } from '../utils/precision';
+/**
+ * Options for power operations
+ */
+export interface PowerOptions {
+    /** Precision for decimal operations */
+    precision?: number;
+    /** Rounding mode for decimal operations */
+    roundingMode?: RoundingMode;
+    /** Whether to check for overflow */
+    checkOverflow?: boolean;
+    /** Maximum allowed computation steps */
+    maxSteps?: number;
+}
+/**
+ * Raises a number to an integer power using binary exponentiation
+ */
+export declare function power(baseValue: bigint | string | number, exponentValue: bigint | string | number, options?: PowerOptions): bigint;
+/**
+ * Calculates square root using Newton's method
+ */
+export declare function sqrt(value: bigint | string | number, options?: PowerOptions): bigint;
+/**
+ * Calculates nth root using Newton's method
+ */
+export declare function nthRoot(value: bigint | string | number, n: bigint | string | number, options?: PowerOptions): bigint;
+/**
+ * Calculates tetration (repeated exponentiation)
+ * a↑↑n = a^(a^(a^...)) (n times)
+ */
+export declare function tetration(base: bigint | string | number, height: bigint | string | number, options?: PowerOptions): bigint;
+/**
+ * Calculates super-root (inverse tetration)
+ * Finds x where x↑↑n = value
+ */
+export declare function superRoot(value: bigint | string | number, height: bigint | string | number, options?: PowerOptions): bigint;
+declare const _default: {
+    power: typeof power;
+    sqrt: typeof sqrt;
+    nthRoot: typeof nthRoot;
+    tetration: typeof tetration;
+    superRoot: typeof superRoot;
+};
+export default _default;
+//# sourceMappingURL=power.d.ts.map

package/dist/types/operations/power.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"power.d.ts","sourceRoot":"","sources":["../../../src/operations/power.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAUD,OAAO,EACL,YAAY,EAEb,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,uCAAuC;IACvC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2CAA2C;IAC3C,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,oCAAoC;IACpC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AASD;;GAEG;AACH,wBAAgB,KAAK,CACnB,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EACnC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EACvC,OAAO,GAAE,YAAiB,GACzB,MAAM,CAyDR;AAED;;GAEG;AACH,wBAAgB,IAAI,CAClB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC/B,OAAO,GAAE,YAAiB,GACzB,MAAM,CAgCR;AAED;;GAEG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC/B,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC3B,OAAO,GAAE,YAAiB,GACzB,MAAM,CA6CR;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC9B,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAChC,OAAO,GAAE,YAAiB,GACzB,MAAM,CAuCR;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC/B,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAChC,OAAO,GAAE,YAAiB,GACzB,MAAM,CAmDR;;;;;;;;AAED,wBAME"}

package/dist/types/storage/Heap.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Represents the result of a comparison operation
+ * -1: first value is less than second value
+ *  0: values are equal
+ *  1: first value is greater than second value
+ */
+export type ComparisonResult = -1 | 0 | 1;
+/**
+ * Generic comparator function type for heap elements
+ */
+export type Comparator<T> = (a: T, b: T) => ComparisonResult;
+/**
+ * Abstract base heap class implementing common heap operations
+ */
+declare abstract class Heap<T> {
+    protected heap: T[];
+    protected readonly compare: Comparator<T>;
+    constructor(comparator: Comparator<T>);
+    /**
+     * Gets the size of the heap
+     */
+    size(): number;
+    /**
+     * Checks if the heap is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Peeks at the root element without removing it
+     */
+    peek(): T | undefined;
+    /**
+     * Inserts a new element into the heap
+     */
+    push(value: T): void;
+    /**
+     * Removes and returns the root element
+     */
+    pop(): T | undefined;
+    /**
+     * Removes all elements from the heap
+     */
+    clear(): void;
+    /**
+     * Creates a heap from an array of elements
+     */
+    static heapify<T extends {}>(array: T[], comparator: Comparator<T>): Heap<T>;
+    /**
+     * Gets the parent index of a node
+     */
+    protected getParentIndex(index: number): number;
+    /**
+     * Gets the left child index of a node
+     */
+    protected getLeftChildIndex(index: number): number;
+    /**
+     * Gets the right child index of a node
+     */
+    protected getRightChildIndex(index: number): number;
+    /**
+     * Swaps two elements in the heap
+     */
+    protected swap(i: number, j: number): void;
+    /**
+     * Moves an element up the heap until heap property is satisfied
+     */
+    protected abstract siftUp(index: number): void;
+    /**
+     * Moves an element down the heap until heap property is satisfied
+     */
+    protected abstract siftDown(index: number): void;
+}
+/**
+ * MinHeap implementation where the root is the smallest element
+ */
+export declare class MinHeap<T> extends Heap<T> {
+    constructor(comparator: Comparator<T>);
+    protected siftUp(index: number): void;
+    protected siftDown(index: number): void;
+}
+/**
+ * MaxHeap implementation where the root is the largest element
+ */
+export declare class MaxHeap<T> extends Heap<T> {
+    constructor(comparator: Comparator<T>);
+    protected siftUp(index: number): void;
+    protected siftDown(index: number): void;
+}
+export declare const isMinHeap: <T>(heap: Heap<T>) => heap is MinHeap<T>;
+export declare const isMaxHeap: <T>(heap: Heap<T>) => heap is MaxHeap<T>;
+/**
+ * Custom comparator for large numbers
+ */
+export declare function createLargeNumberComparator(): (a: bigint, b: bigint) => number;
+export {};
+//# sourceMappingURL=Heap.d.ts.map

package/dist/types/storage/Heap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Heap.d.ts","sourceRoot":"","sources":["../../../src/storage/Heap.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE1C;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,gBAAgB,CAAC;AAE7D;;GAEG;AACH,uBAAe,IAAI,CAAC,CAAC;IACnB,SAAS,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;IACpB,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;gBAE9B,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC;IAKrC;;OAEG;IACI,IAAI,IAAI,MAAM;IAIrB;;OAEG;IACI,OAAO,IAAI,OAAO;IAIzB;;OAEG;IACI,IAAI,IAAI,CAAC,GAAG,SAAS;IAI5B;;OAEG;IACI,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAK3B;;OAEG;IACI,GAAG,IAAI,CAAC,GAAG,SAAS;IAgB3B;;OAEG;IACI,KAAK,IAAI,IAAI;IAIpB;;OAEG;WACW,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IAMnF;;OAEG;IACH,SAAS,CAAC,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAI/C;;OAEG;IACH,SAAS,CAAC,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAIlD;;OAEG;IACH,SAAS,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAInD;;OAEG;IACH,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAM1C;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAE9C;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CACjD;AAED;;GAEG;AACH,qBAAa,OAAO,CAAC,CAAC,CAAE,SAAQ,IAAI,CAAC,CAAC,CAAC;gBACzB,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC;IAIrC,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAWrC,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAwBxC;AAED;;GAEG;AACH,qBAAa,OAAO,CAAC,CAAC,CAAE,SAAQ,IAAI,CAAC,CAAC,CAAC;gBACzB,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC;IAIrC,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAWrC,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAwBxC;AAGD,eAAO,MAAM,SAAS,YAAa,KAAK,CAAC,CAAC,uBAEzC,CAAC;AAEF,eAAO,MAAM,SAAS,YAAa,KAAK,CAAC,CAAC,uBAEzC,CAAC;AAEF;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAI9E"}

package/dist/types/storage/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Heap';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/storage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC"}

package/dist/types/structures/ackermann.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Interface representing an Ackermann node in the computation structure
+ */
+interface IAckermannNode {
+    m: number;
+    n: number;
+    value: bigint;
+    prevM?: IAckermannNode;
+    prevN?: IAckermannNode;
+    nextM?: IAckermannNode;
+    nextN?: IAckermannNode;
+}
+/**
+ * Type for Ackermann computation path step
+ */
+type ComputationStep = {
+    m: number;
+    n: number;
+    value: bigint;
+};
+/**
+ * Type for growth rate analysis
+ */
+type GrowthAnalysis = {
+    value: bigint;
+    increase: bigint;
+    multiplier: bigint;
+};
+/**
+ * Class representing the Ackermann function computation structure
+ * Implements caching and relationship tracking between values
+ */
+export declare class AckermannStructure {
+    private nodes;
+    private maxComputedM;
+    private maxComputedN;
+    private heap;
+    constructor();
+    /**
+     * Generates a unique key for node storage
+     */
+    private static getNodeKey;
+    /**
+     * Computes the Ackermann function value
+     * Uses recursion with memoization
+     */
+    private computeAckermann;
+    /**
+     * Adds a new node to the structure
+     */
+    addNode(m: number, n: number): IAckermannNode;
+    /**
+     * Builds nodes for a range of m and n values
+     */
+    buildRange(mRange: number, nRange: number): void;
+    /**
+     * Gets the computation path to reach A(m,n)
+     */
+    getComputationPath(m: number, n: number): ComputationStep[];
+    /**
+     * Analyzes growth rate for a fixed m value
+     */
+    analyzeGrowthRate(m: number): Map<number, GrowthAnalysis>;
+    /**
+     * Gets the largest computed value
+     */
+    getLargestValue(): bigint;
+    /**
+     * Gets a specific Ackermann value if it exists
+     */
+    getValue(m: number, n: number): bigint | undefined;
+}
+export default AckermannStructure;
+//# sourceMappingURL=ackermann.d.ts.map

package/dist/types/structures/ackermann.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ackermann.d.ts","sourceRoot":"","sources":["../../../src/structures/ackermann.ts"],"names":[],"mappings":"AAGE;;GAEG;AACH,UAAU,cAAc;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,KAAK,CAAC,EAAE,cAAc,CAAC;CACxB;AAED;;GAEG;AACH,KAAK,eAAe,GAAG;IACrB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;GAEG;AACH,KAAK,cAAc,GAAG;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;GAGG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,KAAK,CAA8B;IAC3C,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,IAAI,CAAkB;;IAS9B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,UAAU;IAIzB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAuCxB;;OAEG;IACI,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,cAAc;IAmCpD;;OAEG;IACI,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAQvD;;OAEG;IACI,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,eAAe,EAAE;IAsClE;;OAEG;IACI,iBAAiB,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC;IAuBhE;;OAEG;IACI,eAAe,IAAI,MAAM;IAIhC;;OAEG;IACI,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;CAG1D;AAED,eAAe,kBAAkB,CAAC"}

package/dist/types/structures/big-array.d.ts

@@ -0,0 +1,102 @@
+import { Comparator } from '@/core';
+import { MinHeap, MaxHeap } from '../storage/Heap';
+/**
+ * Interface for segment tree node operations
+ */
+export interface SegmentTreeNode<T> {
+    value: T;
+    lazy?: T;
+    start: number;
+    end: number;
+}
+/**
+ * Type for BigArray operation result
+ */
+export type OperationResult<T> = {
+    success: boolean;
+    value?: T;
+    error?: string;
+};
+/**
+ * Options for BigArray initialization
+ */
+export interface BigArrayOptions<T> {
+    initialCapacity?: number;
+    growthFactor?: number;
+    comparator?: Comparator<T>;
+}
+/**
+ * A specialized array implementation for handling large numbers and providing
+ * efficient operations with segment tree support
+ */
+export declare class BigArray<T> {
+    private data;
+    private segmentTree;
+    private readonly growthFactor;
+    private readonly comparator;
+    private size;
+    private capacity;
+    constructor(options?: BigArrayOptions<T>);
+    /**
+     * Gets the current size of the array
+     */
+    getSize(): number;
+    /**
+     * Gets the current capacity of the array
+     */
+    getCapacity(): number;
+    /**
+     * Resizes the internal array when needed
+     */
+    private resize;
+    /**
+     * Appends an element to the end of the array
+     */
+    push(value: T): OperationResult<number>;
+    /**
+     * Removes and returns the last element
+     */
+    pop(): OperationResult<T>;
+    /**
+     * Gets element at specified index
+     */
+    get(index: number): OperationResult<T>;
+    /**
+     * Sets element at specified index
+     */
+    set(index: number, value: T): OperationResult<T>;
+    /**
+     * Rebuilds the segment tree after major changes
+     */
+    private rebuildSegmentTree;
+    /**
+     * Builds a segment tree node recursively
+     */
+    private buildSegmentTree;
+    /**
+     * Updates the segment tree after a value change
+     */
+    private updateSegmentTree;
+    /**
+     * Queries the maximum value in a range
+     */
+    queryRange(start: number, end: number): OperationResult<T>;
+    /**
+     * Recursively queries the segment tree
+     */
+    private querySegmentTree;
+    /**
+     * Creates a heap from the current array
+     */
+    toHeap(isMin?: boolean): MinHeap<T> | MaxHeap<T>;
+    /**
+     * Sorts the array in-place
+     */
+    sort(ascending?: boolean): void;
+    /**
+     * Returns array as native array
+     */
+    toArray(): T[];
+}
+export default BigArray;
+//# sourceMappingURL=big-array.d.ts.map

package/dist/types/structures/big-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"big-array.d.ts","sourceRoot":"","sources":["../../../src/structures/big-array.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC;IAAK,KAAK,EAAE,CAAC,CAAC;IAC9C,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,CAAC,CAAC;IACV,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;CAC5B;AAED;;;GAGG;AACH,qBAAa,QAAQ,CAAC,CAAC;IACrB,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,WAAW,CAAmC;IACtD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAC3C,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,QAAQ,CAAS;gBAEb,OAAO,GAAE,eAAe,CAAC,CAAC,CAAM;IAmB5C;;OAEG;IACI,OAAO,IAAI,MAAM;IAIxB;;OAEG;IACI,WAAW,IAAI,MAAM;IAI5B;;OAEG;IACH,OAAO,CAAC,MAAM;IAUd;;OAEG;IACI,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,eAAe,CAAC,MAAM,CAAC;IAiB9C;;OAEG;IACI,GAAG,IAAI,eAAe,CAAC,CAAC,CAAC;IAgBhC;;OAEG;IACI,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC;IAO7C;;OAEG;IACI,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC;IAYvD;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAO1B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA4BxB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA4BzB;;OAEG;IACI,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC;IAWjE;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAuBxB;;OAEG;IACI,MAAM,CAAC,KAAK,GAAE,OAAc,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAgB7D;;OAEG;IACI,IAAI,CAAC,SAAS,GAAE,OAAc,GAAG,IAAI;IAW5C;;OAEG;IACI,OAAO,IAAI,CAAC,EAAE;CAGtB;AAED,eAAe,QAAQ,CAAC"}

package/dist/types/structures/index.d.ts

@@ -0,0 +1,5 @@
+export { AckermannStructure } from './ackermann';
+export { BigArray, type BigArrayOptions } from './big-array';
+export { NumberTree } from './number-tree';
+export { PowerTower } from './power-tower';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/structures/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/structures/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC"}

package/dist/types/structures/number-tree.d.ts

@@ -0,0 +1,114 @@
+import { Comparator } from "@/core";
+/**
+ * Interface for tree node statistics
+ */
+interface NodeStats {
+    height: number;
+    size: number;
+    sum: bigint;
+    min: bigint;
+    max: bigint;
+}
+/**
+ * Interface for tree traversal configuration
+ */
+interface TraversalConfig {
+    includeStats?: boolean;
+    skipSubtrees?: boolean;
+    maxDepth?: number;
+}
+/**
+ * Class representing a node in the number tree
+ */
+declare class NumberNode {
+    value: bigint;
+    left: NumberNode | null;
+    right: NumberNode | null;
+    parent: NumberNode | null;
+    height: number;
+    size: number;
+    sum: bigint;
+    constructor(value: bigint | string | number);
+    /**
+     * Updates node statistics based on children
+     */
+    updateStats(): void;
+    /**
+     * Gets balance factor of the node
+     */
+    getBalance(): number;
+    /**
+     * Gets complete statistics for the node and its subtree
+     */
+    getStats(): NodeStats;
+    /**
+     * Finds minimum value node in the subtree
+     */
+    findMin(): NumberNode;
+    /**
+     * Finds maximum value node in the subtree
+     */
+    findMax(): NumberNode;
+}
+/**
+ * AVL Tree implementation specialized for handling large numbers
+ */
+export declare class NumberTree {
+    private root;
+    private readonly comparator;
+    constructor(comparator?: Comparator<bigint>);
+    /**
+     * Gets the root node if it exists
+     */
+    getRoot(): NumberNode | null;
+    /**
+     * Inserts a new value into the tree
+     */
+    insert(value: bigint | string | number): NumberNode;
+    /**
+     * Recursively inserts a new node
+     */
+    private insertNode;
+    /**
+     * Balances a node using AVL rotations
+     */
+    private balance;
+    /**
+     * Performs left rotation
+     */
+    private rotateLeft;
+    /**
+     * Performs right rotation
+     */
+    private rotateRight;
+    /**
+     * Removes a value from the tree
+     */
+    remove(value: bigint | string | number): boolean;
+    /**
+     * Recursively removes a node
+     */
+    private removeNode;
+    /**
+     * Finds a node by value
+     */
+    find(value: bigint | string | number): NumberNode | null;
+    /**
+     * Traverses the tree in specified order and returns values
+     */
+    traverse(order?: 'inOrder' | 'preOrder' | 'postOrder', config?: TraversalConfig): bigint[];
+    /**
+     * Gets overall tree statistics
+     */
+    getTreeStats(): NodeStats | null;
+    /**
+     * Gets the nth smallest value in the tree
+     */
+    getNthValue(n: number): bigint | null;
+    /**
+     * Gets a range of values between start and end (inclusive)
+     */
+    getRange(start: bigint | string | number, end: bigint | string | number): bigint[];
+}
+export default NumberTree;
+//# sourceMappingURL=number-tree.d.ts.map

package/dist/types/structures/number-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-tree.d.ts","sourceRoot":"","sources":["../../../src/structures/number-tree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEpC;;GAEG;AACH,UAAU,SAAS;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,UAAU,eAAe;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,cAAM,UAAU;IACd,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;IACxB,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IACzB,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;gBAEA,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM;IAU3C;;OAEG;IACH,WAAW,IAAI,IAAI;IAWnB;;OAEG;IACH,UAAU,IAAI,MAAM;IAIpB;;OAEG;IACH,QAAQ,IAAI,SAAS;IAUrB;;OAEG;IACH,OAAO,IAAI,UAAU;IAQrB;;OAEG;IACH,OAAO,IAAI,UAAU;CAOtB;AAED;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,IAAI,CAAoB;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqB;gBAEpC,UAAU,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC;IAS3C;;OAEG;IACI,OAAO,IAAI,UAAU,GAAG,IAAI;IAInC;;OAEG;IACI,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU;IAM1D;;OAEG;IACH,OAAO,CAAC,UAAU;IAoBlB;;OAEG;IACH,OAAO,CAAC,OAAO;IAsBf;;OAEG;IACH,OAAO,CAAC,UAAU;IAmBlB;;OAEG;IACH,OAAO,CAAC,WAAW;IAmBnB;;OAEG;IACI,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO;IAYvD;;OAEG;IACH,OAAO,CAAC,UAAU;IAsClB;;OAEG;IACI,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,IAAI;IAe/D;;OAEG;IACI,QAAQ,CAAC,KAAK,GAAE,SAAS,GAAG,UAAU,GAAG,WAAuB,EACxD,MAAM,GAAE,eAAoB,GAAG,MAAM,EAAE;IAiCtD;;OAEG;IACI,YAAY,IAAI,SAAS,GAAG,IAAI;IAIvC;;OAEG;IACI,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IA0B5C;;OAEG;IACI,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAChC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE;CAyBxD;AAED,eAAe,UAAU,CAAC"}