@futdevpro/fsm-dynamo 1.9.10 → 1.9.12

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

@@ -1,53 +1,53 @@
-
-
-
-
-
-
-
-
-
-export class DynamoFM_Math {
-
-  static between(value: number, minExclusive: number, maxExclusive: number): boolean {
-    return minExclusive < value && value < maxExclusive;
-  }
-
-  static around(value: number, target: number, range: number): boolean {
-    return this.between(value, target - range, target + range);
-  }
-
-  static getRandomInt(min: number, max: number): number {
-    return min + Math.round((max - min) * Math.random());
-  }
-
-  static round(value: number, decimals: number = 2): number {
-    return Number(value.toFixed(decimals));
-  }
-
-  static numberWithSpaces(x: number): string {
-    return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
-  }
-
-  static floatingNumberWithSpaces(x: number): string {
-    const parts: string[] = x.toString().split('.');
-
-    parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
-
-    return parts.join('.');
-  }
-
-  static decimals(x: number, useSpacer: string = ','): string {
-    const parts: string[] = x.toString().split('.');
-
-    parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, useSpacer);
-
-    return parts.join('.');
-  }
-}
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+export class DynamoFM_Math {
+
+  static between(value: number, minExclusive: number, maxExclusive: number): boolean {
+    return minExclusive < value && value < maxExclusive;
+  }
+
+  static around(value: number, target: number, range: number): boolean {
+    return this.between(value, target - range, target + range);
+  }
+
+  static getRandomInt(min: number, max: number): number {
+    return min + Math.round((max - min) * Math.random());
+  }
+
+  static round(value: number, decimals: number = 2): number {
+    return Number(value.toFixed(decimals));
+  }
+
+  static numberWithSpaces(x: number): string {
+    return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
+  }
+
+  static floatingNumberWithSpaces(x: number): string {
+    const parts: string[] = x.toString().split('.');
+
+    parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
+
+    return parts.join('.');
+  }
+
+  static decimals(x: number, useSpacer: string = ','): string {
+    const parts: string[] = x.toString().split('.');
+
+    parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, useSpacer);
+
+    return parts.join('.');
+  }
+}
+
+
+
+
+
+

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

