atomic-fns 0.2.2 → 0.3.0

package/src/math.ts

@@ -1,77 +0,0 @@
-/**
- * Math
- * @module
- */
-import { call, isFunc } from './globals.js'
-import { comp } from './operators.js'
-
-export function abs(x: number) {
-  const op = call(x, 'abs')
-  if (op != null) return op
-  return Math.abs(x)
-}
-
-/**
- * Returns a tuple like (x / y, x % y)
- *
- * @param {number} x
- * @param {number} y
- * @return {number[]}
- */
-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
-}
-
-/** First argument can be a comparer func */
-export function min(args) {
-  // Uses `le` by default
-  let cmp = comp
-  if (isFunc(args[0])) {
-    cmp = args.shift()
-  }
-  let res = args[0]
-  for (const x of args) {
-    if (cmp(x, res) === -1) {
-      res = x
-    }
-  }
-  return res
-}
-
-/** First argument can be a comparer func */
-export function max(args) {
-  // Uses ge by default
-  let cmp = comp
-  if (isFunc(args[0])) {
-    cmp = args.shift()
-  }
-  let res = args[0]
-  for (const x of args) {
-    if (cmp(x, res) === 1) {
-      res = x
-    }
-  }
-  return res
-}
-
-export function sum(args) {
-  let total = 0
-  for (const x of args) {
-    total += x
-  }
-  return total
-}

package/src/objects.js

@@ -1 +0,0 @@
-'use strict'

package/src/operators.js

