semantic-typescript 0.4.1 → 0.5.3

package/dist/statistics.d.ts

@@ -1,97 +0,0 @@
-import { OrderedCollectable } from "./collectable";
-import type { Comparator, Functional, Generator } from "./utility";
-export declare abstract class Statistics<E, D extends number | bigint> extends OrderedCollectable<E> {
-    protected readonly Statistics: symbol;
-    constructor(generator: Generator<E>);
-    constructor(generator: Generator<E>, comparator: Comparator<E>);
-    [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
-    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
-    count(): bigint;
-    abstract average(): D;
-    abstract average(mapper: Functional<E, D>): D;
-    abstract range(): D;
-    abstract range(mapper: Functional<E, D>): D;
-    abstract variance(): D;
-    abstract variance(mapper: Functional<E, D>): D;
-    abstract standardDeviation(): D;
-    abstract standardDeviation(mapper: Functional<E, D>): D;
-    abstract mean(): D;
-    abstract mean(mapper: Functional<E, D>): D;
-    abstract median(): D;
-    abstract median(mapper: Functional<E, D>): D;
-    abstract mode(): D;
-    abstract mode(mapper: Functional<E, D>): D;
-    frequency(): Map<E, bigint>;
-    abstract summate(): D;
-    abstract summate(mapper: Functional<E, D>): D;
-    abstract quantile(quantile: number): D;
-    abstract quantile(quantile: number, mapper: Functional<E, D>): D;
-    abstract interquartileRange(): D;
-    abstract interquartileRange(mapper: Functional<E, D>): D;
-    abstract skewness(): D;
-    abstract skewness(mapper: Functional<E, D>): D;
-    abstract kurtosis(): D;
-    abstract kurtosis(mapper: Functional<E, D>): D;
-}
-export declare class NumericStatistics<E> extends Statistics<E, number> {
-    protected readonly NumericStatistics: symbol;
-    constructor(generator: Generator<E>);
-    constructor(generator: Generator<E>, comparator: Comparator<E>);
-    [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
-    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
-    average(): number;
-    average(mapper: Functional<E, number>): number;
-    range(): number;
-    range(mapper: Functional<E, number>): number;
-    variance(): number;
-    variance(mapper: Functional<E, number>): number;
-    standardDeviation(): number;
-    standardDeviation(mapper: Functional<E, number>): number;
-    mean(): number;
-    mean(mapper: Functional<E, number>): number;
-    median(): number;
-    median(mapper: Functional<E, number>): number;
-    mode(): number;
-    mode(mapper: Functional<E, number>): number;
-    summate(): number;
-    summate(mapper: Functional<E, number>): number;
-    quantile(quantile: number): number;
-    quantile(quantile: number, mapper: Functional<E, number>): number;
-    interquartileRange(): number;
-    interquartileRange(mapper: Functional<E, number>): number;
-    skewness(): number;
-    skewness(mapper: Functional<E, number>): number;
-    kurtosis(): number;
-    kurtosis(mapper: Functional<E, number>): number;
-}
-export declare class BigIntStatistics<E> extends Statistics<E, bigint> {
-    protected readonly BigIntStatistics: symbol;
-    constructor(generator: Generator<E>);
-    constructor(generator: Generator<E>, comparator: Comparator<E>);
-    [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
-    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
-    average(): bigint;
-    average(mapper: Functional<E, bigint>): bigint;
-    range(): bigint;
-    range(mapper: Functional<E, bigint>): bigint;
-    variance(): bigint;
-    variance(mapper: Functional<E, bigint>): bigint;
-    standardDeviation(): bigint;
-    standardDeviation(mapper: Functional<E, bigint>): bigint;
-    mean(): bigint;
-    mean(mapper: Functional<E, bigint>): bigint;
-    median(): bigint;
-    median(mapper: Functional<E, bigint>): bigint;
-    mode(): bigint;
-    mode(mapper: Functional<E, bigint>): bigint;
-    summate(): bigint;
-    summate(mapper: Functional<E, bigint>): bigint;
-    quantile(quantile: number): bigint;
-    quantile(quantile: number, mapper: Functional<E, bigint>): bigint;
-    interquartileRange(): bigint;
-    interquartileRange(mapper: Functional<E, bigint>): bigint;
-    skewness(): bigint;
-    skewness(mapper: Functional<E, bigint>): bigint;
-    kurtosis(): bigint;
-    kurtosis(mapper: Functional<E, bigint>): bigint;
-}

package/dist/statistics.js

@@ -1,483 +0,0 @@
-import { OrderedCollectable } from "./collectable";
-import { Collector, useBigIntAverage, useBigIntMedian, useBigIntMode, useBigIntSummate, useBigIntVariance, useFrequency, useNumericAverage, useNumericMedian, useNumericMode, useNumericStandardDeviation, useNumericSummate, useNumericVariance, useToArray } from "./collector";
-import { isFunction } from "./guard";
-import { useCompare, useToBigInt, useToNumber } from "./hook";
-import { StatisticsSymbol, NumericStatisticsSymbol, BigIntStatisticsSymbol } from "./symbol";
-export class Statistics extends OrderedCollectable {
-    Statistics = StatisticsSymbol;
-    constructor(parameter, comparator) {
-        super(parameter, comparator || useCompare);
-        Object.defineProperties(this, {
-            "Statistics": {
-                value: StatisticsSymbol,
-                enumerable: false,
-                writable: false,
-                configurable: false
-            }
-        });
-        Object.freeze(this);
-    }
-    *[Symbol.iterator]() {
-        try {
-            let collector = useToArray();
-            yield* collector.collect(this.source());
-        }
-        catch (error) {
-            throw new Error("Uncaught error on Generator.");
-        }
-    }
-    async *[Symbol.asyncIterator]() {
-        try {
-            let collector = useToArray();
-            yield* collector.collect(this.source());
-        }
-        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) {
-        super(parameter, comparator || useCompare);
-        Object.defineProperties(this, {
-            "NumericStatistics": {
-                value: NumericStatisticsSymbol,
-                enumerable: false,
-                writable: false,
-                configurable: false
-            }
-        });
-        Object.freeze(this);
-    }
-    *[Symbol.iterator]() {
-        try {
-            let collector = useToArray();
-            yield* collector.collect(this.source());
-        }
-        catch (error) {
-            throw new Error("Uncaught error on Generator.");
-        }
-    }
-    async *[Symbol.asyncIterator]() {
-        try {
-            let collector = useToArray();
-            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;
-        }
-        try {
-            if (this.count() === 1n) {
-                return 0;
-            }
-            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.");
-        }
-    }
-    variance(argument1) {
-        if (this.isEmpty() || this.count() === 1n) {
-            return 0;
-        }
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
-            return useNumericVariance(mapper).collect(this.source());
-        }
-        catch (error) {
-            throw new Error("Uncaught error on variance.");
-        }
-    }
-    standardDeviation(argument1) {
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
-            return useNumericStandardDeviation(mapper).collect(this.source());
-        }
-        catch (error) {
-            throw new Error("Uncaught error on standardDeviation.");
-        }
-    }
-    mean(argument1) {
-        if (this.isEmpty()) {
-            return 0;
-        }
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
-            return useNumericAverage(mapper).collect(this.source());
-        }
-        catch (error) {
-            throw new Error("Uncaught error on mean.");
-        }
-    }
-    median(argument1) {
-        if (this.isEmpty()) {
-            return 0;
-        }
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
-            return useNumericMedian(mapper).collect(this.source());
-        }
-        catch (error) {
-            throw new Error("Uncaught error on median.");
-        }
-    }
-    mode(argument1) {
-        if (this.isEmpty()) {
-            return 0;
-        }
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
-            return useNumericMode(mapper).collect(this.source());
-        }
-        catch (error) {
-            throw new Error("Uncaught error on mode.");
-        }
-    }
-    summate(argument1) {
-        if (this.isEmpty()) {
-            return 0;
-        }
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
-            return useNumericSummate(mapper).collect(this.source());
-        }
-        catch (error) {
-            throw new Error("Uncaught error on summate.");
-        }
-    }
-    quantile(quantile, argument1) {
-        if (this.isEmpty()) {
-            return 0;
-        }
-        if (quantile < 0 || quantile > 1) {
-            throw new RangeError("Invalid quantile.");
-        }
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
-            let count = Number(this.count());
-            let index = Math.floor(quantile * count);
-            if (index === count) {
-                index--;
-            }
-            let value = mapper(this.buffer[index].element);
-            return value;
-        }
-        catch (error) {
-            throw new Error("Uncaught error on quantile.");
-        }
-    }
-    interquartileRange(argument1) {
-        if (this.isEmpty()) {
-            return 0;
-        }
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
-            let lower = this.quantile(0.25, mapper);
-            let upper = this.quantile(0.75, mapper);
-            return upper - lower;
-        }
-        catch (error) {
-            throw new Error("Uncaught error on interquartileRange.");
-        }
-    }
-    skewness(argument1) {
-        if (this.isEmpty()) {
-            return 0;
-        }
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
-            let mean = this.mean(mapper);
-            let standardDeviation = this.standardDeviation(mapper);
-            if (standardDeviation === 0) {
-                return 0;
-            }
-            let data = this.toArray().map(item => mapper(item));
-            let summate = 0;
-            for (let value of data) {
-                let z = (value - mean) / standardDeviation;
-                summate += Math.pow(z, 3);
-            }
-            return summate / data.length;
-        }
-        catch (error) {
-            throw new Error("Uncaught error on skewness.");
-        }
-    }
-    kurtosis(argument1) {
-        if (this.isEmpty()) {
-            return 0;
-        }
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
-            let mean = this.mean(mapper);
-            let standardDeviation = this.standardDeviation(mapper);
-            if (standardDeviation === 0) {
-                return 0;
-            }
-            let data = this.toArray().map(item => mapper(item));
-            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;
-        }
-        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) {
-        super(parameter, comparator || useCompare);
-        Object.defineProperties(this, {
-            "BigIntStatistics": {
-                value: BigIntStatisticsSymbol,
-                enumerable: false,
-                writable: false,
-                configurable: false
-            }
-        });
-        Object.freeze(this);
-    }
-    *[Symbol.iterator]() {
-        try {
-            let collector = useToArray();
-            yield* collector.collect(this.source());
-        }
-        catch (error) {
-            throw new Error("Uncaught error on Generator.");
-        }
-    }
-    async *[Symbol.asyncIterator]() {
-        try {
-            let collector = useToArray();
-            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;
-        }
-        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.");
-        }
-    }
-    variance(argument1) {
-        if (this.isEmpty() || this.count() === 1n) {
-            return 0n;
-        }
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
-            return useBigIntVariance(mapper).collect(this.source());
-        }
-        catch (error) {
-            throw new Error("Uncaught error on variance.");
-        }
-    }
-    standardDeviation(argument1) {
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
-            let variance = this.variance(mapper);
-            return BigInt(Math.sqrt(Number(variance)));
-        }
-        catch (error) {
-            throw new Error("Uncaught error on standardDeviation.");
-        }
-    }
-    mean(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 mean.");
-        }
-    }
-    median(argument1) {
-        if (this.isEmpty()) {
-            return 0n;
-        }
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
-            return useBigIntMedian(mapper).collect(this.source());
-        }
-        catch (error) {
-            throw new Error("Uncaught error on median.");
-        }
-    }
-    mode(argument1) {
-        if (this.isEmpty()) {
-            return 0n;
-        }
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
-            return useBigIntMode(mapper).collect(this.source());
-        }
-        catch (error) {
-            throw new Error("Uncaught error on mode.");
-        }
-    }
-    summate(argument1) {
-        if (this.isEmpty()) {
-            return 0n;
-        }
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
-            return useBigIntSummate(mapper).collect(this.source());
-        }
-        catch (error) {
-            throw new Error("Uncaught error on summate.");
-        }
-    }
-    quantile(quantile, argument1) {
-        if (this.isEmpty()) {
-            return 0n;
-        }
-        if (typeof quantile !== "number" || quantile < 0 || quantile > 1) {
-            throw new RangeError("Invalid quantile.");
-        }
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
-            let count = Number(this.count());
-            let index = Math.floor(quantile * count);
-            if (index === count) {
-                index--;
-            }
-            let value = mapper(this.buffer[index].element);
-            return value;
-        }
-        catch (error) {
-            throw new Error("Uncaught error on quantile.");
-        }
-    }
-    interquartileRange(argument1) {
-        if (this.isEmpty()) {
-            return 0n;
-        }
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
-            let lower = this.quantile(0.25, mapper);
-            let upper = this.quantile(0.75, mapper);
-            return upper - lower;
-        }
-        catch (error) {
-            throw new Error("Uncaught error on interquartileRange.");
-        }
-    }
-    skewness(argument1) {
-        if (this.isEmpty()) {
-            return 0n;
-        }
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
-            let mean = this.mean(mapper);
-            let standardDeviation = this.standardDeviation(mapper);
-            if (standardDeviation === 0n) {
-                return 0n;
-            }
-            let data = this.toArray().map(item => mapper(item));
-            let summate = 0n;
-            for (let value of data) {
-                let z = value - mean;
-                summate += z * z * z;
-            }
-            return summate / BigInt(data.length);
-        }
-        catch (error) {
-            throw new Error("Uncaught error on skewness.");
-        }
-    }
-    kurtosis(argument1) {
-        if (this.isEmpty()) {
-            return 0n;
-        }
-        try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
-            let mean = this.mean(mapper);
-            let standardDeviation = this.standardDeviation(mapper);
-            if (standardDeviation === 0n) {
-                return 0n;
-            }
-            let data = this.toArray().map(item => mapper(item));
-            let summate = 0n;
-            let count = data.length;
-            for (let value of data) {
-                let z = value - mean;
-                summate += z * z * z * z;
-            }
-            return summate / BigInt(count * count) - 3n;
-        }
-        catch (error) {
-            throw new Error("Uncaught error on kurtosis.");
-        }
-    }
-}
-;
-Object.freeze(BigIntStatistics);
-Object.freeze(BigIntStatistics.prototype);
-Object.freeze(Object.getPrototypeOf(BigIntStatistics));