@@ -1,80 +1,80 @@
-
-import { DynamoFM_RandomWeight } from '../../../_models/interfaces/random-weight.interface';
-
-export type DFM_Random = DynamoFM_Random;
-export class DynamoFM_Random {
-  static getRandomWeightedInt(
-    min: number, 
-    max: number, 
-    weights: DynamoFM_RandomWeight<number>[]
-  ): number {
-    weights = weights.sort((a, b): number => b.chance - a.chance);
-    let weightChanceSum = 0;
-
-    weights.forEach((weight): void => { weightChanceSum += weight.chance; });
-
-    if (1 < weightChanceSum) {
-      weights.forEach((weights): void => { weights.chance = weights.chance / weightChanceSum; });
-    }
-  
-    const randomChance: number = Math.random();
-    let result: number;
-    let chancer = 0;
-
-    for (let i = 0; i < weights.length && result === undefined; i++) {
-      chancer += weights[i].chance;
-
-      if (randomChance < chancer) {
-        result = weights[i].result;
-      }
-    }
-  
-    if (result !== undefined) {
-      return result;
-    } else {
-      return this.getRandomInt(min, max);
-    }
-  }
-  
-  static getRandomInt(min: number, max: number): number {
-    return min + Math.round((max - min) * Math.random());
-  }
-  
-  static getRandomListElement<T>(list: T[]): T {
-    if (0 < list.length) {
-      return list[this.getRandomInt(0, list.length - 1)];
-    } else {
-      return null;
-    }
-  }
-  
-  static getRandomWeighted<T>(weights: DynamoFM_RandomWeight<T>[]): T {
-    if (!weights?.length) {
-      return null;
-    }
-  
-    weights = weights.sort((a, b): number => b.chance - a.chance);
-    let weightChanceSum = 0;
-
-    weights.forEach((weight): void => { 
-      weightChanceSum += weight.chance; 
-    });
-    weights.forEach((weights): void => { 
-      weights.chance = weights.chance / weightChanceSum; 
-    });
-  
-    const randomChance: number = Math.random();
-    let result: T;
-    let chancer = 0;
-
-    for (let i = 0; i < weights.length && result === undefined; i++) {
-      chancer += weights[i].chance;
-
-      if (randomChance < chancer) {
-        result = weights[i].result;
-      }
-    }
-  
-    return result;
-  }
-}
+
+import { DynamoFM_RandomWeight } from '../../../_models/interfaces/random-weight.interface';
+
+export type DFM_Random = DynamoFM_Random;
+export class DynamoFM_Random {
+  static getRandomWeightedInt(
+    min: number, 
+    max: number, 
+    weights: DynamoFM_RandomWeight<number>[]
+  ): number {
+    weights = weights.sort((a, b): number => b.chance - a.chance);
+    let weightChanceSum = 0;
+
+    weights.forEach((weight): void => { weightChanceSum += weight.chance; });
+
+    if (1 < weightChanceSum) {
+      weights.forEach((weights): void => { weights.chance = weights.chance / weightChanceSum; });
+    }
+  
+    const randomChance: number = Math.random();
+    let result: number;
+    let chancer = 0;
+
+    for (let i = 0; i < weights.length && result === undefined; i++) {
+      chancer += weights[i].chance;
+
+      if (randomChance < chancer) {
+        result = weights[i].result;
+      }
+    }
+  
+    if (result !== undefined) {
+      return result;
+    } else {
+      return this.getRandomInt(min, max);
+    }
+  }
+  
+  static getRandomInt(min: number, max: number): number {
+    return min + Math.round((max - min) * Math.random());
+  }
+  
+  static getRandomListElement<T>(list: T[]): T {
+    if (0 < list.length) {
+      return list[this.getRandomInt(0, list.length - 1)];
+    } else {
+      return null;
+    }
+  }
+  
+  static getRandomWeighted<T>(weights: DynamoFM_RandomWeight<T>[]): T {
+    if (!weights?.length) {
+      return null;
+    }
+  
+    weights = weights.sort((a, b): number => b.chance - a.chance);
+    let weightChanceSum = 0;
+
+    weights.forEach((weight): void => { 
+      weightChanceSum += weight.chance; 
+    });
+    weights.forEach((weights): void => { 
+      weights.chance = weights.chance / weightChanceSum; 
+    });
+  
+    const randomChance: number = Math.random();
+    let result: T;
+    let chancer = 0;
+
+    for (let i = 0; i < weights.length && result === undefined; i++) {
+      chancer += weights[i].chance;
+
+      if (randomChance < chancer) {
+        result = weights[i].result;
+      }
+    }
+  
+    return result;
+  }
+}

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