@@ -1,109 +0,0 @@
-/**
- * Operators
- * @module
- */
-import { call, isNumber, isObject } from './globals.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 const all = (arr, fn = bool) => arr.every(fn)
-export const any = (arr, fn = bool) => arr.some(fn)
-export const and = all
-export const or = any
-export function comp(x, y) {
-  const op = call(x, 'compare', y)
-  if (isNumber(op)) return op
-  if (eq(x, y)) return 0
-  if (le(x, y)) return -1
-  if (ge(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 shallowEqual(x, y) {
-  if (!x || !y) return x === y
-  if (Array.isArray(x)) {
-    for (let i = 0; i < x.length; i++) {
-      if (!eq(x[i], y[i])) return false
-    }
-    return true
-  }
-  if (isObject(x)) {
-    if (eq(x, y)) return true
-    for (const key in x) {
-      if (!eq(x[key], y[key])) return false
-    }
-    return true
-  }
-  return eq(x, y)
-}
-export function lt(x, y) {
-  const op = call(x, 'lt', y)
-  if (op != null) return op
-  return x < y
-}
-export function le(x, y) {
-  let op = call(x, 'le', 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 ge(x, y) {
-  let op = call(x, 'ge', 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 mult(x, y) {
-  const op = call(x, 'mult', 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
-}

package/src/operators.ts

@@ -1,130 +0,0 @@
-/**
- * Operators
- * @module
- */
-import { call, isNumber, isObject } from './globals.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 const all = (arr: any[], fn = bool) => arr.every(fn)
-
-export const any = (arr: any[], fn = bool) => arr.some(fn)
-
-export const and = all
-
-export const or = any
-
-export function comp(x, y) {
-  const op = call(x, 'compare', y)
-  if (isNumber(op)) return op
-  if (eq(x, y)) return 0
-  if (le(x, y)) return -1
-  if (ge(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 shallowEqual(x, y) {
-  if (!x || !y) return x === y
-  if (Array.isArray(x)) {
-    for (let i = 0; i < x.length; i++) {
-      if (!eq(x[i], y[i])) return false
-    }
-    return true
-  }
-  if (isObject(x)) {
-    if (eq(x, y)) return true
-    for (const key in x) {
-      if (!eq(x[key], y[key])) return false
-    }
-    return true
-  }
-  return eq(x, y)
-}
-
-export function lt(x, y) {
-  const op = call(x, 'lt', y)
-  if (op != null) return op
-  return x < y
-}
-
-export function le(x, y) {
-  let op = call(x, 'le', 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 ge(x, y) {
-  let op = call(x, 'ge', 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 mult(x, y) {
-  const op = call(x, 'mult', 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
-}

package/src/random.d.ts

@@ -1,22 +0,0 @@
-/** Returns a random float between a [min, max) value (max exclusive). */
-export declare const random: (min?: number, max?: number) => number;
-/** Returns a random integer between a [min, max] value (inclusive). */
-export declare const randomInt: (min?: number, max?: number) => number;
-/** Returns the item at some random index in a sequence. */
-export declare const choice: (arr: any[]) => any;
-/**
- * Returns a random sample of size k from a list of items.
- *
- * @export
- * @param {any[]} arr
- * @param {number} k
- * @return
- */
-export declare function sample(arr: any[], k: number): any[] | undefined;
-/**
- * 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 {*} arr
- * @return
- */
-export declare function shuffle(arr: any): any;

package/src/random.js

@@ -1,48 +0,0 @@
-/**
- * Random
- * @module
- */
-import { isObject } from './globals'
-/** Returns a random float between a [min, max) value (max exclusive). */
-export const random = (min = 0, max = 1) => Math.random() * (max - min) + min
-/** Returns a random integer between a [min, max] value (inclusive). */
-export const randomInt = (min = 0, max = 1) => Math.round(random(min, max))
-/** Returns the item at some random index in a sequence. */
-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.
- *
- * @export
- * @param {any[]} arr
- * @param {number} k
- * @return
- */
-export function sample(arr, k) {
-  if (!arr || !arr.length || arr.length < k) return
-  const result = []
-  for (let i = 0; i < k; i++) {
-    result.push(choice(arr))
-  }
-  return result
-}
-/**
- * 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 {*} arr
- * @return
- */
-export function shuffle(arr) {
-  if (!arr || !arr.length) return
-  if (isObject(arr)) arr = Object.values(arr)
-  const n = arr.length - 1
-  for (let i = n; i > 0; i--) {
-    const j = randomInt(0, i)
-    const temp = arr[j]
-    arr[j] = arr[i]
-    arr[i] = temp
-  }
-  return arr
-}

package/src/random.ts

@@ -1,53 +0,0 @@
-/**
- * Random
- * @module
- */
-import { isObject } from './globals'
-
-/** Returns a random float between a [min, max) value (max exclusive). */
-export const random = (min = 0, max = 1) => Math.random() * (max - min) + min
-
-/** Returns a random integer between a [min, max] value (inclusive). */
-export const randomInt = (min = 0, max = 1) => Math.round(random(min, max))
-
-/** Returns the item at some random index in a sequence. */
-export const choice = (arr: any[]) => {
-  if (!arr || !arr.length) return
-  return arr[randomInt(0, arr.length - 1)]
-}
-
-/**
- * Returns a random sample of size k from a list of items.
- *
- * @export
- * @param {any[]} arr
- * @param {number} k
- * @return
- */
-export function sample(arr: any[], k: number) {
-  if (!arr || !arr.length || arr.length < k) return
-  const result: typeof arr = []
-  for (let i = 0; i < k; i++) {
-    result.push(choice(arr))
-  }
-  return result
-}
-
-/**
- * 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 {*} arr
- * @return
- */
-export function shuffle(arr) {
-  if (!arr || !arr.length) return
-  if (isObject(arr)) arr = Object.values(arr)
-  const n = arr.length - 1
-  for (let i = n; i > 0; i--) {
-    const j = randomInt(0, i)
-    const temp = arr[j]
-    arr[j] = arr[i]
-    arr[i] = temp
-  }
-  return arr
-}

package/src/strings.js

@@ -1 +0,0 @@
-'use strict'

package/src/util.js

@@ -1 +0,0 @@
-'use strict'