@jarenjs/core 0.9.2

package/src/index.js

@@ -0,0 +1,223 @@
+//@ts-check
+export function isFn(data) {
+  return typeof data === 'function';
+}
+
+//#region Scalar Tests
+function isScalarTypeEx(typeName) {
+  switch (typeName) {
+    case 'string':
+    case 'number':
+    case 'boolean':
+    case 'integer':
+    case 'bigint':
+      return true;
+    default:
+      return false;
+  }
+}
+
+export function isScalarType(data) {
+  return data != null && isScalarTypeEx(typeof data);
+}
+
+export function isStringType(data) {
+  return typeof data === 'string';
+}
+
+/**
+ * Checks if the given data is of boolean type.
+ * @param {any} data - The data to check.
+ * @returns {boolean} - True if the data is a boolean, otherwise false.
+ */
+export function isBooleanType(data) {
+  return data === true || data === false;
+}
+
+/**
+ * Checks if the given data is of number type.
+ * @param {any} data - The data to check.
+ * @returns {boolean} - True if the data is a number, otherwise false.
+ */
+export function isNumberType(data) {
+  return data != null && typeof data === 'number';
+}
+
+/**
+ * Checks if the given data is an integer type.
+ * @param {any} data - The data to check.
+ * @returns {boolean} - True if the data is an integer, otherwise false.
+ */
+export function isIntegerType(data) {
+  return Number.isInteger(data);
+}
+
+export function isBigIntType(data) {
+  return typeof data === 'bigint';
+}
+
+//#endregion
+
+//#region Scalar Getters
+/**
+ * Returns the string type of the input object if it is a string; otherwise, returns the default value.
+ *
+ * @param {any} obj - The input object to check its type.
+ * @param {string|undefined} [def=undefined] - The default value to return if the input object is not a string.
+ * @returns {string} The string type of the input object or the default value.
+ */
+export function getStringType(obj, def = undefined) {
+  return isStringType(obj) ? obj : def;
+}
+
+/**
+ * Checks if the given object is a boolean type and returns it, otherwise returns the default value.
+ * @param {any} obj - The object to check.
+ * @param {boolean|undefined} [def=undefined] - The default value to return if the object is not a boolean.
+ * @returns {boolean|undefined} - The boolean value or the default value.
+ */
+export function getBooleanType(obj, def = undefined) {
+  return isBooleanType(obj) ? obj : def;
+}
+
+/**
+ * Checks if the given object is a number type and returns it, otherwise returns the default value.
+ * @param {any} obj - The object to check.
+ * @param {number|undefined} [def=undefined] - The default value to return if the object is not a number.
+ * @returns {number|undefined} - The number value or the default value.
+ */
+export function getNumberType(obj, def = undefined) {
+  return isNumberType(obj) ? obj : def;
+}
+
+/**
+ * Checks if the given object is an integer type and returns it, otherwise returns the default value.
+ * @param {any} obj - The object to check.
+ * @param {number|undefined} [def=undefined] - The default value to return if the object is not an integer.
+ * @returns {number|undefined} - The integer value or the default value.
+ */
+export function getIntegerType(obj, def = undefined) {
+  return isIntegerType(obj) ? obj : def;
+}
+
+/**
+ * Checks if the given object is a bigint type and returns it, otherwise returns the default value.
+ * @param {any} obj - The object to check.
+ * @param {bigint|undefined} [def=undefined] - The default value to return if the object is not a bigint.
+ * @returns {bigint|undefined} - The bigint value or the default value.
+ */
+export function getBigIntType(obj, def = undefined) {
+  return isBigIntType(obj)
+    ? obj
+    : def;
+}
+//#endregion
+
+//#region Object Tests
+/**
+ * Checks if the input data is null.
+ *
+ * @param {any} data - The data to be checked.
+ * @returns {boolean} - Returns true if the data is null, otherwise false.
+ */
+export function isNullValue(data) {
+  return data === null;
+}
+
+/**
+ * Checks if the given data is an object of a specific class.
+ *
+ * @param {any} data - The data to check.
+ * @param {Function} type - The class type to compare against.
+ * @returns {boolean} Returns true if the data is an object of the specified class; otherwise, false.
+ */
+export function isObjectOfClass(data, type) {
+  return data != null && data.constructor === type;
+}
+
+/**
+ * @brief test if data is an object literal
+ * @param {*} data the data to test
+ * @returns boolean
+ */
+export function isObjectClass(data) {
+  return isObjectOfClass(data, Object);
+}
+
+/**
+ * Checks if the input data is of type Map.
+ *
+ * @param {any} data - The data to be checked.
+ * @returns {boolean} - Returns true if the data is an instance of the Map class, otherwise false.
+ */
+export function isMapClass(data) {
+  return isObjectOfClass(data, Map);
+}
+
+/**
+ * @brief test if data is typeof object but not an Array
+ * @param {*} data the data to test
+ * @returns boolean
+ */
+export function isObjectType(data) {
+  return data != null
+    && typeof data === 'object'
+    && data.constructor !== Array;
+}
+
+/**
+ * Checks if the input data is of type Array.
+ *
+ * @param {any} data - The data to be checked.
+ * @returns {boolean} - Returns true if the data is an instance of the Array class, otherwise false.
+ */
+export function isArrayClass(data) {
+  return isObjectOfClass(data, Array);
+}
+
+/**
+ * Checks if the input data is of type Set.
+ *
+ * @param {any} data - The data to be checked.
+ * @returns {boolean} - Returns true if the data is an instance of the Set class, otherwise false.
+ */
+export function isSetClass(data) {
+  return isObjectOfClass(data, Set);
+}
+
+export const TypedArray = Object.getPrototypeOf(Uint8Array);
+export function isTypedArray(data) {
+  if (data == null)
+    return false;
+  const proto = data.__proto__.__proto__;
+  return proto != null && proto.constructor === TypedArray;
+}
+//#endregion
+
+//#region Object Getters
+export function getObjectType(obj, def = undefined) {
+  return isObjectType(obj) ? obj : def;
+}
+
+export function getArrayClass(obj, def = undefined) {
+  return isArrayClass(obj) ? obj : def;
+}
+//#endregion
+
+/**
+ * Calculates the inclusive and exclusive bounds based on the provided parameters.
+ *
+ * @param {function} getType - A function to determine the type of the inclusive and exclusive bounds.
+ * @param {number|string|undefined} inclusive - The inclusive bound value.
+ * @param {number|string|boolean|undefined} exclusive - The exclusive bound value.
+ * @returns {Array} An array containing the inclusive and exclusive bounds.
+ */
+export function getInclusiveExclusiveBounds(getType, inclusive, exclusive) {
+  const includes = getType(inclusive);
+  const excludes = exclusive === true
+    ? includes
+    : getType(exclusive);
+  return (excludes === undefined)
+    ? [includes, undefined]
+    : [undefined, excludes];
+}

