pimath 0.0.118 → 0.0.120

package/dist/pi.js

@@ -6794,12 +6794,18 @@ class Vector {
             return Vector.scalarProduct(this, V);
             // return this._x.clone().multiply(V.x).add(this._y.clone().multiply(V.y));
         };
+        this.determinantWithVector = (V) => {
+            return Vector.determinant(this, V);
+        };
         this.normal = () => {
             let x = this.x.clone().opposed(), y = this.y.clone();
             this._x = y;
             this._y = x;
             return this;
         };
+        this.isColinearTo = (v) => {
+            return this.determinantWithVector(v).isZero();
+        };
         this.isNormalTo = (v) => {
             return this.scalarProductWithVector(v).isZero();
         };
@@ -6875,6 +6881,9 @@ exports.Vector = Vector;
 Vector.scalarProduct = (v1, v2) => {
     return v1.x.clone().multiply(v2.x).add(v1.y.clone().multiply(v2.y));
 };
+Vector.determinant = (v1, v2) => {
+    return v1.x.clone().multiply(v2.y).subtract(v1.y.clone().multiply(v2.x));
+};
 
 
 /***/ }),
@@ -6989,44 +6998,55 @@ class Numeric {
         }
         return triplets;
     }
-    static numberCorrection(value, epsilonDigit = 1, epsilonNumberOfDigits = 10, number_of_digits = 6) {
-        // Must modify the number if it's like:
-        // a: 3.0000000000000003
-        // b: 3.9999999999999994
-        // remove the last character
-        // check if around n last characters are either 0 or 9
-        // if it is, 'round' the number.
-        function extractDecimalPart(valueToExtract, decimalLength) {
-            let decimal = valueToExtract.toString();
-            if (!decimal.includes('.')) {
-                return '';
-            }
-            decimal = decimal.split('.')[1];
-            return decimal.substring(0, decimalLength);
-        }
-        const epsilon = Number(`0.${"0".repeat(epsilonNumberOfDigits - 1)}${epsilonDigit}`);
-        const decimal = extractDecimalPart(value, epsilonNumberOfDigits);
-        if (decimal === '') {
-            return value;
-        }
-        const n9 = decimal.match(/9+$/g);
-        const n0 = decimal.match(/0+$/g);
-        if (n9 && n9[0].length >= number_of_digits) {
-            // New tested values.
-            const mod = extractDecimalPart(value + epsilon, epsilonNumberOfDigits), mod0 = mod.match(/0+$/g);
-            if (mod0 && mod0[0].length >= number_of_digits) {
-                return +((value + epsilon).toString().split(mod0[0])[0]);
-            }
-        }
-        if (n0 && n0[0].length >= number_of_digits) {
-            // New tested values.
-            const mod = extractDecimalPart(value - epsilon, epsilonNumberOfDigits), mod9 = mod.match(/9+$/g);
-            if (mod9 && mod9[0].length >= number_of_digits) {
-                // The value can be changed. Remove all nines!
-                return +(value.toString().split(n0[0])[0]);
-            }
-        }
-        return value;
+    static numberCorrection(value, epsilonDigit = 1, epsilonNumberOfDigits = 10, number_of_digits = 8) {
+        return +value.toFixed(number_of_digits);
+        //
+        // // Must modify the number if it's like:
+        // // a: 3.0000000000000003
+        // // b: 3.9999999999999994
+        // // remove the last character
+        // // check if around n last characters are either 0 or 9
+        // // if it is, 'round' the number.
+        // function extractDecimalPart(valueToExtract: number, decimalLength: number){
+        //     let decimal = valueToExtract.toString()
+        //
+        //     if (!decimal.includes('.')) {
+        //         return ''
+        //     }
+        //
+        //     decimal = decimal.split('.')[1]
+        //     return decimal.substring(0, decimalLength)
+        // }
+        //
+        // const epsilon = Number(`0.${"0".repeat(epsilonNumberOfDigits-1)}${epsilonDigit}`)
+        // const decimal = extractDecimalPart(value, epsilonNumberOfDigits)
+        // if(decimal===''){return value}
+        //
+        // const n9 = decimal.match(/9+$/g)
+        // const n0 = decimal.match(/0+$/g)
+        //
+        // if (n9 && n9[0].length >= number_of_digits) {
+        //     // New tested values.
+        //     const mod = extractDecimalPart(value + epsilon, epsilonNumberOfDigits),
+        //         mod0 = mod.match(/0+$/g)
+        //
+        //     if(mod0 && mod0[0].length>= number_of_digits){
+        //         return +((value+epsilon).toString().split(mod0[0])[0])
+        //     }
+        // }
+        //
+        // if (n0 && n0[0].length >= number_of_digits) {
+        //     // New tested values.
+        //     const mod = extractDecimalPart(value - epsilon, epsilonNumberOfDigits),
+        //         mod9 = mod.match(/9+$/g)
+        //
+        //     if(mod9 && mod9[0].length>= number_of_digits){
+        //         // The value can be changed. Remove all nines!
+        //         return +(value.toString().split(n0[0])[0])
+        //     }
+        // }
+        //
+        // return value
     }
     static periodic(value) {
         if (Number.isSafeInteger(value)) {