functionalscript 0.4.2 → 0.4.4

package/types/bigint/module.f.js

@@ -1,5 +1,5 @@
 /**
- * A collection of utility functions for working with `bigint` values.
+ * Utility functions for working with `bigint` values.
  *
  * @module
  *
@@ -14,14 +14,58 @@
  * const bitCount = bitLength(255n) // 8n
  * const bitmask = mask(5n) // 31n
  * const m = min(3n)(13n) // 3n
+ * const c = combination([3n, 2n, 1n]) // 60n
  * ```
  */
 import { unsafeCmp } from "../function/compare/module.f.js";
 import { reduce } from "../list/module.f.js";
+/**
+ * Adds two `bigint` values.
+ *
+ * @param a - The first bigint value.
+ * @returns A function that takes the second bigint value and returns the sum.
+ */
 export const addition = a => b => a + b;
+/**
+ * Calculates the sum of a list of `bigint` values.
+ *
+ * @param input - A list of bigint values.
+ * @returns The sum of all values in the list.
+ */
 export const sum = reduce(addition)(0n);
+/**
+ * Multiplies two `bigint` values.
+ *
+ * @param a - The first bigint value.
+ * @returns A function that takes the second bigint value and returns the product.
+ */
+export const multiple = a => b => a * b;
+/**
+ * Calculates the product of a list of `bigint` values.
+ *
+ * @param input - A list of bigint values.
+ * @returns The product of all values in the list.
+ */
+export const product = reduce(multiple)(1n);
+/**
+ * Calculates the absolute value of a `bigint`.
+ *
+ * @param a - The bigint value.
+ * @returns The absolute value of the input bigint.
+ */
 export const abs = a => a >= 0 ? a : -a;
+/**
+ * Determines the sign of a `bigint`.
+ * @param a - The bigint value.
+ * @returns `1` if positive, `-1` if negative, and `0` if zero.
+ */
 export const sign = (a) => unsafeCmp(a)(0n);
+/**
+ * Serializes a `bigint` to a string representation.
+ *
+ * @param a - The bigint value.
+ * @returns A string representation of the bigint (e.g., '123n').
+ */
 export const serialize = (a) => `${a}n`;
 const { isFinite } = Number;
 const { log2: mathLog2 } = Math;
@@ -139,6 +183,58 @@ export const bitLength = (v) => {
  */
 export const mask = (len) => (1n << len) - 1n;
 /**
- * A minimal value.
+ * Returns the smaller of two `bigint` values.
+ *
+ * @param a - The first bigint.
+ * @returns A function that takes the second bigint and returns the smaller value.
  */
 export const min = (a) => (b) => a < b ? a : b;
+/**
+ * Returns the larger of two `bigint` values.
+ *
+ * @param a - The first bigint.
+ * @returns A function that takes the second bigint and returns the larger value.
+ */
+export const max = (a) => (b) => a < b ? b : a;
+/**
+ * Calculates the partial factorial `b!/a!`.
+ *
+ * @param a - The starting bigint value.
+ * @returns A function that takes `b` and computes `b!/a!`.
+ */
+export const partialFactorial = (a) => (b) => {
+    let result = b;
+    while (true) {
+        --b;
+        if (b <= a) {
+            return result;
+        }
+        result *= b;
+    }
+};
+/**
+ * Calculates the factorial of a `bigint`.
+ *
+ * @param b - The bigint value.
+ * @returns The factorial of the input.
+ */
+export const factorial = partialFactorial(1n);
+/**
+ * Calculates the number of combinations for a list of `bigint` values.
+ *
+ * @param k - A list of bigint values.
+ * @returns The number of combinations.
+ */
+export const combination = (...k) => {
+    let s = 0n;
+    let m = 1n;
+    let p = 1n;
+    for (let i of k) {
+        s += i;
+        if (i >= m) {
+            [i, m] = [m, i];
+        }
+        p *= factorial(i);
+    }
+    return partialFactorial(m)(s) / p;
+};

package/types/bigint/test.f.d.ts

@@ -23,5 +23,9 @@ declare const _default: {
         big: () => void;
         neg: (() => void)[];
     };
+    factorial: () => void;
+    combination: () => void;
+    combination50x50: () => void;
+    combination3: () => void;
 };
 export default _default;

