atomic-fns 0.2.2 → 0.3.0

package/src/math/index.ts

@@ -0,0 +1,152 @@
+/**
+ * Math and algebraic operations.
+ *
+ * @module Math
+ */
+
+import { call, Predicate } from '../globals/index.js'
+import { reduce } from '../itertools/index.js'
+import { gt, id, lt } from '../operators/index.js'
+
+/**
+ * Returns the absolute value of a number. The argument may be a number or an object implementing the `abs()`.
+ * @param x The value.
+ * @returns The absolute value.
+ */
+export function abs(x): number {
+  const op = call(x, 'abs')
+  if (op != null) return op
+  return Math.abs(x)
+}
+
+/**
+ * Round `x` to the number of digits after the decimal point. If `digits` is
+ * omitted, it returns the nearest integer to x.
+ *
+ * @param {number} x
+ * @param {number} [digits=0]
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round Math.round()}
+ */
+export function round(x: number, digits = 0) {
+  const base = 10 ** digits
+  return Math.round(x * base) / base
+}
+
+/**
+ * Rounds down and returns the largest integer less than or equal to a given number.
+ * @param x A number.
+ * @returns Nearest integer less than or equal to number.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor Math.floor()}
+ */
+export const floor = (x: number) => Math.floor(x)
+
+/**
+ * Rounds up and returns the largest integer greater than or equal to a given number.
+ * @param x A number.
+ * @returns Nearest integer greater than or equal to number.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil Math.ceil()}
+ */
+export const ceil = (x: number) => Math.ceil(x)
+
+/**
+ * Returns a tuple like `[x / y, x % y]`.
+ *
+ * @param x
+ * @param y
+ * @returns
+ */
+export function divmod(x: number, y: number) {
+  return [Math.floor(x / y), x % y]
+}
+
+export function log2(x) {
+  if (x > 0) {
+    return Math.log(x) * 1.442695
+  }
+  return Number.NaN
+}
+
+export function logBase(x, y) {
+  if (x > 0 && y > 0) {
+    return Math.log(y) / Math.log(x)
+  }
+  return Number.NaN
+}
+
+/**
+ * Returns the smallest element in an iterable. The optional `key` argument specifies a transform on the elements before comparing them. If the elements in the iterable are objects that implement a custom `lt` method, this will be called to compare.
+ * @param iterable The iterable to inspect.
+ * @param key Optional key function to transform the elements (default `id`).
+ * @returns The smallest element in the iterable.
+ */
+export function min(iterable: number[]): number
+export function min<T>(iterable: Iterable<T>, key?: Predicate<T>): T
+export function min<T>(iterable: Iterable<T>, key = id) {
+  return reduce(iterable, (x, y) => (lt(key(x), key(y)) ? x : y))
+}
+
+/**
+ * Returns the largest element in an iterable. The optional `key` argument specifies a transform on the elements before comparing them. If the elements in the iterable are objects that implement a custom `gt` method, this will be called to compare.
+ * @param iterable The iterable to inspect.
+ * @param key Optional key function to transform the elements (default `id`).
+ * @returns The largest element in the iterable.
+ */
+export function max(iterable: number[]): number
+export function max<T>(iterable: Iterable<T>, key?: Predicate<T>): T
+export function max<T>(iterable: Iterable<T>, key = id) {
+  return reduce(iterable, (x, y) => (gt(key(x), key(y)) ? x : y))
+}
+
+/**
+ * Computes the mean of the values in `iterable` and accepts an optional `key` function which is invoked for each element to generate the values to be averaged.
+ * @param {Array<number>|Iterable<T>} iterable
+ * @param {Function} [key] Optional iteratee invoked per element.
+ * @returns Returns the mean value or `false` if no elements.
+ * @template T
+ * @example
+```js
+let objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }]
+
+mean(objects, (o) => o.n)
+// => 5
+```
+ */
+export function mean(iterable: number[]): false | number
+export function mean<T>(iterable: Iterable<T>, key?: Predicate<T>): false | number
+export function mean<T>(iterable: Iterable<T>, key = id): false | number {
+  let total = 0
+  let count = 0
+  for (const value of iterable) {
+    total += key(value)
+    count++
+  }
+  return count !== 0 && total / count
+}
+
+/**
+ * Sums `initial` and the items of an iterable and returns the total.
+ * @param args The elements to add to `initial`.
+ * @param initial The initial value to add to (default `0`).
+ * @returns The total sum of initial and iterable elements.
+ * @example
+```js
+sum([1, 2, 3, 4])
+// => 10
+
+sum([1, 2, 3, 4], 5)
+// => 15
+```
+ */
+export function sum(iterable: number[]): number
+export function sum<T>(iterable: Iterable<T>, key?: Predicate<T>): T
+export function sum<T>(iterable: Iterable<T>, key?: Predicate<T>): T
+export function sum<T>(args: Iterable<T>, key: Predicate<T> = id) {
+  let initial = 0
+  for (const x of args) {
+    initial += key(x)
+  }
+  return initial
+}

