umt 1.0.15 → 1.1.1

package/module/Math/index.d.ts

@@ -1,43 +1,81 @@
-import { addition } from './addition';
-import { average } from './average';
-import { calculator } from './calculator';
-import { calculatorInitialization } from './calculator/calculatorInitialization';
-import { degToRad } from './degToRad';
-import { deviationValue } from './deviationValue';
-import { division } from './division';
-import { factorial } from './factorial';
-import { factorize } from './factorize';
-import { gcd } from './gcd';
-import { getDecimalLength } from './getDecimalLength';
-import { isDouble } from './isDouble';
-import { isNumber } from './isNumber';
-import { isPrimeNumber } from './isPrimeNumber';
-import { lcm } from './lcm';
-import { mathConverter } from './mathConverter';
-import { mathSeparator } from './mathSeparator';
-import { max } from './max';
-import { min } from './min';
-import { multiples } from './multiples';
-import { multiplication } from './multiplication';
-import { nCr } from './nCr';
-import { nHr } from './nHr';
-import { nPr } from './nPr';
-import { primeFactorization } from './primeFactorization';
-import { quotient } from './quotient';
-import { radToDeg } from './radToDeg';
-import { random } from './random';
-import { reduce } from './reduce';
-import { repeatedTrial } from './repeatedTrial';
-import { roundOf } from './roundOf';
-import { standardDeviation } from './standardDeviation';
-import { subtract } from './subtract';
-import { toBinary } from './toBinary';
-import { toCelsius } from './toCelsius';
-import { toKelvin } from './toKelvin';
-import { valueSwap } from './valueSwap';
-export { addition, average, calculator, calculatorInitialization, degToRad, deviationValue, division, factorial, factorize, gcd, getDecimalLength, isDouble, isNumber, isPrimeNumber, lcm, mathConverter, mathSeparator, max, min, multiples, multiplication, nCr, nHr, nPr, primeFactorization, quotient, radToDeg, random, reduce, repeatedTrial, roundOf, standardDeviation, subtract, toBinary, toCelsius, toKelvin, valueSwap, };
+import { addition } from "./addition";
+import { average } from "./average";
+import { calculator } from "./calculator";
+import { calculatorInitialization } from "./calculator/calculatorInitialization";
+import { degToRad } from "./degToRad";
+import { deviationValue } from "./deviationValue";
+import { division } from "./division";
+import { factorial } from "./factorial";
+import { factorize } from "./factorize";
+import { gcd } from "./gcd";
+import { getDecimalLength } from "./getDecimalLength";
+import { isDouble } from "./isDouble";
+import { isNumber } from "./isNumber";
+import { isPrimeNumber } from "./isPrimeNumber";
+import { lcm } from "./lcm";
+import { mathConverter } from "./mathConverter";
+import { mathSeparator } from "./mathSeparator";
+import { max } from "./max";
+import { min } from "./min";
+import { multiples } from "./multiples";
+import { multiplication } from "./multiplication";
+import { nCr } from "./nCr";
+import { nHr } from "./nHr";
+import { nPr } from "./nPr";
+import { primeFactorization } from "./primeFactorization";
+import { quotient } from "./quotient";
+import { radToDeg } from "./radToDeg";
+import { random } from "./random";
+import { reduce } from "./reduce";
+import { repeatedTrial } from "./repeatedTrial";
+import { roundOf } from "./roundOf";
+import { solveEquation } from "./solveEquation";
+import { standardDeviation } from "./standardDeviation";
+import { subtract } from "./subtract";
+import { toBinary } from "./toBinary";
+import { toCelsius } from "./toCelsius";
+import { toKelvin } from "./toKelvin";
+import { valueSwap } from "./valueSwap";
+export { addition, average, calculator, calculatorInitialization, degToRad, deviationValue, division, factorial, factorize, gcd, getDecimalLength, isDouble, isNumber, isPrimeNumber, lcm, mathConverter, mathSeparator, max, min, multiples, multiplication, nCr, nHr, nPr, primeFactorization, quotient, radToDeg, random, reduce, repeatedTrial, roundOf, solveEquation, standardDeviation, subtract, toBinary, toCelsius, toKelvin, valueSwap, };
 export declare class UMTMathClass {
-    #private;
+    private localAddition;
+    private localAverage;
+    private localCalculator;
+    private localCalculatorInitialization;
+    private localDegToRad;
+    private localDeviationValue;
+    private localDivision;
+    private localFactorial;
+    private localFactorize;
+    private localGcd;
+    private localGetDecimalLength;
+    private localIsDouble;
+    private localIsNumber;
+    private localIsPrimeNumber;
+    private localLcm;
+    private localMathConverter;
+    private localMathSeparator;
+    private localMax;
+    private localMin;
+    private localMultiples;
+    private localMultiplication;
+    private localNCr;
+    private localNHr;
+    private localNPr;
+    private localPrimeFactorization;
+    private localQuotient;
+    private localRadToDeg;
+    private localRandom;
+    private localReduce;
+    private localRepeatedTrial;
+    private localRoundOf;
+    private localSolveEquation;
+    private localStandardDeviation;
+    private localSubtract;
+    private localToBinary;
+    private localToCelsius;
+    private localToKelvin;
+    private localValueSwap;
     constructor();
     get addition(): (x: number, y: number) => number;
     get average(): (numbers: number[]) => number;
@@ -69,7 +107,7 @@ export declare class UMTMathClass {
     }[];
     get quotient(): (x: number, y: number) => number[];
     get radToDeg(): (x: number) => number;
-    get random(): (num: number, min?: number) => number;
+    get random(): (max: number, min?: number) => number;
     get reduce(): (x: number, y: number) => {
         x: number;
         y: number;
@@ -84,6 +122,7 @@ export declare class UMTMathClass {
         y: number;
     }) => number[];
     get roundOf(): (num: number, precision: number) => number;
+    get solveEquation(): (coefficients: number[][], constants: number[]) => number[];
     get standardDeviation(): (values: number[]) => number;
     get subtract(): (x: number, y: number) => number;
     get toBinary(): import("./toBinary").TOBINARY;

package/module/Math/index.js

@@ -1,18 +1,6 @@
 "use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _UMTMathClass_Local_addition, _UMTMathClass_Local_average, _UMTMathClass_Local_calculator, _UMTMathClass_Local_calculatorInitialization, _UMTMathClass_Local_degToRad, _UMTMathClass_Local_deviationValue, _UMTMathClass_Local_division, _UMTMathClass_Local_factorial, _UMTMathClass_Local_factorize, _UMTMathClass_Local_gcd, _UMTMathClass_Local_getDecimalLength, _UMTMathClass_Local_isDouble, _UMTMathClass_Local_isNumber, _UMTMathClass_Local_isPrimeNumber, _UMTMathClass_Local_lcm, _UMTMathClass_Local_mathConverter, _UMTMathClass_Local_mathSeparator, _UMTMathClass_Local_max, _UMTMathClass_Local_min, _UMTMathClass_Local_multiples, _UMTMathClass_Local_multiplication, _UMTMathClass_Local_nCr, _UMTMathClass_Local_nHr, _UMTMathClass_Local_nPr, _UMTMathClass_Local_primeFactorization, _UMTMathClass_Local_quotient, _UMTMathClass_Local_radToDeg, _UMTMathClass_Local_random, _UMTMathClass_Local_reduce, _UMTMathClass_Local_repeatedTrial, _UMTMathClass_Local_roundOf, _UMTMathClass_Local_standardDeviation, _UMTMathClass_Local_subtract, _UMTMathClass_Local_toBinary, _UMTMathClass_Local_toCelsius, _UMTMathClass_Local_toKelvin, _UMTMathClass_Local_valueSwap;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UMT_Math = exports.UMTMathClass = exports.valueSwap = exports.toKelvin = exports.toCelsius = exports.toBinary = exports.subtract = exports.standardDeviation = exports.roundOf = exports.repeatedTrial = exports.reduce = exports.random = exports.radToDeg = exports.quotient = exports.primeFactorization = exports.nPr = exports.nHr = exports.nCr = exports.multiplication = exports.multiples = exports.min = exports.max = exports.mathSeparator = exports.mathConverter = exports.lcm = exports.isPrimeNumber = exports.isNumber = exports.isDouble = exports.getDecimalLength = exports.gcd = exports.factorize = exports.factorial = exports.division = exports.deviationValue = exports.degToRad = exports.calculatorInitialization = exports.calculator = exports.average = exports.addition = void 0;
+exports.UMT_Math = exports.UMTMathClass = exports.valueSwap = exports.toKelvin = exports.toCelsius = exports.toBinary = exports.subtract = exports.standardDeviation = exports.solveEquation = exports.roundOf = exports.repeatedTrial = exports.reduce = exports.random = exports.radToDeg = exports.quotient = exports.primeFactorization = exports.nPr = exports.nHr = exports.nCr = exports.multiplication = exports.multiples = exports.min = exports.max = exports.mathSeparator = exports.mathConverter = exports.lcm = exports.isPrimeNumber = exports.isNumber = exports.isDouble = exports.getDecimalLength = exports.gcd = exports.factorize = exports.factorial = exports.division = exports.deviationValue = exports.degToRad = exports.calculatorInitialization = exports.calculator = exports.average = exports.addition = void 0;
 const addition_1 = require("./addition");
 Object.defineProperty(exports, "addition", { enumerable: true, get: function () { return addition_1.addition; } });
 const average_1 = require("./average");
@@ -75,6 +63,8 @@ const repeatedTrial_1 = require("./repeatedTrial");
 Object.defineProperty(exports, "repeatedTrial", { enumerable: true, get: function () { return repeatedTrial_1.repeatedTrial; } });
 const roundOf_1 = require("./roundOf");
 Object.defineProperty(exports, "roundOf", { enumerable: true, get: function () { return roundOf_1.roundOf; } });
+const solveEquation_1 = require("./solveEquation");
+Object.defineProperty(exports, "solveEquation", { enumerable: true, get: function () { return solveEquation_1.solveEquation; } });
 const standardDeviation_1 = require("./standardDeviation");
 Object.defineProperty(exports, "standardDeviation", { enumerable: true, get: function () { return standardDeviation_1.standardDeviation; } });
 const subtract_1 = require("./subtract");
@@ -89,193 +79,159 @@ const valueSwap_1 = require("./valueSwap");
 Object.defineProperty(exports, "valueSwap", { enumerable: true, get: function () { return valueSwap_1.valueSwap; } });
 class UMTMathClass {
     constructor() {
-        _UMTMathClass_Local_addition.set(this, void 0);
-        _UMTMathClass_Local_average.set(this, void 0);
-        _UMTMathClass_Local_calculator.set(this, void 0);
-        _UMTMathClass_Local_calculatorInitialization.set(this, void 0);
-        _UMTMathClass_Local_degToRad.set(this, void 0);
-        _UMTMathClass_Local_deviationValue.set(this, void 0);
-        _UMTMathClass_Local_division.set(this, void 0);
-        _UMTMathClass_Local_factorial.set(this, void 0);
-        _UMTMathClass_Local_factorize.set(this, void 0);
-        _UMTMathClass_Local_gcd.set(this, void 0);
-        _UMTMathClass_Local_getDecimalLength.set(this, void 0);
-        _UMTMathClass_Local_isDouble.set(this, void 0);
-        _UMTMathClass_Local_isNumber.set(this, void 0);
-        _UMTMathClass_Local_isPrimeNumber.set(this, void 0);
-        _UMTMathClass_Local_lcm.set(this, void 0);
-        _UMTMathClass_Local_mathConverter.set(this, void 0);
-        _UMTMathClass_Local_mathSeparator.set(this, void 0);
-        _UMTMathClass_Local_max.set(this, void 0);
-        _UMTMathClass_Local_min.set(this, void 0);
-        _UMTMathClass_Local_multiples.set(this, void 0);
-        _UMTMathClass_Local_multiplication.set(this, void 0);
-        _UMTMathClass_Local_nCr.set(this, void 0);
-        _UMTMathClass_Local_nHr.set(this, void 0);
-        _UMTMathClass_Local_nPr.set(this, void 0);
-        _UMTMathClass_Local_primeFactorization.set(this, void 0);
-        _UMTMathClass_Local_quotient.set(this, void 0);
-        _UMTMathClass_Local_radToDeg.set(this, void 0);
-        _UMTMathClass_Local_random.set(this, void 0);
-        _UMTMathClass_Local_reduce.set(this, void 0);
-        _UMTMathClass_Local_repeatedTrial.set(this, void 0);
-        _UMTMathClass_Local_roundOf.set(this, void 0);
-        _UMTMathClass_Local_standardDeviation.set(this, void 0);
-        _UMTMathClass_Local_subtract.set(this, void 0);
-        _UMTMathClass_Local_toBinary.set(this, void 0);
-        _UMTMathClass_Local_toCelsius.set(this, void 0);
-        _UMTMathClass_Local_toKelvin.set(this, void 0);
-        _UMTMathClass_Local_valueSwap.set(this, void 0);
-        __classPrivateFieldSet(this, _UMTMathClass_Local_addition, addition_1.addition, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_average, average_1.average, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_calculator, calculator_1.calculator, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_calculatorInitialization, calculatorInitialization_1.calculatorInitialization, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_degToRad, degToRad_1.degToRad, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_deviationValue, deviationValue_1.deviationValue, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_division, division_1.division, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_factorial, factorial_1.factorial, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_factorize, factorize_1.factorize, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_gcd, gcd_1.gcd, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_getDecimalLength, getDecimalLength_1.getDecimalLength, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_isDouble, isDouble_1.isDouble, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_isNumber, isNumber_1.isNumber, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_isPrimeNumber, isPrimeNumber_1.isPrimeNumber, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_lcm, lcm_1.lcm, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_mathConverter, mathConverter_1.mathConverter, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_mathSeparator, mathSeparator_1.mathSeparator, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_max, max_1.max, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_min, min_1.min, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_multiples, multiples_1.multiples, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_multiplication, multiplication_1.multiplication, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_nCr, nCr_1.nCr, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_nHr, nHr_1.nHr, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_nPr, nPr_1.nPr, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_primeFactorization, primeFactorization_1.primeFactorization, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_quotient, quotient_1.quotient, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_radToDeg, radToDeg_1.radToDeg, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_random, random_1.random, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_reduce, reduce_1.reduce, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_repeatedTrial, repeatedTrial_1.repeatedTrial, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_roundOf, roundOf_1.roundOf, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_standardDeviation, standardDeviation_1.standardDeviation, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_subtract, subtract_1.subtract, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_toBinary, toBinary_1.toBinary, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_toCelsius, toCelsius_1.toCelsius, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_toKelvin, toKelvin_1.toKelvin, "f");
-        __classPrivateFieldSet(this, _UMTMathClass_Local_valueSwap, valueSwap_1.valueSwap, "f");
+        this.localAddition = addition_1.addition;
+        this.localAverage = average_1.average;
+        this.localCalculator = calculator_1.calculator;
+        this.localCalculatorInitialization = calculatorInitialization_1.calculatorInitialization;
+        this.localDegToRad = degToRad_1.degToRad;
+        this.localDeviationValue = deviationValue_1.deviationValue;
+        this.localDivision = division_1.division;
+        this.localFactorial = factorial_1.factorial;
+        this.localFactorize = factorize_1.factorize;
+        this.localGcd = gcd_1.gcd;
+        this.localGetDecimalLength = getDecimalLength_1.getDecimalLength;
+        this.localIsDouble = isDouble_1.isDouble;
+        this.localIsNumber = isNumber_1.isNumber;
+        this.localIsPrimeNumber = isPrimeNumber_1.isPrimeNumber;
+        this.localLcm = lcm_1.lcm;
+        this.localMathConverter = mathConverter_1.mathConverter;
+        this.localMathSeparator = mathSeparator_1.mathSeparator;
+        this.localMax = max_1.max;
+        this.localMin = min_1.min;
+        this.localMultiples = multiples_1.multiples;
+        this.localMultiplication = multiplication_1.multiplication;
+        this.localNCr = nCr_1.nCr;
+        this.localNHr = nHr_1.nHr;
+        this.localNPr = nPr_1.nPr;
+        this.localPrimeFactorization = primeFactorization_1.primeFactorization;
+        this.localQuotient = quotient_1.quotient;
+        this.localRadToDeg = radToDeg_1.radToDeg;
+        this.localRandom = random_1.random;
+        this.localReduce = reduce_1.reduce;
+        this.localRepeatedTrial = repeatedTrial_1.repeatedTrial;
+        this.localRoundOf = roundOf_1.roundOf;
+        this.localSolveEquation = solveEquation_1.solveEquation;
+        this.localStandardDeviation = standardDeviation_1.standardDeviation;
+        this.localSubtract = subtract_1.subtract;
+        this.localToBinary = toBinary_1.toBinary;
+        this.localToCelsius = toCelsius_1.toCelsius;
+        this.localToKelvin = toKelvin_1.toKelvin;
+        this.localValueSwap = valueSwap_1.valueSwap;
     }
     get addition() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_addition, "f");
+        return this.localAddition;
     }
     get average() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_average, "f");