package/types/bigint/test.f.js

@@ -1,4 +1,4 @@
-import { sum, abs, serialize, log2, bitLength, mask, min } from "./module.f.js";
+import { sum, abs, serialize, log2, bitLength, mask, min, combination, factorial } from "./module.f.js";
 const oldLog2 = (v) => {
     if (v <= 0n) {
         return -1n;
@@ -174,15 +174,19 @@ export default {
         if (m !== 3n) {
             throw m;
         }
+        const c = combination(3n, 2n, 1n); // 60n
+        if (c !== 60n) {
+            throw c;
+        }
     },
     benchmark: () => {
         const list = {
-            strBinLog2,
-            strHexLog2,
+            // strBinLog2,
+            // strHexLog2,
             str32Log2,
-            oldLog2,
-            clz32Log2,
-            m1023log2,
+            // oldLog2,
+            // clz32Log2,
+            // m1023log2,
             log2,
         };
         const transform = (b) => Object.fromEntries(Object.entries(list).map(([k, f]) => [k, b(f)]));
@@ -391,5 +395,61 @@ export default {
                 }
             },
         ]
+    },
+    factorial: () => {
+        {
+            const r = factorial(3n);
+            if (r !== 6n) {
+                throw r;
+            }
+        }
+        {
+            const r = factorial(5n);
+            if (r !== 120n) {
+                throw r;
+            }
+        }
+    },
+    combination: () => {
+        const r = combination(2n, 3n);
+        if (r != 120n / (2n * 6n)) {
+            throw r;
+        }
+    },
+    combination50x50: () => {
+        {
+            const r = combination(1n, 1n);
+            if (r !== 2n) {
+                throw r;
+            }
+        }
+        {
+            const r = combination(2n, 2n);
+            if (r !== 6n) {
+                throw r;
+            }
+        }
+        {
+            const r = combination(3n, 3n);
+            if (r !== 20n) {
+                throw r;
+            }
+        }
+        {
+            const r = combination(4n, 4n);
+            if (r !== 70n) {
+                throw r;
+            }
+        }
+    },
+    combination3: () => {
+        const r = combination(2n, 3n, 4n, 2n);
+        // 2! * 3! * 4! * 2! : 2! * 2! * 3!
+        // 2+3+4+2 = 5*6*7*8*9*10*11
+        // e = 5 * 6 * 7 * 8 * 9 * 10 * 11 / (2n * 2n * 6n) =
+        // e = 5     * 7 * 2 * 9 * 10 * 11 = 69300
+        if (r !== 69300n) {
+            throw r;
+        }
     }
 };

package/types/bit_vec/module.f.d.ts

@@ -6,7 +6,7 @@ export type Vec = bigint;
 /**
  * An empty vector of bits.
  */
-export declare const empty = 1n;
+export declare const empty: Vec;
 /**
  * Calculates the length of the given vector of bits.
  */

package/types/monoid/module.f.d.ts