package/src/{operators.d.ts → operators/index.d.ts}

@@ -1,21 +1,21 @@
+/**
+ * Generic operations for both values and objects.
+ *
+ * @module Operators
+ */
 export declare const id: (x: any) => any;
 export declare const bool: (x: any) => boolean;
 export declare const not: (x: any) => boolean;
 export declare const isinstance: (x: any, y: any) => boolean;
-export declare const all: (arr: any[], fn?: (x: any) => boolean) => boolean;
-export declare const any: (arr: any[], fn?: (x: any) => boolean) => boolean;
-export declare const and: (arr: any[], fn?: (x: any) => boolean) => boolean;
-export declare const or: (arr: any[], fn?: (x: any) => boolean) => boolean;
-export declare function comp(x: any, y: any): any;
+export declare function comp(x: any, y: any): 0 | 1 | -1;
 export declare function eq(x: any, y: any): any;
-export declare function shallowEqual(x: any, y: any): any;
 export declare function lt(x: any, y: any): any;
-export declare function le(x: any, y: any): any;
+export declare function lte(x: any, y: any): any;
 export declare function gt(x: any, y: any): any;
-export declare function ge(x: any, y: any): any;
+export declare function gte(x: any, y: any): any;
 export declare function add(x: any, y: any): any;
 export declare function sub(x: any, y: any): any;
-export declare function mult(x: any, y: any): any;
+export declare function mul(x: any, y: any): any;
 export declare function div(x: any, y: any): any;
 export declare function mod(x: any, y: any): any;
 /**
@@ -27,3 +27,5 @@ export declare function mod(x: any, y: any): any;
  * @return `x` raised to the power `y`
  */
 export declare function pow(x: any, y: any): any;
+export declare function shallowEqual(obj: any, other: any): boolean;
+export declare function deepEqual(obj: any, other: any, checker?: typeof eq): boolean;

package/src/operators/index.js

