@futdevpro/fsm-dynamo 1.15.17 → 1.15.20

package/src/_collections/utils/math/vector2.util.ts

@@ -1,653 +1,653 @@
-
-import { DyFM_Vector2 } from '../../../_models/interfaces/vector2.interface';
-import { DyFM_Math } from './math.util';
-
-import { DyFM_Trigonometry } from './trigonometry.util';
-
-export type DyFM_V2_U = DyFM_Vector2_Util;
-export type DyFM_V2_Util = DyFM_Vector2_Util;
-export type DyFM_Vector2_U = DyFM_Vector2_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 implements DyFM_Vector2 {
-  readonly isVector2Util: boolean = true;
-
-  private _x: number = 0;
-  /** 
-   * if you are setting both x and y,
-   * use newValues() or newXY() to avoid multiple magnitude calculation
-   * */
-  set x (value: number) {
-    this._x = value;
-
-    this.calcMagnitude();
-  }
-  get x (): number { 
-    return this._x;
-  }
-
-  private _y: number = 0;
-  /** 
-   * if you are setting both x and y,
-   * use newValues() or newXY() to avoid multiple magnitude calculation
-   * */
-  set y (value: number) {
-    this._y = value;
-    
-    this.calcMagnitude();
-  }
-  get y (): number { 
-    return this._y;
-  }
-
-  private _magintude: number = 0;
-  get magintude (): number { 
-    return this._magintude;
-  }
-
-  // these are created as soft objects to avoid changing instances with DyFM_Vector2 instance functions
-  /**
-   * zero vector
-   */
-  static readonly zero: DyFM_Vector2 = { x: 0, y: 0 };
-  /**
-   * up vector
-   */
-  static readonly up: DyFM_Vector2 = { x: 0, y: 1 };
-  /**
-   * down vector
-   */
-  static readonly down: DyFM_Vector2 = { x: 0, y: -1 };
-  /**
-   * right vector
-   */
-  static readonly right: DyFM_Vector2 = { x: 1, y: 0 };
-  /**
-   * left vector
-   */
-  static readonly left: DyFM_Vector2 = { x: -1, y: 0 };
-
-  constructor(
-    xOrXyOrVector: number | DyFM_Vector2 = 0, 
-    y?: number
-  ) {
-    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 as number;
-      this._y = xOrXyOrVector as number;
-    } else {
-      this._x = xOrXyOrVector as number;
-      this._y = y;
-    }
-
-    this.calcMagnitude();
-  }
-
-  /**
-   * returns true if the vector is constructed
-   */
-  constructed?(): boolean { 
-    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: DyFM_Vector2, b: DyFM_Vector2): number {
-    return this.minus(a, b).magintude;
-  }
-  distance(to: DyFM_Vector2): number {
-    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: DyFM_Vector2, minusB: DyFM_Vector2): DyFM_Vector2_Util {
-    return this.plus(a, this.negative(minusB));
-  }
-  minus(vector: DyFM_Vector2): this {
-    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: DyFM_Vector2, plusB: DyFM_Vector2): DyFM_Vector2_Util {
-    return new DyFM_Vector2_Util(a.x + plusB.x, a.y + plusB.y);
-  }
-  plus(vector: DyFM_Vector2): this {
-    this.newValues(DyFM_Vector2_Util.plus(this, vector));
-
-    return this;
-  }
-  static readonly add = this.plus;
-  readonly 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: DyFM_Vector2, n: number): DyFM_Vector2_Util {
-    return new DyFM_Vector2_Util(v.x * n, v.y * n);
-  }
-  multiply(n: number): this {
-    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: DyFM_Vector2, divideBy: number): DyFM_Vector2_Util {
-    return new DyFM_Vector2_Util(v.x / divideBy, v.y / divideBy);
-  }
-  divide(n: number): this {
-    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: DyFM_Vector2): DyFM_Vector2_Util {
-    return new DyFM_Vector2_Util(-v.x, -v.y);
-  }
-  /** this returns a new instance */
-  getNegative(): DyFM_Vector2_Util {
-    return DyFM_Vector2_Util.negative(this);
-  }
-  negate(): this {
-    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: DyFM_Vector2, baseFrom: DyFM_Vector2, baseTo: DyFM_Vector2): DyFM_Vector2_Util {
-    return this.plus(v, this.minus(baseTo, baseFrom));
-  }
-  rebase(baseFrom: DyFM_Vector2, baseTo: DyFM_Vector2): this {
-    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: DyFM_Vector2, angle: number): DyFM_Vector2_Util {
-    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: DyFM_Vector2, rad: number): DyFM_Vector2_Util {
-    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: number): this {
-    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: number): this {
-    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: DyFM_Vector2): this {
-    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: number, newY: number): this {
-    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: DyFM_Vector2, newV: DyFM_Vector2): DyFM_Vector2 {
-    to.x = newV.x;
-    to.y = newV.y;
-
-    return to;
-  }
-  static readonly 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: DyFM_Vector2, to: DyFM_Vector2): number {
-    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: DyFM_Vector2, to: DyFM_Vector2): number {
-    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: DyFM_Vector2, to: DyFM_Vector2): number {
-    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: DyFM_Vector2): number {
-    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: DyFM_Vector2): number {
-    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(): number {
-    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: DyFM_Vector2): DyFM_Vector2_Util {
-    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(): DyFM_Vector2_Util {
-    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: DyFM_Vector2, to: DyFM_Vector2): DyFM_Vector2_Util {
-    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: DyFM_Vector2): DyFM_Vector2_Util {
-    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: DyFM_Vector2): DyFM_Vector2_Util {
-    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(): void {
-    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(): DyFM_Vector2_Util {
-    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
-   * ```
-   */
-  private calcMagnitude(): void {
-    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(): DyFM_Vector2_Util {
-    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: DyFM_Vector2_Util, b: DyFM_Vector2_Util): boolean {
-    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: DyFM_Vector2, b: DyFM_Vector2): boolean {
-    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: DyFM_Vector2, b: DyFM_Vector2): boolean {
-    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: DyFM_Vector2): DyFM_Vector2_Util {
-    return new DyFM_Vector2_Util(Math.abs(v.x), Math.abs(v.y));
-  }
-  abs(): this {
-    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: DyFM_Vector2, decimals: number = 0): DyFM_Vector2_Util {
-    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: DyFM_Vector2_Util): DyFM_Vector2 {
-    return (new DyFM_Vector2_Util(v)).get();
-  }
-
-  /**
-   * returns a instance of DyFM_Vector2 from a DyFM_Vector2_Util
-   */
-  get(): DyFM_Vector2 {
-    return { x: this.x, y: this.y };
-  }
-  getVector2 = this.get;
-  toVector2 = this.get;
-
-  /**
-   * returns a new vector with the same values
-   */
-  static clone(v: DyFM_Vector2): DyFM_Vector2 {
-    return { x: v.x, y: v.y };
-  }
-}
+
+import { DyFM_Vector2 } from '../../../_models/interfaces/vector2.interface';
+import { DyFM_Math } from './math.util';
+
+import { DyFM_Trigonometry } from './trigonometry.util';
+
+export type DyFM_V2_U = DyFM_Vector2_Util;
+export type DyFM_V2_Util = DyFM_Vector2_Util;
+export type DyFM_Vector2_U = DyFM_Vector2_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 implements DyFM_Vector2 {
+  readonly isVector2Util: boolean = true;
+
+  private _x: number = 0;
+  /** 
+   * if you are setting both x and y,
+   * use newValues() or newXY() to avoid multiple magnitude calculation
+   * */
+  set x (value: number) {
+    this._x = value;
+
+    this.calcMagnitude();
+  }
+  get x (): number { 
+    return this._x;
+  }
+
+  private _y: number = 0;
+  /** 
+   * if you are setting both x and y,
+   * use newValues() or newXY() to avoid multiple magnitude calculation
+   * */
+  set y (value: number) {
+    this._y = value;
+    
+    this.calcMagnitude();
+  }
+  get y (): number { 
+    return this._y;
+  }
+
+  private _magintude: number = 0;
+  get magintude (): number { 
+    return this._magintude;
+  }
+
+  // these are created as soft objects to avoid changing instances with DyFM_Vector2 instance functions
+  /**
+   * zero vector
+   */
+  static readonly zero: DyFM_Vector2 = { x: 0, y: 0 };
+  /**
+   * up vector
+   */
+  static readonly up: DyFM_Vector2 = { x: 0, y: 1 };
+  /**
+   * down vector
+   */
+  static readonly down: DyFM_Vector2 = { x: 0, y: -1 };
+  /**
+   * right vector
+   */
+  static readonly right: DyFM_Vector2 = { x: 1, y: 0 };
+  /**
+   * left vector
+   */
+  static readonly left: DyFM_Vector2 = { x: -1, y: 0 };
+
+  constructor(
+    xOrXyOrVector: number | DyFM_Vector2 = 0, 
+    y?: number
+  ) {
+    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 as number;
+      this._y = xOrXyOrVector as number;
+    } else {
+      this._x = xOrXyOrVector as number;
+      this._y = y;
+    }
+
+    this.calcMagnitude();
+  }
+
+  /**
+   * returns true if the vector is constructed
+   */
+  constructed?(): boolean { 
+    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: DyFM_Vector2, b: DyFM_Vector2): number {
+    return this.minus(a, b).magintude;
+  }
+  distance(to: DyFM_Vector2): number {
+    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: DyFM_Vector2, minusB: DyFM_Vector2): DyFM_Vector2_Util {
+    return this.plus(a, this.negative(minusB));
+  }
+  minus(vector: DyFM_Vector2): this {
+    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: DyFM_Vector2, plusB: DyFM_Vector2): DyFM_Vector2_Util {
+    return new DyFM_Vector2_Util(a.x + plusB.x, a.y + plusB.y);
+  }
+  plus(vector: DyFM_Vector2): this {
+    this.newValues(DyFM_Vector2_Util.plus(this, vector));
+
+    return this;
+  }
+  static readonly add = this.plus;
+  readonly 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: DyFM_Vector2, n: number): DyFM_Vector2_Util {
+    return new DyFM_Vector2_Util(v.x * n, v.y * n);
+  }
+  multiply(n: number): this {
+    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: DyFM_Vector2, divideBy: number): DyFM_Vector2_Util {
+    return new DyFM_Vector2_Util(v.x / divideBy, v.y / divideBy);
+  }
+  divide(n: number): this {
+    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: DyFM_Vector2): DyFM_Vector2_Util {
+    return new DyFM_Vector2_Util(-v.x, -v.y);
+  }
+  /** this returns a new instance */
+  getNegative(): DyFM_Vector2_Util {
+    return DyFM_Vector2_Util.negative(this);
+  }
+  negate(): this {
+    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: DyFM_Vector2, baseFrom: DyFM_Vector2, baseTo: DyFM_Vector2): DyFM_Vector2_Util {
+    return this.plus(v, this.minus(baseTo, baseFrom));
+  }
+  rebase(baseFrom: DyFM_Vector2, baseTo: DyFM_Vector2): this {
+    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: DyFM_Vector2, angle: number): DyFM_Vector2_Util {
+    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: DyFM_Vector2, rad: number): DyFM_Vector2_Util {
+    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: number): this {
+    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: number): this {
+    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: DyFM_Vector2): this {
+    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: number, newY: number): this {
+    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: DyFM_Vector2, newV: DyFM_Vector2): DyFM_Vector2 {
+    to.x = newV.x;
+    to.y = newV.y;
+
+    return to;
+  }
+  static readonly 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: DyFM_Vector2, to: DyFM_Vector2): number {
+    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: DyFM_Vector2, to: DyFM_Vector2): number {
+    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: DyFM_Vector2, to: DyFM_Vector2): number {
+    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: DyFM_Vector2): number {
+    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: DyFM_Vector2): number {
+    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(): number {
+    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: DyFM_Vector2): DyFM_Vector2_Util {
+    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(): DyFM_Vector2_Util {
+    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: DyFM_Vector2, to: DyFM_Vector2): DyFM_Vector2_Util {
+    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: DyFM_Vector2): DyFM_Vector2_Util {
+    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: DyFM_Vector2): DyFM_Vector2_Util {
+    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(): void {
+    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(): DyFM_Vector2_Util {
+    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
+   * ```
+   */
+  private calcMagnitude(): void {
+    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(): DyFM_Vector2_Util {
+    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: DyFM_Vector2_Util, b: DyFM_Vector2_Util): boolean {
+    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: DyFM_Vector2, b: DyFM_Vector2): boolean {
+    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: DyFM_Vector2, b: DyFM_Vector2): boolean {
+    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: DyFM_Vector2): DyFM_Vector2_Util {
+    return new DyFM_Vector2_Util(Math.abs(v.x), Math.abs(v.y));
+  }
+  abs(): this {
+    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: DyFM_Vector2, decimals: number = 0): DyFM_Vector2_Util {
+    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: DyFM_Vector2_Util): DyFM_Vector2 {
+    return (new DyFM_Vector2_Util(v)).get();
+  }
+
+  /**
+   * returns a instance of DyFM_Vector2 from a DyFM_Vector2_Util
+   */
+  get(): DyFM_Vector2 {
+    return { x: this.x, y: this.y };
+  }
+  getVector2 = this.get;
+  toVector2 = this.get;
+
+  /**
+   * returns a new vector with the same values
+   */
+  static clone(v: DyFM_Vector2): DyFM_Vector2 {
+    return { x: v.x, y: v.y };
+  }
+}