@@ -1,4 +1,4 @@
-import type { Reduce } from "../function/operator/module.f.ts";
+import type { Reduce } from '../function/operator/module.f.ts';
 /**
  * Represents a monoid, an algebraic structure with a binary operation
  * and an identity (neutral) element.
@@ -52,6 +52,8 @@ export type Monoid<T> = {
  * @returns A function that takes an element `a` and a repetition count `n`,
  * and returns the result of applying the operation `n` times.
  *
+ * See also {@link https://en.wikipedia.org/wiki/Exponentiation_by_squaring}.
+ *
  * @example
  *
  * ```ts

package/types/monoid/module.f.js

@@ -7,6 +7,8 @@
  * @returns A function that takes an element `a` and a repetition count `n`,
  * and returns the result of applying the operation `n` times.
  *
+ * See also {@link https://en.wikipedia.org/wiki/Exponentiation_by_squaring}.
+ *
  * @example
  *
  * ```ts

package/types/number/module.f.d.ts

@@ -4,3 +4,7 @@ export declare const sum: (input: List<number>) => number;
 export declare const min: (input: List<number>) => number | null;
 export declare const max: (input: List<number>) => number | null;
 export declare const cmp: (a: number) => (b: number) => Sign;
+/**
+ * Count a number of ones in 32 bit number
+ */
+export declare const countOnes: (n: number) => number;

package/types/number/module.f.js

@@ -5,3 +5,19 @@ export const sum = reduce(addition)(0);
 export const min = reduce(minOp)(null);
 export const max = reduce(maxOp)(null);
 export const cmp = unsafeCmp;
+const mo = [
+    [0x5555_5555, 1],
+    [0x3333_3333, 2],
+    [0x0F0F_0F0F, 4],
+    [0x00FF_00FF, 8],
+    [0x0000_FFFF, 16],
+];
+/**
+ * Count a number of ones in 32 bit number
+ */
+export const countOnes = (n) => {
+    for (const [mask, offset] of mo) {
+        n = (n & mask) + ((n >> offset) & mask);
+    }
+    return n;
+};

package/types/number/test.f.d.ts

@@ -7,5 +7,6 @@ declare const _default: {
     max: () => void;
     cmp: () => void;
     standard: () => void;
+    countOnes: (() => void)[];
 };
 export default _default;

package/types/number/test.f.js

