semantic-typescript 0.0.8 → 0.2.5

package/dist/statistics.d.ts

@@ -0,0 +1,101 @@
+import { OrderedCollectable } from "./collectable";
+import { Optional } from "./optional";
+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(iterable: Iterable<E>);
+    constructor(iterable: Iterable<E>, comparator: Comparator<E>);
+    constructor(generator: Generator<E>);
+    constructor(generator: Generator<E>, comparator: Comparator<E>);
+    count(): bigint;
+    maximum(): Optional<E>;
+    maximum(comparator: Comparator<E>): Optional<E>;
+    minimum(): Optional<E>;
+    minimum(comparator: Comparator<E>): Optional<E>;
+    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;
+    abstract frequency(): Map<D, bigint>;
+    abstract frequency(mapper: Functional<E, D>): Map<D, 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(iterable: Iterable<E>);
+    constructor(iterable: Iterable<E>, comparator: Comparator<E>);
+    constructor(generator: Generator<E>);
+    constructor(generator: Generator<E>, comparator: Comparator<E>);
+    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;
+    frequency(): Map<number, bigint>;
+    frequency(mapper: Functional<E, number>): Map<number, bigint>;
+    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(iterable: Iterable<E>);
+    constructor(iterable: Iterable<E>, comparator: Comparator<E>);
+    constructor(generator: Generator<E>);
+    constructor(generator: Generator<E>, comparator: Comparator<E>);
+    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;
+    frequency(): Map<bigint, bigint>;
+    frequency(mapper: Functional<E, bigint>): Map<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;
+}