@jarenjs/core 0.9.2

package/src/math/vec2i32.js

@@ -0,0 +1,250 @@
+import {
+  mathi32_MULTIPLIER,
+  mathi32_sqrt,
+  mathi32_asin,
+  mathi32_atan2,
+} from './int32.js';
+
+export class Vec2i32 {
+  /**
+   * @param {number | undefined} x
+   * @param {number | undefined} y
+   */
+  constructor(x = 0, y = 0) {
+    this.x = x | 0;
+    this.y = y | 0;
+  }
+
+  static new(x = 0, y = 0) {
+    return new Vec2i32(x | 0, y | 0);
+  }
+
+  new() {
+    return new Vec2i32(this.x | 0, this.y | 0);
+  }
+
+  //#region static primitive operators
+
+  static neg(v = def_Vec2i32) {
+    return new Vec2i32(-(v.x | 0) | 0, -(v.y | 0) | 0);
+  }
+  static add(a = def_Vec2i32, b = def_Vec2i32) {
+    return new Vec2i32(
+      ((a.x | 0) + (b.x | 0)) | 0,
+      ((a.y | 0) + (b.y | 0)) | 0,
+    );
+  }
+  static adds(v = def_Vec2i32, scalar = 0) {
+    scalar = scalar | 0;
+    return new Vec2i32(((v.x | 0) + scalar) | 0, ((v.y | 0) + scalar) | 0);
+  }
+
+  static sub(a = def_Vec2i32, b = def_Vec2i32) {
+    return new Vec2i32(
+      ((a.x | 0) - (b.x | 0)) | 0,
+      ((a.y | 0) - (b.y | 0)) | 0,
+    );
+  }
+  static subs(a = def_Vec2i32, scalar = 0) {
+    scalar = scalar | 0;
+    return new Vec2i32(((a.x | 0) - scalar) | 0, ((a.y | 0) - scalar) | 0);
+  }
+
+  static mul(a = def_Vec2i32, b = def_Vec2i32) {
+    return new Vec2i32(
+      ((a.x | 0) * (b.x | 0)) | 0,
+      ((a.y | 0) * (b.y | 0)) | 0,
+    );
+  }
+  static muls(v = def_Vec2i32, scalar = 0) {
+    scalar = scalar | 0;
+    return new Vec2i32(((v.x | 0) * scalar) | 0, ((v.y | 0) * scalar) | 0);
+  }
+
+  static div(a = def_Vec2i32, b = def_Vec2i32) {
+    return new Vec2i32(
+      ((a.x | 0) / (b.x | 0)) | 0,
+      ((a.y | 0) / (b.y | 0)) | 0,
+    );
+  }
+  static divs(v = def_Vec2i32, scalar = 0) {
+    scalar = scalar | 0;
+    return new Vec2i32(((v.x | 0) / scalar) | 0, ((v.y | 0) / scalar) | 0);
+  }
+
+  //#endregion
+
+  //#region static scalar products
+
+  static mag2(v = def_Vec2i32) {
+    return ((v.x | 0) * (v.x | 0) + (v.y | 0) * (v.y | 0)) | 0;
+  }
+
+  static mag(v = def_Vec2i32) {
+    return mathi32_sqrt(+Vec2i32.mag2(v)) | 0;
+  }
+
+  static dot(a = def_Vec2i32, b = def_Vec2i32) {
+    return ((a.x | 0) * (b.x | 0) + (a.y | 0) * (b.y | 0)) | 0;
+  }
+
+  static cross(a = def_Vec2i32, b = def_Vec2i32) {
+    return ((a.x | 0) * (b.y | 0) - (a.y | 0) * (b.x | 0)) | 0;
+  }
+
+  static cross3(a = def_Vec2i32, b = def_Vec2i32, c = def_Vec2i32) {
+    return (
+      ((b.x | 0) - (a.x | 0)) * ((c.y | 0) - (a.y | 0)) -
+      ((b.y | 0) - (a.y | 0)) * ((c.x | 0) - (a.x | 0))
+    );
+  }
+
+  static thetaEx(v = def_Vec2i32) {
+    return (mathi32_MULTIPLIER * mathi32_atan2(v.y | 0, v.x | 0)) | 0;
+  }
+
+  static phiEx(v = def_Vec2i32) {
+    return (mathi32_MULTIPLIER * mathi32_asin((v.y | 0) / Vec2i32.mag(v))) | 0;
+  }
+
+  //#endregion
+
+  //#region static advanced functions
+
+  static norm(v = def_Vec2i32) {
+    return Vec2i32.divs(v, Vec2i32.mag(v) | 0);
+  }
+
+  static rotn90(v = def_Vec2i32) {
+    return new Vec2i32(v.y | 0, -(v.x | 0) | 0);
+  }
+
+  static rot90(v = def_Vec2i32) {
+    return new Vec2i32(-(v.y | 0) | 0, v.x | 0);
+  }
+
+  //#endregion
+
+  //#region instance primitive operators
+
+  ineg() {
+    this.x = -(this.x | 0) | 0;
+    this.y = -(this.y | 0) | 0;
+    return this;
+  }
+
+  iadd(v = def_Vec2i32) {
+    this.x += v.x | 0 | 0;
+    this.y += v.y | 0 | 0;
+    return this;
+  }
+
+  iadds(scalar = 0) {
+    scalar = scalar | 0;
+    this.x += scalar | 0;
+    this.y += scalar | 0;
+    return this;
+  }
+
+  isub(v = def_Vec2i32) {
+    this.x -= v.x | 0 | 0;
+    this.y -= v.y | 0 | 0;
+    return this;
+  }
+
+  isubs(scalar = 0) {
+    scalar = scalar | 0;
+    this.x -= scalar | 0;
+    this.y -= scalar | 0;
+    return this;
+  }
+
+  imul(v = def_Vec2i32) {
+    this.x *= v.x | 0 | 0;
+    this.y *= v.y | 0 | 0;
+    return this;
+  }
+
+  imuls(scalar = 0) {
+    scalar = scalar | 0;
+    this.x *= scalar;
+    this.y *= scalar;
+    return this;
+  }
+
+  idiv(v = def_Vec2i32) {
+    this.x = ((this.x | 0) / (v.x | 0)) | 0;
+    this.y = ((this.y | 0) / (v.y | 0)) | 0;
+    return this;
+  }
+
+  idivs(scalar = 0) {
+    scalar = scalar | 0;
+    this.x = ((this.x | 0) / scalar) | 0;
+    this.y = ((this.y | 0) / scalar) | 0;
+    return this;
+  }
+
+  //#endregion
+
+  //#region instance advanced functions
+  inorm() {
+    return this.idivs(Vec2i32.mag(this) | 0);
+  }
+
+  irotn90() {
+    const t = this.x | 0;
+    this.x = this.y | 0;
+    this.y = -t | 0;
+    return this;
+  }
+
+  irot90() {
+    const t = this.x | 0;
+    this.x = -(this.y | 0) | 0;
+    this.y = t | 0;
+    return this;
+  }
+
+  //#endregion
+
+  /** Just Some Notes
+const fastSin_B = 1.2732395; // 4/pi
+const fastSin_C = -0.40528473; // -4 / (pi²)
+export function fastSin(value) {
+  // See  for graph and equations
+  // https://www.desmos.com/calculator/8nkxlrmp7a
+  // logic explained here : http://devmaster.net/posts/9648/fast-and-accurate-sine-cosine
+
+  return (value > 0)
+    ? fastSin_B * value - fastSin_C * value * value
+    : fastSin_B * value + fastSin_C * value * value;
+}
+
+export function fastSin2(a) {
+  let b, c;
+  return a *= 5214
+    , c = a << 17
+    , a -= 8192
+    , a <<= 18
+    , a >>= 18
+    , a = a * a >> 12
+    , b = 19900 - (3516 * a >> 14)
+    , b = 4096 - (a * b >> 16)
+    , 0 > c && (b = -b)
+    , 2.44E-4 * b;
+};
+
+export function fastSin3(a) {
+  a *= 5214;
+  let b = a << 17;
+  a = a - 8192 << 18 >> 18;
+  a = a * a >> 12;
+  a = 4096 - (a * (19900 - (3516 * a >> 14)) >> 16);
+  0 > b && (a = -a);
+  return 2.44E-4 * a
+};
+*/
+}
+
+export const def_Vec2i32 = Object.freeze(Object.seal(Vec2i32.new()));