@@ -1,4 +1,4 @@
-import { sum, min, max, cmp } from "./module.f.js";
+import { sum, min, max, cmp, countOnes } from "./module.f.js";
 export default {
     sum: () => {
         const result = sum([2, 3, 4, 5]);
@@ -34,7 +34,7 @@ export default {
     },
     standard: () => {
         const check = a => b => {
-            if (BigInt(Number(a)) != b) {
+            if (BigInt(Number(a)) !== b) {
                 throw [a, b];
             }
         };
@@ -119,5 +119,21 @@ export default {
         //      4_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_1234
         check(104002482718319358n)(104002482718319360n);
         check(142693895881191444n)(142693895881191440n);
-    }
+    },
+    countOnes: [
+        () => {
+            //                    1121 2231 = 5 + 8 = 13
+            const r = countOnes(0x1234_5678);
+            if (r !== 13) {
+                throw r;
+            }
+        },
+        () => {
+            //                    2232 3340 = 9 + 10 = 19
+            const r = countOnes(0x9ABC_DEF0);
+            if (r !== 19) {
+                throw r;
+            }
+        }
+    ]
 };

package/types/object/module.f.d.ts

@@ -8,3 +8,21 @@ export declare const at: (name: string) => <T>(object: Map<T>) => T | null;
 export declare const sort: <T>(e: List<Entry<T>>) => List<Entry<T>>;
 export declare const fromEntries: <T>(e: List<Entry<T>>) => Map<T>;
 export declare const fromMap: <T>(m: BtMap<T>) => Map<T>;
+/**
+ * A set of objects with a single key.
+ *
+ * See also
+ * https://stackoverflow.com/questions/57571664/typescript-type-for-an-object-with-only-one-key-no-union-type-allowed-as-a-key
+ */
+export type OneKey<K extends string, V> = {
+    [P in K]: (Record<P, V> & Partial<Record<Exclude<K, P>, never>>) extends infer O ? {
+        [Q in keyof O]: O[Q];
+    } : never;
+}[K];
+/**
+ * https://stackoverflow.com/questions/61112584/typing-a-single-record-entry
+ */
+export type NotUnion<T, U = T> = T extends unknown ? [
+    U
+] extends [T] ? T : never : never;
+export type SingleProperty<T extends Record<string, never>> = keyof T extends NotUnion<keyof T> ? T : never;

package/types/object/module.f.js

@@ -3,7 +3,7 @@ import { entries as mapEntries, fromEntries as mapFromEntries } from "../map/mod
 const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object;
 export const at = name => object => {
     const r = getOwnPropertyDescriptor(object, name);
-    return r === void 0 ? null : r.value;
+    return r === undefined ? null : r.value;
 };
 export const sort = e => mapEntries(mapFromEntries(e));
 export const fromEntries = e => objectFromEntries(iterable(e));

package/bnf/tag/module.f.d.ts

@@ -1,30 +0,0 @@
-import { type Array2 } from '../../types/array/module.f.ts';
-export type Range = bigint;
-export type Sequence = readonly Rule[];
-export type Or = {
-    readonly [k in string]: Rule;
-};
-export type DataRule = Or | Sequence | Range | string;
-export type LazyRule = () => DataRule;
-export type Rule = DataRule | LazyRule;
-export declare const rangeEncode: (a: number, b: number) => Range;
-export declare const oneEncode: (a: number) => Range;
-export declare const rangeDecode: (r: bigint) => Array2<number>;
-export declare const str: (s: string) => readonly Range[] | Range;
-export declare const set: (s: string) => Or;
-export declare const range: (ab: string) => Range;
-export type None = readonly [];
-export declare const none: None;
-export type Option<S> = {
-    none: None;
-    some: S;
-};
-export declare const option: <S extends Rule>(some: S) => Option<S>;
-export type Repeat0<T> = () => Option<readonly [T, Repeat0<T>]>;
-export declare const repeat0: <T extends Rule>(some: T) => Repeat0<T>;
-export type Repeat1<T> = readonly [T, Repeat0<T>];
-export declare const repeat1: <T extends Rule>(some: T) => Repeat1<T>;
-export type Join1<T, S> = readonly [T, Repeat0<readonly [S, T]>];
-export declare const join1: <T extends Rule, S extends Rule>(some: T, separator: S) => Join1<T, S>;
-export type Join0<T, S> = Option<readonly [T, Repeat0<readonly [S, T]>]>;
-export declare const join0: <T extends Rule, S extends Rule>(some: T, separator: S) => Rule;

package/bnf/tag/module.f.js

@@ -1,37 +0,0 @@
-import { stringToCodePointList } from "../../text/utf16/module.f.js";
-import { isArray2 } from "../../types/array/module.f.js";
-import { map, toArray } from "../../types/list/module.f.js";
-//
-const { fromEntries } = Object;
-const { fromCodePoint } = String;
-const offset = 24n;
-const mask = (1n << offset) - 1n;
-export const rangeEncode = (a, b) => (BigInt(a) << offset) | BigInt(b);
-export const oneEncode = (a) => rangeEncode(a, a);
-export const rangeDecode = (r) => [Number(r >> offset), Number(r & mask)];
-const mapOneEncode = map(oneEncode);
-export const str = (s) => {
-    const x = toArray(mapOneEncode(stringToCodePointList(s)));
-    return x.length === 1 ? x[0] : x;
-};
-const mapEntry = map((v) => [fromCodePoint(v), oneEncode(v)]);
-export const set = (s) => fromEntries(toArray(mapEntry(stringToCodePointList(s))));
-export const range = (ab) => {
-    const a = toArray(stringToCodePointList(ab));
-    if (!isArray2(a)) {
-        throw `Invalid range ${ab}.`;
-    }
-    return rangeEncode(...a);
-};
-export const none = [];
-export const option = (some) => ({
-    none,
-    some,
-});
-export const repeat0 = (some) => {
-    const f = () => option([some, f]);
-    return f;
-};
-export const repeat1 = (some) => [some, repeat0(some)];
-export const join1 = (some, separator) => [some, repeat0([separator, some])];
-export const join0 = (some, separator) => option(join1(some, separator));