@@ -1,73 +1,73 @@
-
-export type DFM_Trigonometry = DynamoFM_Trigonometry;
-export type DFM_Trig = DynamoFM_Trigonometry;
-export type DFM_Δ = DynamoFM_Trigonometry;
-export class DynamoFM_Trigonometry {
-  
-  /**
-   * Befogó
-   * a Befogó mérete az átfogó, és a befogóval szemközti szög alapján
-   * a szemközti szög értéke opcionális 
-   * (amennyiben nem adjuk meg, 45 fokos szöggel számolunk)
-   * @param c átfogó
-   * @param angle a befogó oldallal szemközti szög (fokban)
-   * @returns befogó
-   */
-  static getClamp(c: number, angle?: number): number {
-    angle = angle !== undefined ? angle : 45;
-
-    return Math.sin(this.angleToRadians(angle)) * c;
-  }
-
-  /**
-   * Befogó
-   * a Befogó mérete az átfogó és a másik befogó alapján
-   * @param a befogó
-   * @param c átfogó
-   * @returns befogó
-   */
-  static getClampByClampAndHypotenuse(a: number, c: number): number {
-    if (a > c) {
-
-      throw { 
-        errorMessage: 
-          `getClampByClampAndHypotenuse error hypotenuse is smaller than clamp (a:${a} > c:${c})` 
-      };
-    }
-
-    return Math.sqrt((c * c) - (a * a));
-  }
-
-  /**
-   * Átfogó
-   * az Átfogó mérete a befogók alapján
-   * a második befogó értéke opcionális 
-   * (amennyiben nem adjuk meg, egyenlő szárú háromszöggel számolunk)
-   * @param a egyik befogó
-   * @param b másik befogó
-   * @returns átfogó
-   */
-  static getHypotenuse(a: number, b?: number): number {
-    b = b !== undefined ? b : a;
-    
-    return Math.sqrt((a * a) + (b * b));
-  }
-
-  /**
-   * Szög fokmértéket átalakítja radiánsra
-   * @param angle szög fok
-   * @returns szög radiáns
-   */
-  static angleToRadians(angle: number): number {
-    return angle * Math.PI / 180;
-  }
-
-  /**
-   * Szög radiáns mértéket átalakítja fokra
-   * @param radians szög radiáns
-   * @returns szög fok
-   */
-  static radiansToAngle(radians: number): number {
-    return radians / Math.PI * 180;
-  }
-}
+
+export type DFM_Trigonometry = DynamoFM_Trigonometry;
+export type DFM_Trig = DynamoFM_Trigonometry;
+export type DFM_Δ = DynamoFM_Trigonometry;
+export class DynamoFM_Trigonometry {
+  
+  /**
+   * Befogó
+   * a Befogó mérete az átfogó, és a befogóval szemközti szög alapján
+   * a szemközti szög értéke opcionális 
+   * (amennyiben nem adjuk meg, 45 fokos szöggel számolunk)
+   * @param c átfogó
+   * @param angle a befogó oldallal szemközti szög (fokban)
+   * @returns befogó
+   */
+  static getClamp(c: number, angle?: number): number {
+    angle = angle !== undefined ? angle : 45;
+
+    return Math.sin(this.angleToRadians(angle)) * c;
+  }
+
+  /**
+   * Befogó
+   * a Befogó mérete az átfogó és a másik befogó alapján
+   * @param a befogó
+   * @param c átfogó
+   * @returns befogó
+   */
+  static getClampByClampAndHypotenuse(a: number, c: number): number {
+    if (a > c) {
+
+      throw { 
+        errorMessage: 
+          `getClampByClampAndHypotenuse error hypotenuse is smaller than clamp (a:${a} > c:${c})` 
+      };
+    }
+
+    return Math.sqrt((c * c) - (a * a));
+  }
+
+  /**
+   * Átfogó
+   * az Átfogó mérete a befogók alapján
+   * a második befogó értéke opcionális 
+   * (amennyiben nem adjuk meg, egyenlő szárú háromszöggel számolunk)
+   * @param a egyik befogó
+   * @param b másik befogó
+   * @returns átfogó
+   */
+  static getHypotenuse(a: number, b?: number): number {
+    b = b !== undefined ? b : a;
+    
+    return Math.sqrt((a * a) + (b * b));
+  }
+
+  /**
+   * Szög fokmértéket átalakítja radiánsra
+   * @param angle szög fok
+   * @returns szög radiáns
+   */
+  static angleToRadians(angle: number): number {
+    return angle * Math.PI / 180;
+  }
+
+  /**
+   * Szög radiáns mértéket átalakítja fokra
+   * @param radians szög radiáns
+   * @returns szög fok
+   */
+  static radiansToAngle(radians: number): number {
+    return radians / Math.PI * 180;
+  }
+}