@@ -0,0 +1,171 @@
+/**
+ * Generic operations for both values and objects.
+ *
+ * @module Operators
+ */
+import { call, isNumber, isObject } from '../globals/index.js';
+export const id = (x) => x;
+export const bool = (x) => !!x;
+export const not = (x) => !x;
+export const isinstance = (x, y) => x instanceof y;
+export function comp(x, y) {
+    const op = call(x, 'compare', y);
+    if (isNumber(op))
+        return op;
+    if (eq(x, y))
+        return 0;
+    if (lte(x, y))
+        return -1;
+    if (gte(x, y))
+        return 1;
+    return 0;
+}
+export function eq(x, y) {
+    const op = call(x, 'eq', y);
+    if (op != null)
+        return op;
+    return x === y;
+}
+export function lt(x, y) {
+    const op = call(x, 'lt', y);
+    if (op != null)
+        return op;
+    return x < y;
+}
+export function lte(x, y) {
+    let op = call(x, 'lte', y);
+    if (op != null)
+        return op;
+    op = call(x, 'eq', y);
+    if (op === true)
+        return op;
+    op = call(x, 'lt', y);
+    if (op != null)
+        return op;
+    return x <= y;
+}
+export function gt(x, y) {
+    const op = call(x, 'gt', y);
+    if (op != null)
+        return op;
+    return x > y;
+}
+export function gte(x, y) {
+    let op = call(x, 'gte', y);
+    if (op != null)
+        return op;
+    op = call(x, 'eq', y);
+    if (op === true)
+        return op;
+    op = call(x, 'gt', y);
+    if (op != null)
+        return op;
+    return x >= y;
+}
+export function add(x, y) {
+    const op = call(x, 'add', y);
+    if (op != null)
+        return op;
+    return x + y;
+}
+export function sub(x, y) {
+    const op = call(x, 'sub', y);
+    if (op != null)
+        return op;
+    return x - y;
+}
+export function mul(x, y) {
+    const op = call(x, 'mul', y);
+    if (op != null)
+        return op;
+    return x * y;
+}
+export function div(x, y) {
+    const op = call(x, 'div', y);
+    if (op != null)
+        return op;
+    return x / y;
+}
+export function mod(x, y) {
+    const op = call(x, 'mod', y);
+    if (op != null)
+        return op;
+    return x % y;
+}
+/**
+ * Calculates `x` to the power of `y`. If `x` implements a custom `pow` operator
+ * it will return `x.pow(y)`.
+ *
+ * @param {*} x
+ * @param {*} y
+ * @return `x` raised to the power `y`
+ */
+export function pow(x, y) {
+    const op = call(x, 'pow', y);
+    if (op != null)
+        return op;
+    return x ** y;
+}
+export function shallowEqual(obj, other) {
+    if (obj === other)
+        return true;
+    if (!obj || !other)
+        return false;
+    if (Array.isArray(obj)) {
+        // compare the arrays
+        if (obj.length !== other.length)
+            return false;
+        for (let i = 0; i < obj.length; i++) {
+            if (obj[i] !== other[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else if (isObject(obj)) {
+        // compare the object keys
+        const objKeys = Object.keys(obj);
+        const otherKeys = Object.keys(other);
+        if (objKeys.length !== otherKeys.length)
+            return false;
+        for (const key of objKeys) {
+            if (!Object.prototype.hasOwnProperty.call(other, key) || obj[key] !== other[key]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+export function deepEqual(obj, other, checker = eq) {
+    if (checker(obj, other))
+        return true;
+    if (!obj || !other)
+        return false;
+    if (Array.isArray(obj)) {
+        // compare the arrays
+        if (obj.length !== other.length)
+            return false;
+        for (let i = 0; i < obj.length; i++) {
+            if (!deepEqual(obj[i], other[i], checker)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else if (isObject(obj)) {
+        // compare the object keys
+        const objKeys = Object.keys(obj);
+        const otherKeys = Object.keys(other);
+        if (objKeys.length !== otherKeys.length)
+            return false;
+        for (const key of objKeys) {
+            if (!Object.prototype.hasOwnProperty.call(other, key) ||
+                !deepEqual(obj[key], other[key], checker)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}

package/src/operators/index.ts

@@ -0,0 +1,175 @@
+/**
+ * Generic operations for both values and objects.
+ *
+ * @module Operators
+ */
+
+import { call, isNumber, isObject } from '../globals/index.js'
+
+export const id = (x) => x
+
+export const bool = (x) => !!x
+
+export const not = (x) => !x
+
+export const isinstance = (x, y) => x instanceof y
+
+export function comp(x, y) {
+  const op = call(x, 'compare', y)
+  if (isNumber(op)) return op as 0 | 1 | -1
+  if (eq(x, y)) return 0
+  if (lte(x, y)) return -1
+  if (gte(x, y)) return 1
+  return 0
+}
+
+export function eq(x, y) {
+  const op = call(x, 'eq', y)
+  if (op != null) return op
+  return x === y
+}
+
+export function lt(x, y) {
+  const op = call(x, 'lt', y)
+  if (op != null) return op
+  return x < y
+}
+
+export function lte(x, y) {
+  let op = call(x, 'lte', y)
+  if (op != null) return op
+  op = call(x, 'eq', y)
+  if (op === true) return op
+  op = call(x, 'lt', y)
+  if (op != null) return op
+  return x <= y
+}
+
+export function gt(x, y) {
+  const op = call(x, 'gt', y)
+  if (op != null) return op
+  return x > y
+}
+
+export function gte(x, y) {
+  let op = call(x, 'gte', y)
+  if (op != null) return op
+  op = call(x, 'eq', y)
+  if (op === true) return op
+  op = call(x, 'gt', y)
+  if (op != null) return op
+  return x >= y
+}
+
+export function add(x, y) {
+  const op = call(x, 'add', y)
+  if (op != null) return op
+  return x + y
+}
+
+export function sub(x, y) {
+  const op = call(x, 'sub', y)
+  if (op != null) return op
+  return x - y
+}
+
+export function mul(x, y) {
+  const op = call(x, 'mul', y)
+  if (op != null) return op
+  return x * y
+}
+
+export function div(x, y) {
+  const op = call(x, 'div', y)
+  if (op != null) return op
+  return x / y
+}
+
+export function mod(x, y) {
+  const op = call(x, 'mod', y)
+  if (op != null) return op
+  return x % y
+}
+
+/**
+ * Calculates `x` to the power of `y`. If `x` implements a custom `pow` operator
+ * it will return `x.pow(y)`.
+ *
+ * @param {*} x
+ * @param {*} y
+ * @return `x` raised to the power `y`
+ */
+export function pow(x, y) {
+  const op = call(x, 'pow', y)
+  if (op != null) return op
+  return x ** y
+}
+
+export function shallowEqual(obj, other) {
+  if (obj === other) return true
+
+  if (!obj || !other) return false
+
+  if (Array.isArray(obj)) {
+    // compare the arrays
+    if (obj.length !== other.length) return false
+
+    for (let i = 0; i < obj.length; i++) {
+      if (obj[i] !== other[i]) {
+        return false
+      }
+    }
+    return true
+  } else if (isObject(obj)) {
+    // compare the object keys
+    const objKeys = Object.keys(obj)
+    const otherKeys = Object.keys(other)
+
+    if (objKeys.length !== otherKeys.length) return false
+
+    for (const key of objKeys) {
+      if (!Object.prototype.hasOwnProperty.call(other, key) || obj[key] !== other[key]) {
+        return false
+      }
+    }
+    return true
+  }
+
+  return false
+}
+
+export function deepEqual(obj, other, checker = eq) {
+  if (checker(obj, other)) return true
+
+  if (!obj || !other) return false
+
+  if (Array.isArray(obj)) {
+    // compare the arrays
+    if (obj.length !== other.length) return false
+
+    for (let i = 0; i < obj.length; i++) {
+      if (!deepEqual(obj[i], other[i], checker)) {
+        return false
+      }
+    }
+    return true
+  } else if (isObject(obj)) {
+    // compare the object keys
+    const objKeys = Object.keys(obj)
+    const otherKeys = Object.keys(other)
+
+    if (objKeys.length !== otherKeys.length) return false
+
+    for (const key of objKeys) {
+      if (
+        !Object.prototype.hasOwnProperty.call(other, key) ||
+        !deepEqual(obj[key], other[key], checker)
+      ) {
+        return false
+      }
+    }
+    return true
+  }
+
+  return false
+}

package/src/random/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * This module implements pseudo-random generators for various distributions.
+ *
+ * @module Random
+ */
+/**
+ * Returns a random float between a [min, max) value (max exclusive).
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+export declare const random: (min?: number, max?: number) => number;
+/**
+ * Returns a random integer between a [min, max] value (inclusive).
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+export declare const randomInt: (min?: number, max?: number) => number;
+/**
+ * Returns the item at some random index in a sequence.
+ * @returns {T}
+ * @template T
+ */
+export declare const choice: <T>(arr: T[]) => T | undefined;
+/**
+ * Returns a random sample of size k from a list of items.
+ * @param {Array} arr
+ * @param {number} size
+ * @returns A new array with `size` random elements from `arr`.
+ * @template T
+ */
+export declare function sample<T>(arr: T[], size: number): T[];
+/**
+ * Shuffles a collection elements in-place. Uses the Fisher-Yates algorithm for uniform shuffling. If collection is an Object it returns shuffled `Object.values()`.
+ *
+ * @param {Array} arr
+ * @param {number} size
+ * @returns The shuffled array.
+ * @template T
+ */
+export declare function shuffle<T>(arr: T[], size?: number): T[];

package/src/random/index.js

@@ -0,0 +1,65 @@
+/**
+ * This module implements pseudo-random generators for various distributions.
+ *
+ * @module Random
+ */
+import { isObject } from '../globals/index.js';
+/**
+ * Returns a random float between a [min, max) value (max exclusive).
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+export const random = (min = 0, max = 1) => Math.random() * (max - min) + min;
+/**
+ * Returns a random integer between a [min, max] value (inclusive).
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+export const randomInt = (min = 0, max = 1) => Math.round(random(min, max));
+/**
+ * Returns the item at some random index in a sequence.
+ * @returns {T}
+ * @template T
+ */
+export const choice = (arr) => {
+    if (!arr || !arr.length)
+        return;
+    return arr[randomInt(0, arr.length - 1)];
+};
+/**
+ * Returns a random sample of size k from a list of items.
+ * @param {Array} arr
+ * @param {number} size
+ * @returns A new array with `size` random elements from `arr`.
+ * @template T
+ */
+export function sample(arr, size) {
+    if (!arr || !arr.length || arr.length < size)
+        return [];
+    return shuffle(arr.slice()).slice(-size);
+}
+/**
+ * Shuffles a collection elements in-place. Uses the Fisher-Yates algorithm for uniform shuffling. If collection is an Object it returns shuffled `Object.values()`.
+ *
+ * @param {Array} arr
+ * @param {number} size
+ * @returns The shuffled array.
+ * @template T
+ */
+export function shuffle(arr, size) {
+    if (!arr || !arr.length)
+        return arr;
+    if (isObject(arr))
+        arr = Object.values(arr);
+    if (size == null)
+        size = arr.length - 1;
+    for (let i = 0; i <= size; i++) {
+        const j = randomInt(i, size);
+        const temp = arr[j];
+        arr[j] = arr[i];
+        arr[i] = temp;
+    }
+    return arr;
+}

package/src/random/index.ts

@@ -0,0 +1,66 @@
+/**
+ * This module implements pseudo-random generators for various distributions.
+ *
+ * @module Random
+ */
+
+import { isObject } from '../globals/index.js'
+
+/**
+ * Returns a random float between a [min, max) value (max exclusive).
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+export const random = (min = 0, max = 1) => Math.random() * (max - min) + min
+
+/**
+ * Returns a random integer between a [min, max] value (inclusive).
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+export const randomInt = (min = 0, max = 1) => Math.round(random(min, max))
+
+/**
+ * Returns the item at some random index in a sequence.
+ * @returns {T}
+ * @template T
+ */
+export const choice = <T>(arr: T[]) => {
+  if (!arr || !arr.length) return
+  return arr[randomInt(0, arr.length - 1)]
+}
+
+/**
+ * Returns a random sample of size k from a list of items.
+ * @param {Array} arr
+ * @param {number} size
+ * @returns A new array with `size` random elements from `arr`.
+ * @template T
+ */
+export function sample<T>(arr: T[], size: number) {
+  if (!arr || !arr.length || arr.length < size) return []
+  return shuffle(arr.slice()).slice(-size)
+}
+
+/**
+ * Shuffles a collection elements in-place. Uses the Fisher-Yates algorithm for uniform shuffling. If collection is an Object it returns shuffled `Object.values()`.
+ *
+ * @param {Array} arr
+ * @param {number} size
+ * @returns The shuffled array.
+ * @template T
+ */
+export function shuffle<T>(arr: T[], size?: number) {
+  if (!arr || !arr.length) return arr
+  if (isObject(arr)) arr = Object.values(arr)
+  if (size == null) size = arr.length - 1
+  for (let i = 0; i <= size; i++) {
+    const j = randomInt(i, size)
+    const temp = arr[j]
+    arr[j] = arr[i]
+    arr[i] = temp
+  }
+  return arr
+}