+        return this.localAverage;
     }
     get calculator() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_calculator, "f");
+        return this.localCalculator;
     }
     get calculatorInitialization() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_calculatorInitialization, "f");
+        return this.localCalculatorInitialization;
     }
     get degToRad() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_degToRad, "f");
+        return this.localDegToRad;
     }
     get deviationValue() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_deviationValue, "f");
+        return this.localDeviationValue;
     }
     get division() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_division, "f");
+        return this.localDivision;
     }
     get factorial() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_factorial, "f");
+        return this.localFactorial;
     }
     get factorize() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_factorize, "f");
+        return this.localFactorize;
     }
     get gcd() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_gcd, "f");
+        return this.localGcd;
     }
     get getDecimalLength() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_getDecimalLength, "f");
+        return this.localGetDecimalLength;
     }
     get isDouble() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_isDouble, "f");
+        return this.localIsDouble;
     }
     get isNumber() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_isNumber, "f");
+        return this.localIsNumber;
     }
     get isPrimeNumber() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_isPrimeNumber, "f");
+        return this.localIsPrimeNumber;
     }
     get lcm() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_lcm, "f");
+        return this.localLcm;
     }
     get mathConverter() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_mathConverter, "f");
+        return this.localMathConverter;
     }
     get mathSeparator() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_mathSeparator, "f");