package/dist/window.d.ts

@@ -1,12 +0,0 @@
-import { OrderedCollectable } from "./collectable";
-import type { Semantic } from "./semantic";
-import type { Comparator, Generator } from "./utility";
-export declare class WindowCollectable<E> extends OrderedCollectable<E> {
-    protected readonly WindowCollectable: symbol;
-    constructor(generator: Generator<E>);
-    constructor(generator: Generator<E>, comparator: Comparator<E>);
-    [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
-    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
-    slide(size: bigint, step?: bigint): Semantic<Semantic<E>>;
-    tumble(size: bigint): Semantic<Semantic<E>>;
-}

package/dist/window.js

@@ -1,72 +0,0 @@
-import { OrderedCollectable } from "./collectable";
-import { useToAsyncGeneratorFunction, useToGeneratorFunction } from "./collector";
-import { from } from "./factory";
-import { useCompare } from "./hook";
-import { WindowCollectableSymbol } from "./symbol";
-export class WindowCollectable extends OrderedCollectable {
-    WindowCollectable = WindowCollectableSymbol;
-    constructor(parameter, comparator = useCompare) {
-        super(parameter, comparator);
-        Object.defineProperties(this, {
-            "WindowCollectable": {
-                value: WindowCollectableSymbol,
-                writable: false,
-                enumerable: false,
-                configurable: false
-            }
-        });
-        Object.freeze(this);
-    }
-    *[Symbol.iterator]() {
-        try {
-            let collector = useToGeneratorFunction();
-            yield* collector.collect(this.source());
-        }
-        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.");
-        }
-    }
-    slide(size, step = 1n) {
-        if (size > 0n && step > 0n) {
-            try {
-                let source = this.toArray();
-                let windows = [];
-                let windowStartIndex = 0n;
-                while (windowStartIndex < BigInt(source.length)) {
-                    let windowEnd = windowStartIndex + size;
-                    let window = source.slice(Number(windowStartIndex), Number(windowEnd));
-                    if (window.length > 0) {
-                        windows.push(window);
-                    }
-                    windowStartIndex += step;
-                }
-                return from(windows).map((window) => from(window));
-            }
-            catch (error) {
-                throw new Error("Invalid arguments.");
-            }
-        }
-        throw new RangeError("Invalid arguments.");
-    }
-    tumble(size) {
-        try {
-            return this.slide(size, size);
-        }
-        catch (error) {
-            throw new Error("Invalid arguments.");
-        }
-    }
-}
-;
-Object.freeze(WindowCollectable);
-Object.freeze(WindowCollectable.prototype);
-Object.freeze(Object.getPrototypeOf(WindowCollectable));