package/src/math/vec3f64.js

@@ -0,0 +1,225 @@
+//@ts-check
+
+import { mathf64_sqrt } from './float64.js';
+
+import { Vec2f64 } from './vec2f64.js';
+
+/**
+ * @class Vec3f64
+ * @classdesc A 3-dimensional vector of float64 values
+ * @property {double} x - The x component of the vector
+ * @property {double} y - The y component of the vector
+ * @property {double} z - The z component of the vector
+ */
+export class Vec3f64 {
+  constructor(x = 0.0, y = 0.0, z = 0.0) {
+    this.x = +x;
+    this.y = +y;
+    this.z = +z;
+  }
+
+  /**
+   * Create a new 3 dimensional vector
+   * @param {number | Vec3f64 | Vec2f64} x a floating point number or a Vec3f64 instance or a vec2f64 instance
+   * @param {number | undefined} y a floating point number
+   * @param {number | undefined} z a floating point number
+   * @returns {Vec3f64} a new vector structure
+   */
+  static new(x = 0.0, y = 0.0, z = 0.0) {
+    return (x instanceof Vec3f64)
+      ? new Vec3f64(+x.x, +x.y, +x.z)
+      : (x instanceof Vec2f64)
+        ? new Vec3f64(+x.x, +x.y, +z) // TODO: check this
+        : new Vec3f64(+x, +y, +z);
+  }
+
+  //#region static vec3f pure operators
+
+  static add(a = def_Vec3f64, b = def_Vec3f64) {
+    return new Vec3f64(
+      +(+a.x + +b.x),
+      +(+a.y + +b.y),
+      +(+a.z + +b.z),
+    );
+  }
+
+  static adds(a = def_Vec3f64, scalar = 0.0) {
+    return new Vec3f64(
+      +(+a.x + +scalar),
+      +(+a.y + +scalar),
+      +(+a.z + +scalar),
+    );
+  }
+
+  static sub(a = def_Vec3f64, b = def_Vec3f64) {
+    return new Vec3f64(
+      +(+a.x - +b.x),
+      +(+a.y - +b.y),
+      +(+a.z - +b.z),
+    );
+  }
+
+  static subs(a = def_Vec3f64, scalar = 0.0) {
+    return new Vec3f64(
+      +(+a.x - +scalar),
+      +(+a.y - +scalar),
+      +(+a.z - +scalar),
+    );
+  }
+
+  static div(a = def_Vec3f64, b = def_Vec3f64) {
+    return new Vec3f64(
+      +(+a.x / +b.x),
+      +(+a.y / +b.y),
+      +(+a.z / +b.z),
+    );
+  }
+  static divs(v = def_Vec3f64, scalar = 0.0) {
+    return new Vec3f64(
+      +(+v.x / +scalar),
+      +(+v.y / +scalar),
+      +(+v.z / +scalar),
+    );
+  }
+
+  static mul(a = def_Vec3f64, b = def_Vec3f64) {
+    return new Vec3f64(
+      +(+a.x * +b.x),
+      +(+a.y * +b.y),
+      +(+a.z * +b.z),
+    );
+  }
+  static muls(v = def_Vec3f64, scalar = 0.0) {
+    return new Vec3f64(
+      +(+v.x * +scalar),
+      +(+v.y * +scalar),
+      +(+v.z * +scalar),
+    );
+  }
+
+  /**
+   * Returns the dot product of two 3d vectors
+   * @param {Vec3f64} a the base vector
+   * @param {Vec3f64} b the target vector
+   * @returns {number} the dot product of two vectors
+   */
+  static dot(a = def_Vec3f64, b = def_Vec3f64) {
+    return +(+(+a.x * +b.x) + +(+a.y * +b.y) + +(+a.z * +b.z));
+  }
+
+  /**
+   * Returns the cross product of two 3d vectors
+   * @param {Vec3f64} a the base vector
+   * @param {Vec3f64} b the target vector
+   * @returns {Vec3f64} the cross product of two vectors
+   */
+  static cross(a = def_Vec3f64, b = def_Vec3f64) {
+    return new Vec3f64(
+      +(+(+a.y * +b.z) - +(+a.z * +b.y)),
+      +(+(+a.z * +b.x) - +(+a.x * +b.z)),
+      +(+(+a.x * +b.y) - +(+a.y * +b.x)),
+    );
+  }
+
+  static mag2(v = def_Vec3f64) {
+    return +Vec3f64.dot(v, v);
+  }
+
+  static mag(v = def_Vec3f64) {
+    return +mathf64_sqrt(+Vec3f64.mag2(v));
+  }
+
+  static unit(v = def_Vec3f64) {
+    return Vec3f64.divs(v, +Vec3f64.mag(v));
+  }
+
+  //#endregion
+
+  //#region vec3f in-place operators
+
+  iadd(v = def_Vec3f64) {
+    this.x += +(+v.x);
+    this.y += +(+v.y);
+    this.z += +(+v.z);
+    return this;
+  }
+
+  iadds(scalar = 0.0) {
+    this.x += +scalar;
+    this.y += +scalar;
+    this.z += +scalar;
+    return this;
+  }
+
+  isub(v = def_Vec3f64) {
+    this.x -= +(+v.x);
+    this.y -= +(+v.y);
+    this.z -= +(+v.z);
+    return this;
+  }
+
+  isubs(scalar = 0.0) {
+    this.x -= +scalar;
+    this.y -= +scalar;
+    this.z -= +scalar;
+    return this;
+  }
+
+  idiv(v = def_Vec3f64) {
+    this.x /= +(+v.x);
+    this.y /= +(+v.y);
+    this.z /= +(+v.z);
+    return this;
+  }
+
+  idivs(scalar = 0.0) {
+    this.x /= +scalar;
+    this.y /= +scalar;
+    this.z /= +scalar;
+    return this;
+  }
+
+  imul(v = def_Vec3f64) {
+    this.x *= +(+v.x);
+    this.y *= +(+v.y);
+    this.z *= +(+v.z);
+    return this;
+  }
+
+  imuls(scalar = 0.0) {
+    this.x *= +scalar;
+    this.y *= +scalar;
+    this.z *= +scalar;
+    return this;
+  }
+
+  dot(v = def_Vec3f64) {
+    return Vec3f64.dot(this, v);
+  }
+
+  icross(v = def_Vec3f64) {
+    const x = +this.x;
+    const y = +this.y;
+    const z = +this.z;
+    this.x = +(+(y * +v.z) - +(z * +v.y));
+    this.y = +(+(z * +v.x) - +(x * +v.z));
+    this.z = +(+(x * +v.y) - +(y * +v.x));
+    return this;
+  }
+
+  mag2() {
+    return Vec3f64.mag2(this);
+  }
+
+  mag() {
+    return Vec3f64.mag(this);
+  }
+
+  iunit() {
+    return this.idivs(+this.mag());
+  }
+
+  //#endregion
+}
+
+export const def_Vec3f64 = Object.freeze(Object.seal(Vec3f64.new()));