+        return this.localMathSeparator;
     }
     get max() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_max, "f");
+        return this.localMax;
     }
     get min() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_min, "f");
+        return this.localMin;
     }
     get multiples() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_multiples, "f");
+        return this.localMultiples;
     }
     get multiplication() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_multiplication, "f");
+        return this.localMultiplication;
     }
     get nCr() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_nCr, "f");
+        return this.localNCr;
     }
     get nHr() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_nHr, "f");
+        return this.localNHr;
     }
     get nPr() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_nPr, "f");
+        return this.localNPr;
     }
     get primeFactorization() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_primeFactorization, "f");
+        return this.localPrimeFactorization;
     }
     get quotient() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_quotient, "f");
+        return this.localQuotient;
     }
     get radToDeg() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_radToDeg, "f");
+        return this.localRadToDeg;
     }
     get random() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_random, "f");
+        return this.localRandom;
     }
     get reduce() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_reduce, "f");
+        return this.localReduce;
     }
     get repeatedTrial() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_repeatedTrial, "f");
+        return this.localRepeatedTrial;
     }
     get roundOf() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_roundOf, "f");
+        return this.localRoundOf;
+    }
+    get solveEquation() {
+        return this.localSolveEquation;
     }
     get standardDeviation() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_standardDeviation, "f");