package/src/integer.js

@@ -0,0 +1,77 @@
+//@ts-check
+
+import {
+  isIntegerType,
+} from './index.js';
+
+export const INT8_MIN = -128;
+export const INT8_MAX = 127;
+
+export function isValidInt8(value) {
+  return isIntegerType(value)
+    && value >= INT8_MIN
+    && value <= INT8_MAX;
+}
+
+export const UINT8_MIN = 0;
+export const UINT8_MAX = 255;
+
+export function isValidUInt8(value) {
+  return isIntegerType(value)
+    && value >= UINT8_MIN
+    && value <= UINT8_MAX;
+}
+
+export const INT16_MIN = -32768;
+export const INT16_MAX = 32767;
+
+export function isValidInt16(value) {
+  return isIntegerType(value)
+    && value >= INT16_MIN
+    && value <= INT16_MAX;
+}
+
+export const UINT16_MIN = 0;
+export const UINT16_MAX = 65535;
+
+export function isValidUInt16(value) {
+  return isIntegerType(value)
+    && value >= UINT16_MIN
+    && value <= UINT16_MAX;
+}
+
+export const INT32_MIN = -(2 ** 31);
+export const INT32_MAX = (2 ** 31) - 1;
+
+export function isValidInt32(value) {
+  return isIntegerType(value)
+    && value >= INT32_MIN
+    && value <= INT32_MAX;
+}
+
+export const UINT32_MIN = 0;
+export const UINT32_MAX = (2 ** 32) - 1;
+
+export function isValidUInt32(value) {
+  return isIntegerType(value)
+    && value >= UINT32_MIN
+    && value <= UINT32_MAX;
+}
+
+export const INT64_MIN = Number.MIN_SAFE_INTEGER;
+export const INT64_MAX = Number.MAX_SAFE_INTEGER;
+
+export function isValidInt64(value) {
+  return isIntegerType(value)
+    && value >= INT64_MIN
+    && value <= INT64_MAX;
+}
+
+export const UINT64_MIN = 0;
+export const UINT64_MAX = Number.MAX_SAFE_INTEGER;
+
+export function isValidUInt64(value) {
+  return isIntegerType(value)
+    && value >= UINT64_MIN
+    && value <= UINT64_MAX;
+}

