semantic-typescript 0.3.3 → 0.3.8

package/dist/statistics.js

@@ -1,329 +1,179 @@
 import { OrderedCollectable } from "./collectable";
-import { isFunction, isIterable } from "./guard";
-import { useCompare } from "./hook";
-import { Optional } from "./optional";
+import { Collector, useBigIntAverage, useBigIntMedian, useBigIntMode, useBigIntSummate, useBigIntVariance, useFrequency, useNumericAverage, useNumericMedian, useNumericMode, useNumericStandardDeviation, useNumericSummate, useNumericVariance, useToAsyncGeneratorFunction, useToGeneratorFunction } from "./collector";
+import { isFunction } from "./guard";
+import { useCompare, useToBigInt, useToNumber } from "./hook";
 import { StatisticsSymbol, NumericStatisticsSymbol, BigIntStatisticsSymbol } from "./symbol";
-import { invalidate } from "./utility";
 export class Statistics extends OrderedCollectable {
     Statistics = StatisticsSymbol;
     constructor(parameter, comparator) {
-        if (isIterable(parameter)) {
-            if (isFunction(comparator)) {
-                super(parameter, comparator);
-            }
-            else {
-                super(parameter);
-            }
-        }
-        else if (isFunction(parameter)) {
-            if (isFunction(comparator)) {
-                super(parameter, comparator);
-            }
-            else {
-                super(parameter);
-            }
-        }
+        super(parameter, comparator || useCompare);
+        Object.defineProperty(this, "Statistics", {
+            value: StatisticsSymbol,
+            enumerable: false,
+            writable: false,
+            configurable: false
+        });
+        Object.freeze(this);
     }
-    count() {
-        return BigInt(this.ordered.length);
-    }
-    maximum(argument1) {
-        if (invalidate(argument1)) {
-            if (!this.isEmpty()) {
-                return this.collect(() => {
-                    return Optional.ofNullable();
-                }, (result, element) => {
-                    if (result.isEmpty()) {
-                        return Optional.of(element);
-                    }
-                    else {
-                        let current = result.get();
-                        if (useCompare(current, element) > 0) {
-                            return Optional.of(element);
-                        }
-                        else {
-                            return result;
-                        }
-                    }
-                }, (result) => result);
-            }
-            else {
-                return Optional.ofNullable();
-            }
+    *[Symbol.iterator]() {
+        try {
+            let collector = useToGeneratorFunction();
+            yield* collector.collect(this.source());
         }
-        else {
-            let comparator = argument1;
-            if (!this.isEmpty()) {
-                return this.collect(() => {
-                    return Optional.ofNullable();
-                }, (result, element) => {
-                    if (result.isEmpty()) {
-                        return Optional.of(element);
-                    }
-                    else {
-                        let current = result.get();
-                        if (comparator(current, element) > 0) {
-                            return Optional.of(element);
-                        }
-                        else {
-                            return result;
-                        }
-                    }
-                }, (result) => result);
-            }
+        catch (error) {
+            throw new Error("Uncaught error on Generator.");
         }
-        return Optional.ofNullable();
-    }
-    minimum(argument1) {
-        if (invalidate(argument1)) {
-            if (!this.isEmpty()) {
-                return this.collect(() => {
-                    return Optional.ofNullable();
-                }, (result, element) => {
-                    if (result.isEmpty()) {
-                        return Optional.of(element);
-                    }
-                    else {
-                        let current = result.get();
-                        if (useCompare(current, element) < 0) {
-                            return Optional.of(element);
-                        }
-                        else {
-                            return result;
-                        }
-                    }
-                }, (result) => result);
-            }
-            else {
-                return Optional.ofNullable();
-            }
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            let collector = useToAsyncGeneratorFunction();
+            yield* collector.collect(this.source());
         }
-        else {
-            let comparator = argument1;
-            if (!this.isEmpty()) {
-                return this.collect(() => {
-                    return Optional.ofNullable();
-                }, (result, element) => {
-                    if (result.isEmpty()) {
-                        return Optional.of(element);
-                    }
-                    else {
-                        let current = result.get();
-                        if (comparator(current, element) < 0) {
-                            return Optional.of(element);
-                        }
-                        else {
-                            return result;
-                        }
-                    }
-                }, (result) => result);
-            }
-            return Optional.ofNullable();
+        catch (error) {
+            throw new Error("Uncaught error on AsyncGenerator.");
         }
     }
+    count() {
+        return BigInt(this.buffer.length);
+    }
+    frequency() {
+        return useFrequency().collect(this.source());
+    }
 }
 ;
+Object.freeze(Statistics);
+Object.freeze(Statistics.prototype);
+Object.freeze(Object.getPrototypeOf(Statistics));
 export class NumericStatistics extends Statistics {
     NumericStatistics = NumericStatisticsSymbol;
     constructor(parameter, comparator) {
-        if (isIterable(parameter)) {
-            if (isFunction(comparator)) {
-                super(parameter, comparator);
-            }
-            else {
-                super(parameter);
-            }
+        super(parameter, comparator || useCompare);
+        Object.defineProperty(this, "NumericStatistics", {
+            value: NumericStatisticsSymbol,
+            enumerable: false,
+            writable: false,
+            configurable: false
+        });
+        Object.freeze(this);
+    }
+    *[Symbol.iterator]() {
+        try {
+            let collector = useToGeneratorFunction();
+            yield* collector.collect(this.source());
         }
-        else if (isFunction(parameter)) {
-            if (isFunction(comparator)) {
-                super(parameter, comparator);
-            }
-            else {
-                super(parameter);
+        catch (error) {
+            throw new Error("Uncaught error on Generator.");
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            let collector = useToAsyncGeneratorFunction();
+            yield* collector.collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on AsyncGenerator.");
+        }
+    }
+    average(mapper) {
+        if (this.isEmpty()) {
+            return 0;
+        }
+        try {
+            if (isFunction(mapper)) {
+                return useNumericAverage(mapper).collect(this.source());
             }
+            return useNumericAverage().collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on average.");
         }
     }
     range(argument1) {
         if (this.isEmpty()) {
             return 0;
         }
-        if (invalidate(argument1)) {
-            let minimum = this.ordered[0].value;
-            let maximum = this.ordered[0].value;
-            for (let i = 1; i < this.ordered.length; i++) {
-                let current = this.ordered[i].value;
-                if (useCompare(current, minimum) < 0) {
-                    minimum = current;
-                }
-                if (useCompare(current, maximum) > 0) {
-                    maximum = current;
-                }
-            }
-            return useCompare(maximum, minimum);
-        }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
-            let minimum = mapper(this.ordered[0].value);
-            let maximum = mapper(this.ordered[0].value);
-            for (let i = 1; i < this.ordered.length; i++) {
-                let current = mapper(this.ordered[i].value);
-                if (current < minimum) {
-                    minimum = current;
-                }
-                if (current > maximum) {
-                    maximum = current;
-                }
+        try {
+            if (this.count() === 1n) {
+                return 0;
             }
-            return maximum - minimum;
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            let count = this.buffer.length;
+            let minimum = this.buffer[0].element;
+            let maximum = this.buffer[count - 1].element;
+            return mapper(maximum) - mapper(minimum);
+        }
+        catch (error) {
+            throw new Error("Uncaught error on range.");
         }
-        throw new TypeError("Invalid arguments.");
     }
     variance(argument1) {
         if (this.isEmpty() || this.count() === 1n) {
             return 0;
         }
-        if (invalidate(argument1)) {
-            let mean = this.mean();
-            let summate = this.summate();
-            return (summate / Number(this.count())) - (mean * mean);
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useNumericVariance(mapper).collect(this.source());
         }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
-            let mean = this.mean(mapper);
-            let summate = this.summate(mapper);
-            return (summate / Number(this.count())) - (mean * mean);
+        catch (error) {
+            throw new Error("Uncaught error on variance.");
         }
-        throw new TypeError("Invalid arguments.");
     }
     standardDeviation(argument1) {
-        if (invalidate(argument1)) {
-            return Math.sqrt(this.variance());
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useNumericStandardDeviation(mapper).collect(this.source());
         }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
-            let variance = this.variance(mapper);
-            return Math.sqrt(variance);
+        catch (error) {
+            throw new Error("Uncaught error on standardDeviation.");
         }
-        throw new TypeError("Invalid arguments.");
     }
     mean(argument1) {
         if (this.isEmpty()) {
             return 0;
         }
-        if (invalidate(argument1)) {
-            let summate = this.summate();
-            return summate / Number(this.count());
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useNumericAverage(mapper).collect(this.source());
         }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
-            let summate = this.summate(mapper);
-            return summate / Number(this.count());
+        catch (error) {
+            throw new Error("Uncaught error on mean.");
         }
-        throw new TypeError("Invalid arguments.");
     }
     median(argument1) {
         if (this.isEmpty()) {
             return 0;
         }
-        if (invalidate(argument1)) {
-            let count = Number(this.count());
-            let middle = Math.floor(count / 2);
-            let median = Number(this.ordered[middle].value);
-            if (count % 2 === 0) {
-                median = (median + Number(this.ordered[middle - 1].value)) / 2;
-            }
-            return median;
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useNumericMedian(mapper).collect(this.source());
         }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
-            let count = Number(this.count());
-            let middle = Math.floor(count / 2);
-            let median = mapper(this.ordered[middle].value);
-            if (count % 2 === 0) {
-                median = (median + mapper(this.ordered[middle - 1].value)) / 2;
-            }
-            return median;
+        catch (error) {
+            throw new Error("Uncaught error on median.");
         }
-        throw new TypeError("Invalid arguments.");
     }
     mode(argument1) {
         if (this.isEmpty()) {
             return 0;
         }
-        if (invalidate(argument1)) {
-            let frequency = this.frequency();
-            let mode = 0;
-            let maxFrequency = 0n;
-            for (let [value, freq] of frequency) {
-                if (freq > maxFrequency) {
-                    mode = value;
-                    maxFrequency = freq;
-                }
-            }
-            return mode;
-        }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
-            let frequency = this.frequency(mapper);
-            let mode = 0;
-            let maxFrequency = 0n;
-            for (let [value, freq] of frequency) {
-                if (freq > maxFrequency) {
-                    mode = value;
-                    maxFrequency = freq;
-                }
-            }
-            return mode;
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useNumericMode(mapper).collect(this.source());
         }
-        throw new TypeError("Invalid arguments.");
-    }
-    frequency(argument1) {
-        if (this.isEmpty()) {
-            return new Map();
-        }
-        if (invalidate(argument1)) {
-            let frequency = new Map();
-            for (let i = 0; i < this.ordered.length; i++) {
-                let current = Number(this.ordered[i].value);
-                let count = frequency.get(current) || 0n;
-                frequency.set(current, count + 1n);
-            }
-            return frequency;
-        }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
-            let frequency = new Map();
-            for (let i = 0; i < this.ordered.length; i++) {
-                let current = mapper(this.ordered[i].value);
-                let count = frequency.get(current) || 0n;
-                frequency.set(current, count + 1n);
-            }
-            return frequency;
+        catch (error) {
+            throw new Error("Uncaught error on mode.");
         }
-        throw new TypeError("Invalid arguments.");
     }
     summate(argument1) {
         if (this.isEmpty()) {
             return 0;
         }
-        if (invalidate(argument1)) {
-            let summate = 0;
-            for (let i = 0; i < this.ordered.length; i++) {
-                let current = Number(this.ordered[i].value);
-                summate += current;
-            }
-            return summate;
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useNumericSummate(mapper).collect(this.source());
         }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
-            let summate = 0;
-            for (let i = 0; i < this.ordered.length; i++) {
-                let current = mapper(this.ordered[i].value);
-                summate += current;
-            }
-            return summate;
+        catch (error) {
+            throw new Error("Uncaught error on summate.");
         }
-        throw new TypeError("Invalid arguments.");
     }
     quantile(quantile, argument1) {
         if (this.isEmpty()) {
@@ -332,64 +182,40 @@ export class NumericStatistics extends Statistics {
         if (quantile < 0 || quantile > 1) {
             throw new RangeError("Invalid quantile.");
         }
-        if (invalidate(argument1)) {
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
             let count = Number(this.count());
             let index = Math.floor(quantile * count);
             if (index === count) {
                 index--;
             }
-            let value = Number(this.ordered[index].value);
+            let value = mapper(this.buffer[index].element);
             return value;
         }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
-            let count = Number(this.count());
-            let index = Math.floor(quantile * count);
-            if (index === count) {
-                index--;
-            }
-            let value = mapper(this.ordered[index].value);
-            return value;
+        catch (error) {
+            throw new Error("Uncaught error on quantile.");
         }
-        throw new TypeError("Invalid arguments.");
     }
     interquartileRange(argument1) {
         if (this.isEmpty()) {
             return 0;
         }
-        if (invalidate(argument1)) {
-            let lower = this.quantile(0.25);
-            let upper = this.quantile(0.75);
-            return upper - lower;
-        }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
             let lower = this.quantile(0.25, mapper);
             let upper = this.quantile(0.75, mapper);
             return upper - lower;
         }
-        throw new TypeError("Invalid arguments.");
+        catch (error) {
+            throw new Error("Uncaught error on interquartileRange.");
+        }
     }
     skewness(argument1) {
         if (this.isEmpty()) {
             return 0;
         }
-        if (invalidate(argument1)) {
-            let mean = this.mean();
-            let standardDeviation = this.standardDeviation();
-            if (standardDeviation === 0) {
-                return 0;
-            }
-            let data = this.toArray();
-            let summate = 0;
-            for (let value of data) {
-                let z = (value - mean) / standardDeviation;
-                summate += Math.pow(z, 3);
-            }
-            return summate / data.length;
-        }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
             let mean = this.mean(mapper);
             let standardDeviation = this.standardDeviation(mapper);
             if (standardDeviation === 0) {
@@ -403,28 +229,16 @@ export class NumericStatistics extends Statistics {
             }
             return summate / data.length;
         }
-        throw new TypeError("Invalid arguments.");
+        catch (error) {
+            throw new Error("Uncaught error on skewness.");
+        }
     }
     kurtosis(argument1) {
         if (this.isEmpty()) {
             return 0;
         }
-        if (invalidate(argument1)) {
-            let mean = this.mean();
-            let standardDeviation = this.standardDeviation();
-            if (standardDeviation === 0) {
-                return 0;
-            }
-            let data = this.toArray();
-            let summate = 0;
-            for (let value of data) {
-                let z = (value - mean) / standardDeviation;
-                summate += Math.pow(z, 4);
-            }
-            return summate / (data.length * data.length) - 3;
-        }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
             let mean = this.mean(mapper);
             let standardDeviation = this.standardDeviation(mapper);
             if (standardDeviation === 0) {
@@ -438,277 +252,183 @@ export class NumericStatistics extends Statistics {
             }
             return summate / (data.length * data.length) - 3;
         }
-        throw new TypeError("Invalid arguments.");
+        catch (error) {
+            throw new Error("Uncaught error on kurtosis.");
+        }
     }
 }
 ;
+Object.freeze(NumericStatistics);
+Object.freeze(NumericStatistics.prototype);
+Object.freeze(Object.getPrototypeOf(NumericStatistics));
 export class BigIntStatistics extends Statistics {
     BigIntStatistics = BigIntStatisticsSymbol;
     constructor(parameter, comparator) {
-        if (isIterable(parameter)) {
-            if (isFunction(comparator)) {
-                super(parameter, comparator);
-            }
-            else {
-                super(parameter);
-            }
+        super(parameter, comparator || useCompare);
+        Object.defineProperty(this, "BigIntStatistics", {
+            value: BigIntStatisticsSymbol,
+            enumerable: false,
+            writable: false,
+            configurable: false
+        });
+        Object.freeze(this);
+    }
+    *[Symbol.iterator]() {
+        try {
+            let collector = useToGeneratorFunction();
+            yield* collector.collect(this.source());
         }
-        else if (isFunction(parameter)) {
-            if (isFunction(comparator)) {
-                super(parameter, comparator);
-            }
-            else {
-                super(parameter);
-            }
+        catch (error) {
+            throw new Error("Uncaught error on Generator.");
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            let collector = useToAsyncGeneratorFunction();
+            yield* collector.collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on AsyncGenerator.");
+        }
+    }
+    average(argument1) {
+        if (this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useBigIntAverage(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on average.");
         }
     }
     range(argument1) {
         if (this.isEmpty()) {
             return 0n;
         }
-        if (invalidate(argument1)) {
-            let minimum = this.ordered[0].value;
-            let maximum = this.ordered[0].value;
-            for (let i = 1; i < this.ordered.length; i++) {
-                let current = this.ordered[i].value;
-                if (useCompare(current, minimum) < 0) {
-                    minimum = current;
-                }
-                if (useCompare(current, maximum) > 0) {
-                    maximum = current;
-                }
-            }
-            return BigInt(useCompare(maximum, minimum));
-        }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
-            let minimum = mapper(this.ordered[0].value);
-            let maximum = mapper(this.ordered[0].value);
-            for (let i = 1; i < this.ordered.length; i++) {
-                let current = mapper(this.ordered[i].value);
-                if (current < minimum) {
-                    minimum = current;
-                }
-                if (current > maximum) {
-                    maximum = current;
-                }
-            }
-            return maximum - minimum;
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let count = this.buffer.length;
+            let minimum = this.buffer[0].element;
+            let maximum = this.buffer[count - 1].element;
+            return mapper(maximum) - mapper(minimum);
+        }
+        catch (error) {
+            throw new Error("Uncaught error on range.");
         }
-        throw new TypeError("Invalid arguments.");
     }
     variance(argument1) {
         if (this.isEmpty() || this.count() === 1n) {
             return 0n;
         }
-        if (invalidate(argument1)) {
-            let mean = this.mean();
-            let summate = this.summate();
-            return (summate / this.count()) - (mean * mean);
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useBigIntVariance(mapper).collect(this.source());
         }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
-            let mean = this.mean(mapper);
-            let summate = this.summate(mapper);
-            return (summate / this.count()) - (mean * mean);
+        catch (error) {
+            throw new Error("Uncaught error on variance.");
         }
-        throw new TypeError("Invalid arguments.");
     }
     standardDeviation(argument1) {
-        if (invalidate(argument1)) {
-            return BigInt(Math.sqrt(Number(this.variance())));
-        }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
             let variance = this.variance(mapper);
             return BigInt(Math.sqrt(Number(variance)));
         }
-        throw new TypeError("Invalid arguments.");
+        catch (error) {
+            throw new Error("Uncaught error on standardDeviation.");
+        }
     }
     mean(argument1) {
         if (this.isEmpty()) {
             return 0n;
         }
-        if (invalidate(argument1)) {
-            let summate = this.summate();
-            return summate / this.count();
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useBigIntAverage(mapper).collect(this.source());
         }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
-            let summate = this.summate(mapper);
-            return summate / this.count();
+        catch (error) {
+            throw new Error("Uncaught error on mean.");
         }
-        throw new TypeError("Invalid arguments.");
     }
     median(argument1) {
         if (this.isEmpty()) {
             return 0n;
         }
-        if (invalidate(argument1)) {
-            let count = Number(this.count());
-            let middle = Math.floor(count / 2);
-            let median = BigInt(Number(this.ordered[middle].value));
-            if (count % 2 === 0) {
-                median = (median + BigInt(Number(this.ordered[middle - 1].value))) / 2n;
-                return median;
-            }
-            return median;
-        }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
-            let count = this.count();
-            let middle = count / 2n;
-            let median = mapper(this.ordered[Number(middle)].value);
-            if (count % 2n === 0n) {
-                median = (median + mapper(this.ordered[Number(middle - 1n)].value)) / 2n;
-            }
-            return median;
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useBigIntMedian(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on median.");
         }
-        throw new TypeError("Invalid arguments.");
     }
     mode(argument1) {
         if (this.isEmpty()) {
             return 0n;
         }
-        if (invalidate(argument1)) {
-            let frequency = this.frequency();
-            let mode = 0n;
-            let maxFrequency = 0n;
-            for (let [value, freq] of frequency) {
-                if (freq > maxFrequency) {
-                    mode = value;
-                    maxFrequency = freq;
-                }
-            }
-            return mode;
-        }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
-            let frequency = this.frequency(mapper);
-            let mode = 0n;
-            let maxFrequency = 0n;
-            for (let [value, frequence] of frequency) {
-                if (frequence > maxFrequency) {
-                    mode = value;
-                    maxFrequency = frequence;
-                }
-            }
-            return mode;
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useBigIntMode(mapper).collect(this.source());
         }
-        throw new TypeError("Invalid arguments.");
-    }
-    frequency(argument1) {
-        if (this.isEmpty()) {
-            return new Map();
-        }
-        if (invalidate(argument1)) {
-            let frequency = new Map();
-            for (let i = 0; i < this.ordered.length; i++) {
-                let current = BigInt(Number(this.ordered[i].value));
-                let count = frequency.get(current) || 0n;
-                frequency.set(current, count + 1n);
-            }
-            return frequency;
-        }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
-            let frequency = new Map();
-            for (let i = 0; i < this.ordered.length; i++) {
-                let current = mapper(this.ordered[i].value);
-                let count = frequency.get(current) || 0n;
-                frequency.set(current, count + 1n);
-            }
-            return frequency;
+        catch (error) {
+            throw new Error("Uncaught error on mode.");
         }
-        throw new TypeError("Invalid arguments.");
     }
     summate(argument1) {
         if (this.isEmpty()) {
             return 0n;
         }
-        if (invalidate(argument1)) {
-            let summate = 0n;
-            for (let i = 0; i < this.ordered.length; i++) {
-                let current = BigInt(Number(this.ordered[i].value));
-                summate += current;
-            }
-            return summate;
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useBigIntSummate(mapper).collect(this.source());
         }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
-            let summate = 0n;
-            for (let i = 0; i < this.ordered.length; i++) {
-                let current = mapper(this.ordered[i].value);
-                summate += current;
-            }
-            return summate;
+        catch (error) {
+            throw new Error("Uncaught error on summate.");
         }
-        throw new TypeError("Invalid arguments.");
     }
-    quantile(quantile, mapper) {
+    quantile(quantile, argument1) {
         if (this.isEmpty()) {
             return 0n;
         }
         if (typeof quantile !== "number" || quantile < 0 || quantile > 1) {
             throw new RangeError("Invalid quantile.");
         }
-        if (invalidate(mapper)) {
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
             let count = Number(this.count());
             let index = Math.floor(quantile * count);
             if (index === count) {
                 index--;
             }
-            let value = BigInt(Number(this.ordered[index].value));
+            let value = mapper(this.buffer[index].element);
             return value;
         }
-        else if (isFunction(mapper)) {
-            let count = Number(this.count());
-            let index = Math.floor(quantile * count);
-            if (index === count) {
-                index--;
-            }
-            let value = mapper(this.ordered[index].value);
-            return value;
+        catch (error) {
+            throw new Error("Uncaught error on quantile.");
         }
-        throw new TypeError("Invalid arguments.");
     }
     interquartileRange(argument1) {
         if (this.isEmpty()) {
             return 0n;
         }
-        if (invalidate(argument1)) {
-            let lower = this.quantile(0.25);
-            let upper = this.quantile(0.75);
-            return upper - lower;
-        }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
             let lower = this.quantile(0.25, mapper);
             let upper = this.quantile(0.75, mapper);
             return upper - lower;
         }
-        throw new TypeError("Invalid arguments.");
+        catch (error) {
+            throw new Error("Uncaught error on interquartileRange.");
+        }
     }
     skewness(argument1) {
         if (this.isEmpty()) {
             return 0n;
         }
-        if (invalidate(argument1)) {
-            let mean = this.mean();
-            let standardDeviation = this.standardDeviation();
-            if (standardDeviation === 0n) {
-                return 0n;
-            }
-            let data = this.toArray();
-            let summate = 0n;
-            for (let value of data) {
-                let z = BigInt(Number(value)) - mean;
-                summate += z * z * z;
-            }
-            return summate / BigInt(data.length);
-        }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
             let mean = this.mean(mapper);
             let standardDeviation = this.standardDeviation(mapper);
             if (standardDeviation === 0n) {
@@ -722,29 +442,16 @@ export class BigIntStatistics extends Statistics {
             }
             return summate / BigInt(data.length);
         }
-        throw new TypeError("Invalid arguments.");
+        catch (error) {
+            throw new Error("Uncaught error on skewness.");
+        }
     }
     kurtosis(argument1) {
         if (this.isEmpty()) {
             return 0n;
         }
-        if (invalidate(argument1)) {
-            let mean = this.mean();
-            let standardDeviation = this.standardDeviation();
-            if (standardDeviation === 0n) {
-                return 0n;
-            }
-            let data = this.toArray();
-            let summate = 0n;
-            let count = data.length;
-            for (let value of data) {
-                let z = BigInt(Number(value)) - mean;
-                summate += z * z * z * z;
-            }
-            return summate / BigInt(count * count) - 3n;
-        }
-        else if (isFunction(argument1)) {
-            let mapper = argument1;
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
             let mean = this.mean(mapper);
             let standardDeviation = this.standardDeviation(mapper);
             if (standardDeviation === 0n) {
@@ -759,7 +466,12 @@ export class BigIntStatistics extends Statistics {
             }
             return summate / BigInt(count * count) - 3n;
         }
-        throw new TypeError("Invalid arguments.");
+        catch (error) {
+            throw new Error("Uncaught error on kurtosis.");
+        }
     }
 }
 ;
+Object.freeze(BigIntStatistics);
+Object.freeze(BigIntStatistics.prototype);
+Object.freeze(Object.getPrototypeOf(BigIntStatistics));