+        return this.localStandardDeviation;
     }
     get subtract() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_subtract, "f");
+        return this.localSubtract;
     }
     get toBinary() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_toBinary, "f");
+        return this.localToBinary;
     }
     get toCelsius() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_toCelsius, "f");
+        return this.localToCelsius;
     }
     get toKelvin() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_toKelvin, "f");
+        return this.localToKelvin;
     }
     get valueSwap() {
-        return __classPrivateFieldGet(this, _UMTMathClass_Local_valueSwap, "f");
+        return this.localValueSwap;
     }
 }
 exports.UMTMathClass = UMTMathClass;
-_UMTMathClass_Local_addition = new WeakMap(), _UMTMathClass_Local_average = new WeakMap(), _UMTMathClass_Local_calculator = new WeakMap(), _UMTMathClass_Local_calculatorInitialization = new WeakMap(), _UMTMathClass_Local_degToRad = new WeakMap(), _UMTMathClass_Local_deviationValue = new WeakMap(), _UMTMathClass_Local_division = new WeakMap(), _UMTMathClass_Local_factorial = new WeakMap(), _UMTMathClass_Local_factorize = new WeakMap(), _UMTMathClass_Local_gcd = new WeakMap(), _UMTMathClass_Local_getDecimalLength = new WeakMap(), _UMTMathClass_Local_isDouble = new WeakMap(), _UMTMathClass_Local_isNumber = new WeakMap(), _UMTMathClass_Local_isPrimeNumber = new WeakMap(), _UMTMathClass_Local_lcm = new WeakMap(), _UMTMathClass_Local_mathConverter = new WeakMap(), _UMTMathClass_Local_mathSeparator = new WeakMap(), _UMTMathClass_Local_max = new WeakMap(), _UMTMathClass_Local_min = new WeakMap(), _UMTMathClass_Local_multiples = new WeakMap(), _UMTMathClass_Local_multiplication = new WeakMap(), _UMTMathClass_Local_nCr = new WeakMap(), _UMTMathClass_Local_nHr = new WeakMap(), _UMTMathClass_Local_nPr = new WeakMap(), _UMTMathClass_Local_primeFactorization = new WeakMap(), _UMTMathClass_Local_quotient = new WeakMap(), _UMTMathClass_Local_radToDeg = new WeakMap(), _UMTMathClass_Local_random = new WeakMap(), _UMTMathClass_Local_reduce = new WeakMap(), _UMTMathClass_Local_repeatedTrial = new WeakMap(), _UMTMathClass_Local_roundOf = new WeakMap(), _UMTMathClass_Local_standardDeviation = new WeakMap(), _UMTMathClass_Local_subtract = new WeakMap(), _UMTMathClass_Local_toBinary = new WeakMap(), _UMTMathClass_Local_toCelsius = new WeakMap(), _UMTMathClass_Local_toKelvin = new WeakMap(), _UMTMathClass_Local_valueSwap = new WeakMap();
 exports.UMT_Math = new UMTMathClass();