package/src/math/float64.js

@@ -0,0 +1,316 @@
+//@ts-check
+
+export const mathf64_abs = Math.abs;
+
+export const mathf64_sqrt = Math.sqrt;
+export const mathf64_pow = Math.pow;
+export const mathf64_sin = Math.sin;
+export const mathf64_cos = Math.cos;
+export const mathf64_atan2 = Math.atan2;
+export const mathf64_asin = Math.asin;
+
+export const mathf64_ceil = Math.ceil;
+export const mathf64_floor = Math.floor;
+export const mathf64_round = Math.round;
+export const mathf64_min = Math.min;
+export const mathf64_max = Math.max;
+
+export const mathf64_random = Math.random;
+
+export const mathf64_EPSILON = +0.000001;
+
+export const mathf64_SQRTFIVE = +mathf64_sqrt(5);
+
+export const mathf64_PI = +Math.PI;
+export const mathf64_PI2 = +(mathf64_PI * 2);
+export const mathf64_PI1H = +(mathf64_PI / 2);
+export const mathf64_PI41 = +(4 / mathf64_PI);
+export const mathf64_PI42 = +(4 / (mathf64_PI * mathf64_PI));
+
+const _isqrt = (function float64_isqrt_oncompile() {
+  const f = new Float32Array(1);
+  const i = new Int32Array(f.buffer);
+  return function float64_isqrt_impl(n = 0.0) {
+    n = +n;
+    const n2 = +(n * 0.5);
+    f[0] = +n;
+    i[0] = (0x5f375a86 - ((i[0] | 0) >> 1)) | 0;
+    n = +f[0];
+    return +(+n * +(1.5 - (+n2 * +n * +n)));
+  };
+})();
+
+export class Float64 {
+
+  static gcd(a = 0.0, b = 0.0) {
+    a = +a; b = +b;
+    // For example, a 1024x768 monitor has a GCD of 256.
+    // When you divide both values by that you get 4x3 or 4: 3.
+    return +((b === 0.0) ? +a : +Float64.gcd(b, a % b));
+  }
+
+  static sqrt(n = 0.0) {
+    return +mathf64_sqrt(+n);
+  }
+
+  /**
+   *
+   * The Cross Product Magnitude
+   * a × b of two vectors is another vector that is at right angles to both:
+   * The magnitude (length) of the cross product equals the area
+   * of a parallelogram with vectors a and b for sides:
+   *
+   * We can calculate the Cross Product this way:
+   *
+   *    a × b = |a| |b| sin(θ) n
+   *
+   * or as
+   *
+   *    a × b = ax × by - bx × ay
+   *
+   * Another useful property of the cross product is,
+   * that its magnitude is related to the sine of
+   * the angle between the two vectors:
+   *
+   *    | a x b | = |a| . |b| . sine(theta)
+   *
+   * or
+   *
+   *    sine(theta) = | a x b | / (|a| . |b|)
+   *
+   * So, in implementation 1 above, if a and b are known in advance
+   * to be unit vectors then the result of that function is exactly that sine() value.
+   * @param {number} ax
+   * @param {number} ay
+   * @param {number} bx
+   * @param {number} by
+   */
+  static cross(ax = 0.0, ay = 0.0, bx = 0.0, by = 0.0) {
+    return +(+(+ax * +by) - +(+bx * +ay));
+  }
+
+
+  /**
+   *
+   * We can calculate the Dot Product of two vectors this way:
+   *
+   *    a · b = |a| × |b| × cos(θ)
+   *
+   * or in this implementation as:
+   *
+   *    a · b = ax × bx + ay × by
+   *
+   * When two vectors are at right angles to each other the dot product is zero.
+   *
+   * @param {number} ax vector A x velocity
+   * @param {number} ay vector A y velocity
+   * @param {number} bx vector B x velocity
+   * @param {number} by vector B y velocity
+   * @returns {number} scalar of the dot product
+   */
+  static dot(ax = 0.0, ay = 0.0, bx = 0.0, by = 0.0) {
+    return +(+(+ax * +bx) + +(+ay * +by));
+  }
+
+  static mag2(dx = 0.0, dy = 0.0) {
+    return +Float64.dot(dx, dy, dx, dy);
+  }
+
+  static mag(dx = 0.0, dy = 0.0) {
+    return +mathf64_sqrt(+Float64.mag2(dx, dy));
+  }
+
+  static isqrt(n = 0.0) {
+    return +_isqrt(n);
+  }
+
+  static fib(n = 0.0) {
+    n = +mathf64_floor(+n);
+    if (!(n >= 1.0)) return 0.0;
+    let c = 0.0;
+    let x = 1.0;
+    let i = 1.0;
+    for (; i !== n; i += 1.0) {
+      const t = +(+c + +x);
+      c = +x;
+      x = +t;
+    }
+    return +x;
+  }
+
+  // https://gist.github.com/geraldyeo/988116export
+  static fib2(value = 0.0) {
+    value = +value;
+    const fh = +(1.0 / +mathf64_SQRTFIVE * +mathf64_pow(+(+(1.0 + mathf64_SQRTFIVE) / 2.0), +value));
+    const sh = +(1.0 / +mathf64_SQRTFIVE * +mathf64_pow(+(+(1.0 - mathf64_SQRTFIVE) / 2.0), +value));
+    return +mathf64_round(+(fh - sh));
+  }
+
+  static norm(value = 0.0, min = 0.0, max = 0.0) {
+    value = +value; min = +min; max = +max;
+    return +((value - min) / (max - min));
+  }
+
+  static lerp(norm = 0.0, min = 0.0, max = 0.0) {
+    norm = +norm; min = +min; max = +max;
+    return +((max - min) * (norm + min));
+  }
+
+  static map(value = 0.0, smin = 0.0, smax = 0.0, dmin = 0.0, dmax = 0.0) {
+    value = +value; smin = +smin; smax = +smax; dmin = +dmin; dmax = +dmax;
+    return +Float64.lerp(+Float64.norm(value, smin, smax), dmin, dmax);
+  }
+
+  /**
+   * Clamps a value between a checked boundary.
+   * and can therefor handle swapped min/max arguments
+   *
+   * @param {number} value input value
+   * @param {number} min minimum bounds
+   * @param {number} max maximum bounds
+   * @returns {number} clamped value
+   */
+  static clamp(value = 0.0, min = 0.0, max = 0.0) {
+    return +mathf64_min(+mathf64_max(+value, +mathf64_min(+min, +max)), +mathf64_max(+min, +max));
+  }
+  /**
+   * Clamps a value between an unchecked boundary
+   * this function needs min < max!!
+   * (see Float64.clamp for a checked boundary)
+   *
+   * @param {number} value input value
+   * @param {number} min minimum bounds
+   * @param {number} max maximum bounds
+   * @returns {number} clamped value
+   */
+  static clampu(value = 0.0, min = 0.0, max = 0.0) {
+    return +mathf64_min(+mathf64_max(+value, +min), +max);
+  }
+
+  static inRange(value = 0.0, min = 0.0, max = 0.0) {
+    return +(+value >= +mathf64_min(+min, +max) && +value <= +mathf64_max(+min, +max));
+  }
+
+  static intersectsRange(smin = 0.0, smax = 0.0, dmin = 0.0, dmax = 0.0) {
+    return +(+mathf64_max(+smin, +smax) >= +mathf64_min(+dmin, +dmax)
+      && +mathf64_min(+smin, +smax) <= +mathf64_max(+dmin, +dmax));
+  }
+
+  static intersectsRect(
+    ax = 0.0, ay = 0.0, aw = 0.0, ah = 0.0,
+    bx = 0.0, by = 0.0, bw = 0.0, bh = 0.0,
+  ) {
+    return +(+(+Float64.intersectsRange(+ax, +(+ax + +aw), +bx, +(+bx + +bw)) > 0.0
+      && +Float64.intersectsRange(+ay, +(+ay + +ah), +by, +(+by + +bh)) > 0.0));
+  }
+
+  //#region trigonometry
+
+  static toRadian(degrees = 0.0) {
+    return +(+degrees * +Math.PI / 180.0);
+  }
+
+  static toDegrees(radians = 0.0) {
+    return +(+radians * 180.0 / +Math.PI);
+  }
+
+  static wrapRadians(r = 0.0) {
+    r = +r;
+    if (+r > Math.PI) return +(+r - +mathf64_PI2);
+    else if (+r < -Math.PI) return +(+r + +mathf64_PI2);
+    return +r;
+  }
+
+  static sinLpEx(r = 0.0) {
+    r = +r;
+    return +((r < 0.0)
+      ? +(+mathf64_PI41 * +r + +mathf64_PI42 * +r * +r)
+      : +(+mathf64_PI41 * +r - +mathf64_PI42 * +r * +r));
+  }
+
+  static sinLp(r = 0.0) {
+    //always wrap input angle between -PI and PI
+    return +Float64.sinLpEx(+Float64.wrapRadians(+r));
+  }
+
+  static cosLp(r = 0.0) {
+    //compute cosine: sin(x + PI/2) = cos(x)
+    return +Float64.sinLp(+(+r + +mathf64_PI1H));
+  }
+
+  static cosHp(r = 0.0) {
+    //   template<typename T>
+    // inline T cos(T x) noexcept
+    // {
+    //     constexpr T tp = 1./(2.*M_PI);
+    //     x *= tp;
+    //     x -= T(.25) + std::floor(x + T(.25));
+    //     x *= T(16.) * (std::abs(x) - T(.5));
+    //     #if EXTRA_PRECISION
+    //     x += T(.225) * x * (std::abs(x) - T(1.));
+    //     #endif
+    //     return x;
+    // }
+    throw new Error('float64_cosHp is not implemented! r=' + String(r));
+  }
+
+  static sinMpEx(r = 0.0) {
+    r = +r;
+    const sin = +((r < 0.0)
+      ? +(mathf64_PI41 * r + mathf64_PI42 * r * r)
+      : +(mathf64_PI41 * r - mathf64_PI42 * r * r));
+    return +((sin < 0.0)
+      ? +(0.225 * (sin * -sin - sin) + sin)
+      : +(0.225 * (sin * sin - sin) + sin));
+  }
+
+  static sinMp(r = 0.0) {
+    return +Float64.sinMpEx(+Float64.wrapRadians(+r));
+  }
+
+  static cosMp(r = 0.0) {
+    //compute cosine: sin(x + PI/2) = cos(x)
+    return +Float64.sinMp(+(+r + +mathf64_PI1H));
+  }
+
+  static theta(x = 0.0, y = 0.0) {
+    return +mathf64_atan2(+y, +x);
+    /*
+      // alternative was faster, but not anymore.
+      // error < 0.005
+      y = +y;
+      x = +x;
+      if (x == 0.0) {
+        if (y > 0.0) return +(Math.PI / 2.0);
+        if (y == 0.0) return 0.0;
+        return +(-Math.PI / 2.0);
+      }
+  
+      const z = +(y / x);
+      var atan = 0.0;
+      if (+Math.abs(z) < 1.0) {
+        atan = +(z / (1.0 + 0.28 * z * z));
+        if (x < 0.0) {
+          if (y < 0.0) return +(atan - Math.PI);
+          return +(atan + Math.PI);
+        }
+      }
+      else {
+        atan = +(Math.PI / 2.0 - z / (z * z + 0.28));
+        if (y < 0.0) return +(atan - Math.PI);
+      }
+      return +(atan);
+    */
+  }
+
+  static angle(x = 0.0, y = 0.0) {
+    return +Float64.theta(x, y);
+  }
+
+  static phi(y = 0.0, len = 0.0) {
+    return +mathf64_asin(+y / +len);
+  }
+
+  //#endregion
+
+}

package/src/math/index.js

@@ -0,0 +1,5 @@
+export * from './int32.js';
+export * from './vec2i32.js';
+export * from './float64.js';
+export * from './vec2f64.js';
+export * from './vec3f64.js';