@futdevpro/fsm-dynamo 1.20.92 → 1.20.93

package/build-esm/_collections/utils/math/vector2.util.js

@@ -0,0 +1,587 @@
+import { DyFM_Math } from './math.util';
+import { DyFM_Trigonometry } from './trigonometry.util';
+/**
+ * The main difference between static class functions and instance functions
+ * is that static functions return new Vector2,
+ * while instance functions change the current Vector2 and returns itself.
+ * (if this is not true, report it as a bug)
+ *
+ * @example
+ * ```ts
+ * const vector2 = new DyFM_Vector2_Util(1);
+ * const vector2 = new DyFM_Vector2_Util(1, 2);
+ * const vector2 = new DyFM_Vector2_Util({ x: 1, y: 2 });
+ * ```
+ */
+export class DyFM_Vector2_Util {
+    isVector2Util = true;
+    _x = 0;
+    /**
+     * if you are setting both x and y,
+     * use newValues() or newXY() to avoid multiple magnitude calculation
+     * */
+    set x(value) {
+        this._x = value;
+        this.calcMagnitude();
+    }
+    get x() {
+        return this._x;
+    }
+    _y = 0;
+    /**
+     * if you are setting both x and y,
+     * use newValues() or newXY() to avoid multiple magnitude calculation
+     * */
+    set y(value) {
+        this._y = value;
+        this.calcMagnitude();
+    }
+    get y() {
+        return this._y;
+    }
+    _magintude = 0;
+    get magintude() {
+        return this._magintude;
+    }
+    // these are created as soft objects to avoid changing instances with DyFM_Vector2 instance functions
+    /**
+     * zero vector
+     */
+    static zero = { x: 0, y: 0 };
+    /**
+     * up vector
+     */
+    static up = { x: 0, y: 1 };
+    /**
+     * down vector
+     */
+    static down = { x: 0, y: -1 };
+    /**
+     * right vector
+     */
+    static right = { x: 1, y: 0 };
+    /**
+     * left vector
+     */
+    static left = { x: -1, y: 0 };
+    constructor(xOrXyOrVector = 0, y) {
+        if (typeof xOrXyOrVector === 'object' &&
+            xOrXyOrVector.x !== undefined &&
+            xOrXyOrVector.y !== undefined) {
+            this._x = xOrXyOrVector.x;
+            this._y = xOrXyOrVector.y;
+        }
+        else if (y === undefined) {
+            this._x = xOrXyOrVector;
+            this._y = xOrXyOrVector;
+        }
+        else {
+            this._x = xOrXyOrVector;
+            this._y = y;
+        }
+        this.calcMagnitude();
+    }
+    /**
+     * returns true if the vector is constructed
+     */
+    constructed() {
+        return true;
+    }
+    /**
+     * returns the distance between two vectors
+     *
+     * @example
+     * ```ts
+     * const distance = DyFM_Vector2_Util.distance({ x: 1, y: 2 }, { x: 3, y: 4 });
+     * console.log(distance); // 2.8284271247461903
+     * ```
+     */
+    static distance(a, b) {
+        return this.minus(a, b).magintude;
+    }
+    distance(to) {
+        return DyFM_Vector2_Util.distance(this, to);
+    }
+    /**
+     * returns a new vector with the subtraction of two vectors
+     *
+     * @example
+     * ```ts
+     * const minus = DyFM_Vector2_Util.minus({ x: 1, y: 2 }, { x: 3, y: 4 });
+     * console.log(minus); // { x: -2, y: -2 }
+     * ```
+     */
+    static minus(a, minusB) {
+        return this.plus(a, this.negative(minusB));
+    }
+    minus(vector) {
+        this.plus(DyFM_Vector2_Util.negative(vector));
+        return this;
+    }
+    /**
+     * returns a new vector with the sum of two vectors
+     *
+     * @example
+     * ```ts
+     * const plus = DyFM_Vector2_Util.plus({ x: 1, y: 2 }, { x: 3, y: 4 });
+     * console.log(plus); // { x: 4, y: 6 }
+     * ```
+     */
+    static plus(a, plusB) {
+        return new DyFM_Vector2_Util(a.x + plusB.x, a.y + plusB.y);
+    }
+    plus(vector) {
+        this.newValues(DyFM_Vector2_Util.plus(this, vector));
+        return this;
+    }
+    static add = this.plus;
+    add = this.plus;
+    /** returns a new vector with the multiplication of two vectors
+     * @example
+     * ```ts
+     * const multiply = DyFM_Vector2_Util.multiply({ x: 1, y: 2 }, 2);
+     * console.log(multiply); // { x: 2, y: 4 }
+     * ```
+     */
+    static multiply(v, n) {
+        return new DyFM_Vector2_Util(v.x * n, v.y * n);
+    }
+    multiply(n) {
+        return this.newValues(DyFM_Vector2_Util.multiply(this, n));
+    }
+    /** returns a new vector with the division of two vectors
+     * @example
+     * ```ts
+     * const divide = DyFM_Vector2_Util.divide({ x: 1, y: 2 }, 2);
+     * console.log(divide); // { x: 0.5, y: 1 }
+     * ```
+     */
+    static divide(v, divideBy) {
+        return new DyFM_Vector2_Util(v.x / divideBy, v.y / divideBy);
+    }
+    divide(n) {
+        this.newValues(DyFM_Vector2_Util.divide(this, n));
+        return this;
+    }
+    /** returns the negative value of the original vector at new vector
+     * @example
+     * ```ts
+     * const negative = DyFM_Vector2_Util.negative({ x: 1, y: 2 });
+     * console.log(negative); // { x: -1, y: -2 }
+     * ```
+     */
+    static negative(v) {
+        return new DyFM_Vector2_Util(-v.x, -v.y);
+    }
+    /** this returns a new instance */
+    getNegative() {
+        return DyFM_Vector2_Util.negative(this);
+    }
+    negate() {
+        this.newValues(DyFM_Vector2_Util.negative(this));
+        return this;
+    }
+    /**
+     * returns a new vector with the rebase of the original vector
+     *
+     * @example
+     * ```ts
+     * const rebase = DyFM_Vector2_Util.rebase({ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 });
+     * console.log(rebase); // { x: 4, y: 6 }
+     * ```
+     */
+    static rebase(v, baseFrom, baseTo) {
+        return this.plus(v, this.minus(baseTo, baseFrom));
+    }
+    rebase(baseFrom, baseTo) {
+        this.newValues(DyFM_Vector2_Util.rebase(this, baseFrom, baseTo));
+        return this;
+    }
+    /**
+     * returns a new vector with the rotation of the original vector by degrees
+     *
+     * @example
+     * ```ts
+     * const rotate = DyFM_Vector2_Util.rotate({ x: 1, y: 2 }, 30);
+     * console.log(rotate); // { x: 0.8660254037844386, y: 1.5 }
+     * ```
+     */
+    static rotate(vector, angle) {
+        const rad = DyFM_Trigonometry.angleToRadians(angle);
+        return this.rotateRad(vector, rad);
+    }
+    /**
+     * returns a new vector with the rotation of the original vector by radians
+     *
+     * @example
+     * ```ts
+     * const rotateRad = DyFM_Vector2_Util.rotateRad({ x: 1, y: 2 }, 3.141592653589793);
+     * console.log(rotateRad); // { x: -1, y: 2 }
+     * ```
+     */
+    static rotateRad(vector, rad) {
+        const cos = Math.cos(rad);
+        const sin = Math.sin(rad);
+        const newX = (vector.x * cos) - (vector.y * sin);
+        const newY = (vector.x * sin) + (vector.y * cos);
+        return new DyFM_Vector2_Util(newX, newY);
+    }
+    /**
+     * returns a new vector with the rotation of the original vector by degrees
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * vector.rotate(30);
+     * ```
+     */
+    rotate(angle) {
+        this.newValues(DyFM_Vector2_Util.rotate(this, angle));
+        return this;
+    }
+    /**
+     * returns a new vector with the rotation of the original vector by radians
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * vector.rotateRad(3.141592653589793);
+     * ```
+     */
+    rotateRad(rad) {
+        this.newValues(DyFM_Vector2_Util.rotateRad(this, rad));
+        return this;
+    }
+    /**
+     * returns a new DyFM_Vector2_Util with the new values
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * vector.newValues({ x: 3, y: 4 });
+     * ```
+     */
+    newValues(newV) {
+        this.newXY(newV.x, newV.y);
+        return this;
+    }
+    /**
+     * returns a new vector with the sum of a vector and the difference of two vectors
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * vector.newXY(3, 4);
+     * ```
+     */
+    newXY(newX, newY) {
+        this._x = newX;
+        this._y = newY;
+        this.calcMagnitude();
+        return this;
+    }
+    /**
+     * returns a new DyFM_Vector2_Util with the new values
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * DyFM_Vector2_Util.newValues(vector, { x: 3, y: 4 });
+     * ```
+     */
+    static newValues(to, newV) {
+        to.x = newV.x;
+        to.y = newV.y;
+        return to;
+    }
+    static newXY = this.newValues;
+    //// AI-ed UNCHECKED
+    /**
+     * returns the angle between two vectors
+     *
+     * @example
+     * ```ts
+     * const angle = DyFM_Vector2_Util.angle({ x: 1, y: 2 }, { x: 3, y: 4 });
+     * console.log(angle); // 45
+     * ```
+     */
+    static angle(from, to) {
+        return DyFM_Trigonometry.radiansToAngle(DyFM_Vector2_Util.angleRad(from, to));
+    }
+    /**
+     * returns the angle between two vectors in radians
+     *
+     * @example
+     * ```ts
+     * const angleRad = DyFM_Vector2_Util.angleRad({ x: 1, y: 2 }, { x: 3, y: 4 });
+     * console.log(angleRad); // 0.7853981633974483
+     * ```
+     */
+    static angleRad(from, to) {
+        return Math.atan2(to.y - from.y, to.x - from.x);
+    }
+    /**
+     * returns the angle between two vectors
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const angle = vector.angle({ x: 3, y: 4 });
+     * console.log(angle); // 45
+     * ```
+     */
+    angle(from, to) {
+        return DyFM_Vector2_Util.angle(from, to);
+    }
+    /**
+     * returns the angle between two vectors in degrees
+     *
+     * @example
+     * ```ts
+     * const angle = DyFM_Vector2_Util.deg({ x: 1, y: 2 });
+     * console.log(angle); // 45
+     */
+    static deg(vector) {
+        return DyFM_Trigonometry.radiansToAngle(DyFM_Vector2_Util.rad(vector));
+    }
+    /**
+     * returns the angle between two vectors in radians
+     *
+     * @example
+     * ```ts
+     * const angleRad = DyFM_Vector2_Util.rad({ x: 1, y: 2 });
+     * console.log(angleRad); // 0.7853981633974483
+     * ```
+     */
+    static rad(vector) {
+        return Math.atan2(vector.y, vector.x);
+    }
+    /**
+     * returns the vector angle in degrees
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const deg = vector.deg();
+     * console.log(deg); // 45
+     * ```
+     */
+    deg() {
+        return DyFM_Vector2_Util.deg(this);
+    }
+    /**
+     * returns math floor of the vector
+     *
+     * @example
+     * ```ts
+     * const vector = DyFM_Vector2_Util.floor({ x: 1.5, y: 2.5 });
+     * console.log(vector); // { x: 1, y: 2 }
+     * ```
+     */
+    static floor(v) {
+        return new DyFM_Vector2_Util(Math.floor(v.x), Math.floor(v.y));
+    }
+    /**
+     * returns math floor of the vector
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1.5, y: 2.5 });
+     * const floor = vector.floor();
+     * console.log(floor); // { x: 1, y: 2 }
+     * ```
+     */
+    floor() {
+        return DyFM_Vector2_Util.floor(this);
+    }
+    /////
+    /**
+     * returns the direction vector from one point to another
+     *
+     * @example
+     * ```ts
+     * const direction = DyFM_Vector2_Util.direction({ x: 1, y: 2 }, { x: 3, y: 4 });
+     * console.log(direction); // { x: 2, y: 2 }
+     * ```
+     */
+    static direction(from, to) {
+        return DyFM_Vector2_Util.minus(to, from);
+    }
+    /**
+     * returns the direction vector from one point to another
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const direction = vector.direction({ x: 3, y: 4 });
+     * console.log(direction); // { x: 2, y: 2 }
+     * ```
+     */
+    direction(to) {
+        return DyFM_Vector2_Util.direction(this, to);
+    }
+    /**
+     * returns a normalized vector
+     *
+     * @example
+     * ```ts
+     * const vector = DyFM_Vector2_Util.normalize({ x: 1, y: 2 });
+     * console.log(vector); // { x: 0.4472135954999579, y: 0.8944271909999159 }
+     * ```
+     */
+    static normalize(v) {
+        const v_U = new DyFM_Vector2_Util(v);
+        return v_U.multiply(1 / v_U.magintude);
+    }
+    /**
+     * returns a normalized vector
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * vector.normalize();
+     * console.log(vector); // { x: 0.4472135954999579, y: 0.8944271909999159 }
+     * ```
+     */
+    normalize() {
+        this.newValues(DyFM_Vector2_Util.normalize(this));
+    }
+    /**
+     * this will return a new instance,
+     * if you want to change the current instance, use normalize()
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const normalized = vector.normalized();
+     * console.log(normalized); // { x: 0.4472135954999579, y: 0.8944271909999159 }
+     * ```
+     */
+    normalized() {
+        return DyFM_Vector2_Util.normalize(this);
+    }
+    /**
+     * returns the magnitude of the vector
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const magnitude = vector.magnitude();
+     * console.log(magnitude); // 2.23606797749979
+     * ```
+     */
+    calcMagnitude() {
+        this._magintude = DyFM_Trigonometry.getHypotenuse(this._x, this._y);
+    }
+    /**
+     * returns a new vector with the same values
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const clone = vector.clone();
+     * console.log(clone); // { x: 1, y: 2 }
+     * ```
+     */
+    clone() {
+        return new DyFM_Vector2_Util(this._x, this._y);
+    }
+    /**
+     * returns true if the vector has changed
+     *
+     * @example
+     * ```ts
+     * const vector1 = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const vector2 = new DyFM_Vector2_Util({ x: 3, y: 4 });
+     * const isChanged = DyFM_Vector2_Util.isChanged(vector1, vector2);
+     * console.log(isChanged); // true
+     * ```
+     */
+    static isChanged(a, b) {
+        return a.x !== b.x || a.y !== b.y;
+    }
+    /**
+     * returns true if the vectors are equal
+     *
+     * @example
+     * ```ts
+     * const vector1 = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const vector2 = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const isEqual = DyFM_Vector2_Util.isEqual(vector1, vector2);
+     * console.log(isEqual); // true
+     * ```
+     */
+    static isEqual(a, b) {
+        return a.x === b.x && a.y === b.y;
+    }
+    /**
+     * returns true if the vectors have changed
+     *
+     * @example
+     * ```ts
+     * const vector1 = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const vector2 = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const isVectorChanged = DyFM_Vector2_Util.vectorChanged(vector1, vector2);
+     * console.log(isVectorChanged); // false
+     * ```
+     */
+    static vectorChanged(a, b) {
+        return a.x !== b.x || a.y !== b.y;
+    }
+    /**
+     * returns a new vector with the absolute values of the original vector
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const vector = DyFM_Vector2_Util.abs(vector);
+     * console.log(vector);
+     * ```
+     */
+    static abs(v) {
+        return new DyFM_Vector2_Util(Math.abs(v.x), Math.abs(v.y));
+    }
+    abs() {
+        return this.newXY(Math.abs(this.x), Math.abs(this.y));
+    }
+    /**
+     * returns a new vector with the rounded values of the original vector
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1.5, y: 2.5 });
+     * const rounded = DyFM_Vector2_Util.round(vector);
+     * const rounded2 = DyFM_Vector2_Util.round(vector,3);
+     * ```
+     */
+    static round(v, decimals = 0) {
+        return new DyFM_Vector2_Util(DyFM_Math.round(v.x, decimals), DyFM_Math.round(v.y, decimals));
+    }
+    /**
+     * returns a instance of DyFM_Vector2 from a DyFM_Vector2_Util
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const vector2 = DyFM_Vector2_Util.toVector2(vector);
+     * console.log(vector2);
+     * ```
+     */
+    static toVector2(v) {
+        return (new DyFM_Vector2_Util(v)).get();
+    }
+    /**
+     * returns a instance of DyFM_Vector2 from a DyFM_Vector2_Util
+     */
+    get() {
+        return { x: this.x, y: this.y };
+    }
+    getVector2 = this.get;
+    toVector2 = this.get;
+    /**
+     * returns a new vector with the same values
+     */
+    static clone(v) {
+        return { x: v.x, y: v.y };
+    }
+}