package/module/Math/isDouble.js

@@ -1,11 +1,12 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDouble = void 0;
 /**
  * @param {any} x
  * @param {boolean} [loose=true] - 文字列も対象にするかどうか
  * @returns boolean
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDouble = void 0;
+// rome-ignore lint/suspicious/noExplicitAny: <explanation>
 const isDouble = (x, loose = true) => {
     if (loose) {
         return (isFinite(x) &&

package/module/Math/isNumber.js

@@ -1,12 +1,13 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNumber = void 0;
 /**
  * 数字かどうか
  * @param  {any} x
  * @param  {boolean} loose 文字列も対象にするかどうか
  * @returns boolean
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNumber = void 0;
+// rome-ignore lint/suspicious/noExplicitAny: <explanation>
 const isNumber = (x, loose = true) => {
     return x !== null && typeof x !== 'boolean' && loose
         ? isFinite(x)

package/module/Math/isPrimeNumber.js

@@ -2,21 +2,43 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isPrimeNumber = void 0;
 const division_1 = require("./division");
+const multiplication_1 = require("./multiplication");
 /**
  * 素数判定
  * @param  {number} n
  * @returns boolean
  */
 const isPrimeNumber = (n) => {
-    if (n < 2)
+    // Check for trivial cases
+    if (n <= 1) {
         return false;
-    else if (n == 2)
+    }
+    else if (n <= 3) {
         return true;
-    else if (n % 2 == 0)
+    }
+    else if (n % 2 === 0 || n % 3 === 0) {
         return false;
-    for (let i = 3; i <= Math.sqrt(n); i++) {
-        if ((0, division_1.division)(n, i, false)[1] == 0) {
-            return false;
+    }
+    // Perform Miller-Rabin primality test
+    const s = Math.floor(Math.log2(n - 1));
+    const d = (n - 1) / Math.pow(2, s);
+    for (let i = 0; i < 10; i++) {
+        const a = Math.floor(Math.random() * (n - 2)) + 2;
+        // let x = BigInt(a) ** BigInt(d) % BigInt(n);
+        let x = (0, division_1.division)((0, multiplication_1.multiplication)(a, d), n, false)[1];
+        if (x !== 1 && x !== n - 1) {
+            for (let j = 0; j < s - 1; j++) {
+                x = (0, division_1.division)((0, multiplication_1.multiplication)(x, x), n, false)[1];
+                if (x === 1) {
+                    return false;
+                }
+                if (x === n - 1) {
+                    break;
+                }
+            }
+            if (x !== n - 1) {
+                return false;
+            }
         }
     }
     return true;

package/module/Math/lcm.js

@@ -10,13 +10,15 @@ const valueSwap_1 = require("./valueSwap");
  * @returns number
  */
 const lcm = (x, y) => {
+    let copyX = x;
+    let copyY = y;
     // If either input is 0, the least common multiple is 0
-    if (x === 0 || y === 0) {
+    if (copyX === 0 || copyY === 0) {
         return 0;
     }
     // Swap the values of x and y if x is greater than y
-    [x, y] = (0, valueSwap_1.valueSwap)(x, y);
+    [copyX, copyY] = (0, valueSwap_1.valueSwap)(copyX, copyY);
     // The least common multiple is x times y divided by their greatest common divisor
-    return (x / (0, gcd_1.gcd)(x, y)) * y;
+    return (copyX / (0, gcd_1.gcd)(copyX, copyY)) * copyY;
 };
 exports.lcm = lcm;

package/module/Math/mathConverter.js

@@ -7,41 +7,40 @@ const mathSeparator_1 = require("./mathSeparator");
  * @returns string
  */
 const mathConverter = (x) => {
+    let returnValue = x;
     while (true) {
-        if (x.indexOf('^') != -1 || x.indexOf('*') != -1) {
+        if (returnValue.indexOf("^") !== -1 || returnValue.indexOf("*") !== -1) {
             //掛け算と割り算の処理
             const y = [
-                x.match(/\d+\.?(\d+)?(\*|\^)\d+\.?(\d+)?/),
-                [''],
+                returnValue.match(/\d+\.?(\d+)?(\*|\^)\d+\.?(\d+)?/),
+                [""],
             ];
             if (y[0]) {
-                y[1] = y[0][0]
-                    .split(/(\d+\.\d+)|(\d+)/g)
-                    .filter((n) => {
-                    return typeof n != 'undefined' && n != '';
+                y[1] = y[0][0].split(/(\d+\.\d+)|(\d+)/g).filter((n) => {
+                    return typeof n !== "undefined" && n !== "";
                 });
-                if (y[1][0] == y[1][2] ||
-                    (y[1][2] && y[1][1] == '^')) {
-                    let [n, m] = (0, mathSeparator_1.mathSeparator)(y[1][0]);
+                if (y[1][0] === y[1][2] || (y[1][2] && y[1][1] === "^")) {
+                    const [n, m] = (0, mathSeparator_1.mathSeparator)(y[1][0]);
                     if (n) {
-                        x = `${Number(y[1][0]) + m}*${n}+`;
+                        returnValue = `${Number(y[1][0]) + m}*${n}+`;
                         if (m <= 100) {
-                            x += `${m}*${m}`;
+                            returnValue += `${m}*${m}`;
                         }
                         else {
-                            return (x += (0, exports.mathConverter)(`${m}*${m}`));
+                            returnValue += (0, exports.mathConverter)(`${m}*${m}`);
+                            return returnValue;
                         }
-                        return x;
+                        return returnValue;
                     }
                 }
-                return x;
+                return returnValue;
             }
             else {
-                return x;
+                return returnValue;
             }
         }
         else {
-            return x;
+            return returnValue;
         }
     }
 };

package/module/Math/multiples.js

@@ -7,7 +7,7 @@ exports.multiples = void 0;
  * @param  {number} n
  */
 const multiples = (x, n) => {
-    let result = [];
+    const result = [];
     for (let i = 1; i <= n; i++) {
         result.push(x * i);
     }

package/module/Math/multiplication.js

@@ -9,8 +9,10 @@ const getDecimalLength_1 = require("./getDecimalLength");
  */
 const multiplication = (x, y) => {
     const n = Math.pow(10, ((0, getDecimalLength_1.getDecimalLength)(x) + (0, getDecimalLength_1.getDecimalLength)(y)));
-    x = +(x + '').replace('.', '');
-    y = +(y + '').replace('.', '');
-    return (x * y) / n;
+    let copyX = x;
+    let copyY = y;
+    copyX = +`${copyX}`.replace(".", "");
+    copyY = +`${copyY}`.replace(".", "");
+    return (copyX * copyY) / n;
 };
 exports.multiplication = multiplication;