package/src/number.js

@@ -0,0 +1,63 @@
+//@ts-check
+
+/**
+ * Checks if the given data is of boolean type or boolean-like (the strings 'true' or 'false').
+ * @param {any} data - The data to check.
+ * @returns {boolean} - True if the data is boolean or boolean-like, otherwise false.
+ */
+export function isBoolishType(data) {
+  return data === true
+    || data === false
+    || data === 'true'
+    || data === 'false';
+}
+
+/**
+ * Checks if the given object is a boolean type or a boolean-like string ('true' or 'false') 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 or boolean-like string.
+ * @returns {boolean|undefined} - The boolean/boolean-like value or the default value.
+ */
+export function getBoolishType(obj, def = undefined) {
+  return isBoolishType(obj) || obj === 'true' || obj === 'false'
+    ? obj
+    : def;
+}
+
+/**
+ * Checks if the given data is number-like (can be converted to a number).
+ * @param {any} data - The data to check.
+ * @returns {boolean} - True if the data is number-like, otherwise false.
+ */
+export function isNumbishType(data) {
+  return typeof data !== 'bigint' && !Number.isNaN(Number(data));
+}
+
+/**
+ * Checks if the given data is an integer-like type.
+ * @param {any} data - The data to check.
+ * @returns {boolean} - True if the data is an integer-like type, otherwise false.
+ */
+export function isIntishType(data) {
+  return Number.isInteger(Number(data));
+}
+
+/**
+ * Checks if the given object is a number-like type and returns it as a number, 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-like type.
+ * @returns {number|undefined} - The number value or the default value.
+ */
+export function getNumbishType(obj, def = undefined) {
+  return isNumbishType(obj) ? Number(obj) : def;
+}
+
+/**
+ * Checks if the given object is an integer-like type and returns it as a number, 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-like type.
+ * @returns {number|undefined} - The integer value or the default value.
+ */
+export function getIntishType(obj, def = undefined) {
+  return isIntishType(obj) ? Number(obj) : def;
+}