umt 1.0.10 → 1.0.11

package/module/Math/gcd.js

@@ -1,19 +1,18 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const valueSwap_1 = __importDefault(require("./valueSwap"));
+exports.gcd = void 0;
+const valueSwap_1 = require("./valueSwap");
 /**
  * 自然数の最大公約数
  * @param  {number} x
  * @param  {number} y
  * @param  {number} ...z
+ * @returns number
  */
 const gcd = (x, y, ...z) => {
     if (x === 0 || y === 0)
         return 0;
-    [x, y] = (0, valueSwap_1.default)(x, y);
+    [x, y] = (0, valueSwap_1.valueSwap)(x, y);
     /* ユークリッドの互除法 */
     let r = y % x;
     while (r !== 0) {
@@ -23,9 +22,9 @@ const gcd = (x, y, ...z) => {
     }
     if (z.length > 0) {
         for (let i = 0; i < z.length; i++) {
-            x = gcd(x, z[i]);
+            x = (0, exports.gcd)(x, z[i]);
         }
     }
     return x;
 };
-exports.default = gcd;
+exports.gcd = gcd;

package/module/Math/getDecimalLength.d.ts

@@ -1,6 +1,6 @@
 /**
  * 小数点以下の桁数
  * @param  {number} value
+ * @returns number
  */
-declare const getDecimalLength: (value: number) => number;
-export default getDecimalLength;
+export declare const getDecimalLength: (value: number) => number;

package/module/Math/getDecimalLength.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDecimalLength = void 0;
 /**
  * 小数点以下の桁数
  * @param  {number} value
+ * @returns number
  */
 const getDecimalLength = (value) => {
     let x = (value + '').split('.')[1];
@@ -11,4 +13,4 @@ const getDecimalLength = (value) => {
     }
     return 0;
 };
-exports.default = getDecimalLength;
+exports.getDecimalLength = getDecimalLength;

package/module/Math/index.d.ts

@@ -1,33 +1,94 @@
-import addition from './addition';
-import average from './average';
-import calculator from './calculator';
-import degToRad from './degToRad';
-import division from './division';
-import gcd from './gcd';
-import factorial from './factorial';
-import factorize from './factorize';
-import getDecimalLength from './getDecimalLength';
-import isDouble from './isDouble';
-import isNumber from './isNumber';
-import isPrimeNumber from './isPrimeNumber';
-import lcm from './lcm';
-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 standardDeviation from './standardDeviation';
-import subtract from './subtract';
-import toBinary from './toBinary';
-import toCelsius from './toCelsius';
-import toKelvin from './toKelvin';
-import valueSwap from './valueSwap';
-export { factorial, lcm, nCr, nHr, nPr, quotient, reduce, repeatedTrial, max, min, isDouble, isNumber, valueSwap, getDecimalLength, subtract, multiplication, addition, division, isPrimeNumber, toBinary, degToRad, radToDeg, primeFactorization, calculator, random, gcd, average, standardDeviation, factorize, multiples, toKelvin, toCelsius, };
+import { addition } from './addition';
+import { average } from './average';
+import { calculator } from './calculator';
+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 './roundOff';
+import { softmax } from './softmax';
+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, 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, softmax, standardDeviation, subtract, toBinary, toCelsius, toKelvin, valueSwap, };
+export declare class UMTMathClass {
+    #private;
+    constructor();
+    get addition(): (x: number, y: number) => number;
+    get average(): (numbers: number[]) => number;
+    get calculator(): <T extends object>(x: string, ex?: T | undefined) => string;
+    get degToRad(): (x: number) => number;
+    get deviationValue(): (value: number, averageValue: number, standardDeviationValue: number) => number;
+    get division(): import("./division").DIVISION;
+    get factorial(): (x: number) => number;
+    get factorize(): (n: number) => number[];
+    get gcd(): (x: number, y: number, ...z: number[]) => number;
+    get getDecimalLength(): (value: number) => number;
+    get isDouble(): (x: any, loose?: boolean) => boolean;
+    get isNumber(): (x: any, loose?: boolean) => boolean;
+    get isPrimeNumber(): (n: number) => boolean;
+    get lcm(): (x: number, y: number) => number;
+    get mathConverter(): (x: string) => string;
+    get mathSeparator(): (number: string | number) => number[];
+    get max(): (...num: number[]) => number;
+    get min(): (...num: number[]) => number;
+    get multiples(): (x: number, n: number) => number[];
+    get multiplication(): (x: number, y: number) => number;
+    get nCr(): (n: number, r: number) => number;
+    get nHr(): (n: number, r: number) => number;
+    get nPr(): (n: number, r: number) => number;
+    get primeFactorization(): (x: number) => {
+        number: number;
+        count: number;
+    }[];
+    get quotient(): (x: number, y: number) => number[];
+    get radToDeg(): (x: number) => number;
+    get random(): (num: number, min?: number) => number;
+    get reduce(): (x: number, y: number) => {
+        x: number;
+        y: number;
+        gcd?: undefined;
+    } | {
+        x: number;
+        y: number;
+        gcd: number;
+    };
+    get repeatedTrial(): (n: number, r: number, p: {
+        x: number;
+        y: number;
+    }) => number[];
+    get roundOf(): (num: number, precision: number) => number;
+    get softmax(): (x: number[]) => number[];
+    get standardDeviation(): (values: number[]) => number;
+    get subtract(): (x: number, y: number) => number;
+    get toBinary(): import("./toBinary").TOBINARY;
+    get toCelsius(): (kelvin: number) => number;
+    get toKelvin(): (celsius: number) => number;
+    get valueSwap(): (x: number, y: number) => number[];
+}
+export declare const UMT_Math: UMTMathClass;

package/module/Math/index.js

@@ -1,70 +1,281 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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_Localaddition, _UMTMathClass_Localaverage, _UMTMathClass_Localcalculator, _UMTMathClass_LocaldegToRad, _UMTMathClass_LocaldeviationValue, _UMTMathClass_Localdivision, _UMTMathClass_Localfactorial, _UMTMathClass_Localfactorize, _UMTMathClass_Localgcd, _UMTMathClass_LocalgetDecimalLength, _UMTMathClass_LocalisDouble, _UMTMathClass_LocalisNumber, _UMTMathClass_LocalisPrimeNumber, _UMTMathClass_Locallcm, _UMTMathClass_LocalmathConverter, _UMTMathClass_LocalmathSeparator, _UMTMathClass_Localmax, _UMTMathClass_Localmin, _UMTMathClass_Localmultiples, _UMTMathClass_Localmultiplication, _UMTMathClass_LocalnCr, _UMTMathClass_LocalnHr, _UMTMathClass_LocalnPr, _UMTMathClass_LocalprimeFactorization, _UMTMathClass_Localquotient, _UMTMathClass_LocalradToDeg, _UMTMathClass_Localrandom, _UMTMathClass_Localreduce, _UMTMathClass_LocalrepeatedTrial, _UMTMathClass_LocalroundOf, _UMTMathClass_Localsoftmax, _UMTMathClass_LocalstandardDeviation, _UMTMathClass_Localsubtract, _UMTMathClass_LocaltoBinary, _UMTMathClass_LocaltoCelsius, _UMTMathClass_LocaltoKelvin, _UMTMathClass_LocalvalueSwap;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toCelsius = exports.toKelvin = exports.multiples = exports.factorize = exports.standardDeviation = exports.average = exports.gcd = exports.random = exports.calculator = exports.primeFactorization = exports.radToDeg = exports.degToRad = exports.toBinary = exports.isPrimeNumber = exports.division = exports.addition = exports.multiplication = exports.subtract = exports.getDecimalLength = exports.valueSwap = exports.isNumber = exports.isDouble = exports.min = exports.max = exports.repeatedTrial = exports.reduce = exports.quotient = exports.nPr = exports.nHr = exports.nCr = exports.lcm = exports.factorial = void 0;
-const addition_1 = __importDefault(require("./addition"));
-exports.addition = addition_1.default;
-const average_1 = __importDefault(require("./average"));
-exports.average = average_1.default;
-const calculator_1 = __importDefault(require("./calculator"));
-exports.calculator = calculator_1.default;
-const degToRad_1 = __importDefault(require("./degToRad"));
-exports.degToRad = degToRad_1.default;
-const division_1 = __importDefault(require("./division"));
-exports.division = division_1.default;
-const gcd_1 = __importDefault(require("./gcd"));
-exports.gcd = gcd_1.default;
-const factorial_1 = __importDefault(require("./factorial"));
-exports.factorial = factorial_1.default;
-const factorize_1 = __importDefault(require("./factorize"));
-exports.factorize = factorize_1.default;
-const getDecimalLength_1 = __importDefault(require("./getDecimalLength"));
-exports.getDecimalLength = getDecimalLength_1.default;
-const isDouble_1 = __importDefault(require("./isDouble"));
-exports.isDouble = isDouble_1.default;
-const isNumber_1 = __importDefault(require("./isNumber"));
-exports.isNumber = isNumber_1.default;
-const isPrimeNumber_1 = __importDefault(require("./isPrimeNumber"));
-exports.isPrimeNumber = isPrimeNumber_1.default;
-const lcm_1 = __importDefault(require("./lcm"));
-exports.lcm = lcm_1.default;
-const max_1 = __importDefault(require("./max"));
-exports.max = max_1.default;
-const min_1 = __importDefault(require("./min"));
-exports.min = min_1.default;
-const multiples_1 = __importDefault(require("./multiples"));
-exports.multiples = multiples_1.default;
-const multiplication_1 = __importDefault(require("./multiplication"));
-exports.multiplication = multiplication_1.default;
-const nCr_1 = __importDefault(require("./nCr"));
-exports.nCr = nCr_1.default;
-const nHr_1 = __importDefault(require("./nHr"));
-exports.nHr = nHr_1.default;
-const nPr_1 = __importDefault(require("./nPr"));
-exports.nPr = nPr_1.default;
-const primeFactorization_1 = __importDefault(require("./primeFactorization"));
-exports.primeFactorization = primeFactorization_1.default;
-const quotient_1 = __importDefault(require("./quotient"));
-exports.quotient = quotient_1.default;
-const radToDeg_1 = __importDefault(require("./radToDeg"));
-exports.radToDeg = radToDeg_1.default;
-const random_1 = __importDefault(require("./random"));
-exports.random = random_1.default;
-const reduce_1 = __importDefault(require("./reduce"));
-exports.reduce = reduce_1.default;
-const repeatedTrial_1 = __importDefault(require("./repeatedTrial"));
-exports.repeatedTrial = repeatedTrial_1.default;
-const standardDeviation_1 = __importDefault(require("./standardDeviation"));
-exports.standardDeviation = standardDeviation_1.default;
-const subtract_1 = __importDefault(require("./subtract"));
-exports.subtract = subtract_1.default;
-const toBinary_1 = __importDefault(require("./toBinary"));
-exports.toBinary = toBinary_1.default;
-const toCelsius_1 = __importDefault(require("./toCelsius"));
-exports.toCelsius = toCelsius_1.default;
-const toKelvin_1 = __importDefault(require("./toKelvin"));
-exports.toKelvin = toKelvin_1.default;
-const valueSwap_1 = __importDefault(require("./valueSwap"));
-exports.valueSwap = valueSwap_1.default;
+exports.UMT_Math = exports.UMTMathClass = exports.valueSwap = exports.toKelvin = exports.toCelsius = exports.toBinary = exports.subtract = exports.standardDeviation = exports.softmax = 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.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");
+Object.defineProperty(exports, "average", { enumerable: true, get: function () { return average_1.average; } });
+const calculator_1 = require("./calculator");
+Object.defineProperty(exports, "calculator", { enumerable: true, get: function () { return calculator_1.calculator; } });
+const degToRad_1 = require("./degToRad");
+Object.defineProperty(exports, "degToRad", { enumerable: true, get: function () { return degToRad_1.degToRad; } });
+const deviationValue_1 = require("./deviationValue");
+Object.defineProperty(exports, "deviationValue", { enumerable: true, get: function () { return deviationValue_1.deviationValue; } });
+const division_1 = require("./division");
+Object.defineProperty(exports, "division", { enumerable: true, get: function () { return division_1.division; } });
+const factorial_1 = require("./factorial");
+Object.defineProperty(exports, "factorial", { enumerable: true, get: function () { return factorial_1.factorial; } });
+const factorize_1 = require("./factorize");
+Object.defineProperty(exports, "factorize", { enumerable: true, get: function () { return factorize_1.factorize; } });
+const gcd_1 = require("./gcd");
+Object.defineProperty(exports, "gcd", { enumerable: true, get: function () { return gcd_1.gcd; } });
+const getDecimalLength_1 = require("./getDecimalLength");
+Object.defineProperty(exports, "getDecimalLength", { enumerable: true, get: function () { return getDecimalLength_1.getDecimalLength; } });
+const isDouble_1 = require("./isDouble");
+Object.defineProperty(exports, "isDouble", { enumerable: true, get: function () { return isDouble_1.isDouble; } });
+const isNumber_1 = require("./isNumber");
+Object.defineProperty(exports, "isNumber", { enumerable: true, get: function () { return isNumber_1.isNumber; } });
+const isPrimeNumber_1 = require("./isPrimeNumber");
+Object.defineProperty(exports, "isPrimeNumber", { enumerable: true, get: function () { return isPrimeNumber_1.isPrimeNumber; } });
+const lcm_1 = require("./lcm");
+Object.defineProperty(exports, "lcm", { enumerable: true, get: function () { return lcm_1.lcm; } });
+const mathConverter_1 = require("./mathConverter");
+Object.defineProperty(exports, "mathConverter", { enumerable: true, get: function () { return mathConverter_1.mathConverter; } });
+const mathSeparator_1 = require("./mathSeparator");
+Object.defineProperty(exports, "mathSeparator", { enumerable: true, get: function () { return mathSeparator_1.mathSeparator; } });
+const max_1 = require("./max");
+Object.defineProperty(exports, "max", { enumerable: true, get: function () { return max_1.max; } });
+const min_1 = require("./min");
+Object.defineProperty(exports, "min", { enumerable: true, get: function () { return min_1.min; } });
+const multiples_1 = require("./multiples");
+Object.defineProperty(exports, "multiples", { enumerable: true, get: function () { return multiples_1.multiples; } });
+const multiplication_1 = require("./multiplication");
+Object.defineProperty(exports, "multiplication", { enumerable: true, get: function () { return multiplication_1.multiplication; } });
+const nCr_1 = require("./nCr");
+Object.defineProperty(exports, "nCr", { enumerable: true, get: function () { return nCr_1.nCr; } });
+const nHr_1 = require("./nHr");
+Object.defineProperty(exports, "nHr", { enumerable: true, get: function () { return nHr_1.nHr; } });
+const nPr_1 = require("./nPr");
+Object.defineProperty(exports, "nPr", { enumerable: true, get: function () { return nPr_1.nPr; } });
+const primeFactorization_1 = require("./primeFactorization");
+Object.defineProperty(exports, "primeFactorization", { enumerable: true, get: function () { return primeFactorization_1.primeFactorization; } });
+const quotient_1 = require("./quotient");
+Object.defineProperty(exports, "quotient", { enumerable: true, get: function () { return quotient_1.quotient; } });
+const radToDeg_1 = require("./radToDeg");
+Object.defineProperty(exports, "radToDeg", { enumerable: true, get: function () { return radToDeg_1.radToDeg; } });
+const random_1 = require("./random");
+Object.defineProperty(exports, "random", { enumerable: true, get: function () { return random_1.random; } });
+const reduce_1 = require("./reduce");
+Object.defineProperty(exports, "reduce", { enumerable: true, get: function () { return reduce_1.reduce; } });
+const repeatedTrial_1 = require("./repeatedTrial");
+Object.defineProperty(exports, "repeatedTrial", { enumerable: true, get: function () { return repeatedTrial_1.repeatedTrial; } });
+const roundOff_1 = require("./roundOff");
+Object.defineProperty(exports, "roundOf", { enumerable: true, get: function () { return roundOff_1.roundOf; } });
+const softmax_1 = require("./softmax");
+Object.defineProperty(exports, "softmax", { enumerable: true, get: function () { return softmax_1.softmax; } });
+const standardDeviation_1 = require("./standardDeviation");
+Object.defineProperty(exports, "standardDeviation", { enumerable: true, get: function () { return standardDeviation_1.standardDeviation; } });
+const subtract_1 = require("./subtract");
+Object.defineProperty(exports, "subtract", { enumerable: true, get: function () { return subtract_1.subtract; } });
+const toBinary_1 = require("./toBinary");
+Object.defineProperty(exports, "toBinary", { enumerable: true, get: function () { return toBinary_1.toBinary; } });
+const toCelsius_1 = require("./toCelsius");
+Object.defineProperty(exports, "toCelsius", { enumerable: true, get: function () { return toCelsius_1.toCelsius; } });
+const toKelvin_1 = require("./toKelvin");
+Object.defineProperty(exports, "toKelvin", { enumerable: true, get: function () { return toKelvin_1.toKelvin; } });
+const valueSwap_1 = require("./valueSwap");
+Object.defineProperty(exports, "valueSwap", { enumerable: true, get: function () { return valueSwap_1.valueSwap; } });
+class UMTMathClass {
+    constructor() {
+        _UMTMathClass_Localaddition.set(this, void 0);
+        _UMTMathClass_Localaverage.set(this, void 0);
+        _UMTMathClass_Localcalculator.set(this, void 0);
+        _UMTMathClass_LocaldegToRad.set(this, void 0);
+        _UMTMathClass_LocaldeviationValue.set(this, void 0);
+        _UMTMathClass_Localdivision.set(this, void 0);
+        _UMTMathClass_Localfactorial.set(this, void 0);
+        _UMTMathClass_Localfactorize.set(this, void 0);
+        _UMTMathClass_Localgcd.set(this, void 0);
+        _UMTMathClass_LocalgetDecimalLength.set(this, void 0);
+        _UMTMathClass_LocalisDouble.set(this, void 0);
+        _UMTMathClass_LocalisNumber.set(this, void 0);
+        _UMTMathClass_LocalisPrimeNumber.set(this, void 0);
+        _UMTMathClass_Locallcm.set(this, void 0);
+        _UMTMathClass_LocalmathConverter.set(this, void 0);
+        _UMTMathClass_LocalmathSeparator.set(this, void 0);
+        _UMTMathClass_Localmax.set(this, void 0);
+        _UMTMathClass_Localmin.set(this, void 0);
+        _UMTMathClass_Localmultiples.set(this, void 0);
+        _UMTMathClass_Localmultiplication.set(this, void 0);
+        _UMTMathClass_LocalnCr.set(this, void 0);
+        _UMTMathClass_LocalnHr.set(this, void 0);
+        _UMTMathClass_LocalnPr.set(this, void 0);
+        _UMTMathClass_LocalprimeFactorization.set(this, void 0);
+        _UMTMathClass_Localquotient.set(this, void 0);
+        _UMTMathClass_LocalradToDeg.set(this, void 0);
+        _UMTMathClass_Localrandom.set(this, void 0);
+        _UMTMathClass_Localreduce.set(this, void 0);
+        _UMTMathClass_LocalrepeatedTrial.set(this, void 0);
+        _UMTMathClass_LocalroundOf.set(this, void 0);
+        _UMTMathClass_Localsoftmax.set(this, void 0);
+        _UMTMathClass_LocalstandardDeviation.set(this, void 0);
+        _UMTMathClass_Localsubtract.set(this, void 0);
+        _UMTMathClass_LocaltoBinary.set(this, void 0);
+        _UMTMathClass_LocaltoCelsius.set(this, void 0);
+        _UMTMathClass_LocaltoKelvin.set(this, void 0);
+        _UMTMathClass_LocalvalueSwap.set(this, void 0);
+        __classPrivateFieldSet(this, _UMTMathClass_Localaddition, addition_1.addition, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_Localaverage, average_1.average, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_Localcalculator, calculator_1.calculator, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocaldegToRad, degToRad_1.degToRad, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocaldeviationValue, deviationValue_1.deviationValue, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_Localdivision, division_1.division, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_Localfactorial, factorial_1.factorial, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_Localfactorize, factorize_1.factorize, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_Localgcd, gcd_1.gcd, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocalgetDecimalLength, getDecimalLength_1.getDecimalLength, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocalisDouble, isDouble_1.isDouble, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocalisNumber, isNumber_1.isNumber, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocalisPrimeNumber, isPrimeNumber_1.isPrimeNumber, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_Locallcm, lcm_1.lcm, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocalmathConverter, mathConverter_1.mathConverter, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocalmathSeparator, mathSeparator_1.mathSeparator, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_Localmax, max_1.max, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_Localmin, min_1.min, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_Localmultiples, multiples_1.multiples, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_Localmultiplication, multiplication_1.multiplication, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocalnCr, nCr_1.nCr, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocalnHr, nHr_1.nHr, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocalnPr, nPr_1.nPr, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocalprimeFactorization, primeFactorization_1.primeFactorization, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_Localquotient, quotient_1.quotient, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocalradToDeg, radToDeg_1.radToDeg, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_Localrandom, random_1.random, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_Localreduce, reduce_1.reduce, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocalrepeatedTrial, repeatedTrial_1.repeatedTrial, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocalroundOf, roundOff_1.roundOf, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_Localsoftmax, softmax_1.softmax, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocalstandardDeviation, standardDeviation_1.standardDeviation, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_Localsubtract, subtract_1.subtract, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocaltoBinary, toBinary_1.toBinary, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocaltoCelsius, toCelsius_1.toCelsius, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocaltoKelvin, toKelvin_1.toKelvin, "f");
+        __classPrivateFieldSet(this, _UMTMathClass_LocalvalueSwap, valueSwap_1.valueSwap, "f");
+    }
+    get addition() {
+        return __classPrivateFieldGet(this, _UMTMathClass_Localaddition, "f");
+    }
+    get average() {
+        return __classPrivateFieldGet(this, _UMTMathClass_Localaverage, "f");
+    }
+    get calculator() {
+        return __classPrivateFieldGet(this, _UMTMathClass_Localcalculator, "f");
+    }
+    get degToRad() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocaldegToRad, "f");
+    }
+    get deviationValue() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocaldeviationValue, "f");
+    }
+    get division() {
+        return __classPrivateFieldGet(this, _UMTMathClass_Localdivision, "f");
+    }
+    get factorial() {
+        return __classPrivateFieldGet(this, _UMTMathClass_Localfactorial, "f");
+    }
+    get factorize() {
+        return __classPrivateFieldGet(this, _UMTMathClass_Localfactorize, "f");
+    }
+    get gcd() {
+        return __classPrivateFieldGet(this, _UMTMathClass_Localgcd, "f");
+    }
+    get getDecimalLength() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocalgetDecimalLength, "f");
+    }
+    get isDouble() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocalisDouble, "f");
+    }
+    get isNumber() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocalisNumber, "f");
+    }
+    get isPrimeNumber() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocalisPrimeNumber, "f");
+    }
+    get lcm() {
+        return __classPrivateFieldGet(this, _UMTMathClass_Locallcm, "f");
+    }
+    get mathConverter() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocalmathConverter, "f");
+    }
+    get mathSeparator() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocalmathSeparator, "f");
+    }
+    get max() {
+        return __classPrivateFieldGet(this, _UMTMathClass_Localmax, "f");
+    }
+    get min() {
+        return __classPrivateFieldGet(this, _UMTMathClass_Localmin, "f");
+    }
+    get multiples() {
+        return __classPrivateFieldGet(this, _UMTMathClass_Localmultiples, "f");
+    }
+    get multiplication() {
+        return __classPrivateFieldGet(this, _UMTMathClass_Localmultiplication, "f");
+    }
+    get nCr() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocalnCr, "f");
+    }
+    get nHr() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocalnHr, "f");
+    }
+    get nPr() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocalnPr, "f");
+    }
+    get primeFactorization() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocalprimeFactorization, "f");
+    }
+    get quotient() {
+        return __classPrivateFieldGet(this, _UMTMathClass_Localquotient, "f");
+    }
+    get radToDeg() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocalradToDeg, "f");
+    }
+    get random() {
+        return __classPrivateFieldGet(this, _UMTMathClass_Localrandom, "f");
+    }
+    get reduce() {
+        return __classPrivateFieldGet(this, _UMTMathClass_Localreduce, "f");
+    }
+    get repeatedTrial() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocalrepeatedTrial, "f");
+    }
+    get roundOf() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocalroundOf, "f");
+    }
+    get softmax() {
+        return __classPrivateFieldGet(this, _UMTMathClass_Localsoftmax, "f");
+    }
+    get standardDeviation() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocalstandardDeviation, "f");
+    }
+    get subtract() {
+        return __classPrivateFieldGet(this, _UMTMathClass_Localsubtract, "f");
+    }
+    get toBinary() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocaltoBinary, "f");
+    }
+    get toCelsius() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocaltoCelsius, "f");
+    }
+    get toKelvin() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocaltoKelvin, "f");
+    }
+    get valueSwap() {
+        return __classPrivateFieldGet(this, _UMTMathClass_LocalvalueSwap, "f");
+    }
+}
+exports.UMTMathClass = UMTMathClass;
+_UMTMathClass_Localaddition = new WeakMap(), _UMTMathClass_Localaverage = new WeakMap(), _UMTMathClass_Localcalculator = new WeakMap(), _UMTMathClass_LocaldegToRad = new WeakMap(), _UMTMathClass_LocaldeviationValue = new WeakMap(), _UMTMathClass_Localdivision = new WeakMap(), _UMTMathClass_Localfactorial = new WeakMap(), _UMTMathClass_Localfactorize = new WeakMap(), _UMTMathClass_Localgcd = new WeakMap(), _UMTMathClass_LocalgetDecimalLength = new WeakMap(), _UMTMathClass_LocalisDouble = new WeakMap(), _UMTMathClass_LocalisNumber = new WeakMap(), _UMTMathClass_LocalisPrimeNumber = new WeakMap(), _UMTMathClass_Locallcm = new WeakMap(), _UMTMathClass_LocalmathConverter = new WeakMap(), _UMTMathClass_LocalmathSeparator = new WeakMap(), _UMTMathClass_Localmax = new WeakMap(), _UMTMathClass_Localmin = new WeakMap(), _UMTMathClass_Localmultiples = new WeakMap(), _UMTMathClass_Localmultiplication = new WeakMap(), _UMTMathClass_LocalnCr = new WeakMap(), _UMTMathClass_LocalnHr = new WeakMap(), _UMTMathClass_LocalnPr = new WeakMap(), _UMTMathClass_LocalprimeFactorization = new WeakMap(), _UMTMathClass_Localquotient = new WeakMap(), _UMTMathClass_LocalradToDeg = new WeakMap(), _UMTMathClass_Localrandom = new WeakMap(), _UMTMathClass_Localreduce = new WeakMap(), _UMTMathClass_LocalrepeatedTrial = new WeakMap(), _UMTMathClass_LocalroundOf = new WeakMap(), _UMTMathClass_Localsoftmax = new WeakMap(), _UMTMathClass_LocalstandardDeviation = new WeakMap(), _UMTMathClass_Localsubtract = new WeakMap(), _UMTMathClass_LocaltoBinary = new WeakMap(), _UMTMathClass_LocaltoCelsius = new WeakMap(), _UMTMathClass_LocaltoKelvin = new WeakMap(), _UMTMathClass_LocalvalueSwap = new WeakMap();
+exports.UMT_Math = new UMTMathClass();

package/module/Math/isDouble.d.ts

@@ -1,6 +1,7 @@
 /**
  * 小数点を含むかどうか
  * @param  {any} x
+ * @param  {boolean} [isStrict=true] - 文字列も対象にするかどうか
+ * @returns boolean
  */
-declare const isDouble: (x: any, loose?: boolean) => boolean;
-export default isDouble;
+export declare const isDouble: (x: any, loose?: boolean) => boolean;

package/module/Math/isDouble.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDouble = void 0;
 /**
  * 小数点を含むかどうか
  * @param  {any} x
+ * @param  {boolean} [isStrict=true] - 文字列も対象にするかどうか
+ * @returns boolean
  */
 const isDouble = (x, loose = true) => {
     if (loose) {
@@ -15,4 +18,4 @@ const isDouble = (x, loose = true) => {
         return (x !== null && typeof x !== 'boolean' && Number.isFinite(x));
     }
 };
-exports.default = isDouble;
+exports.isDouble = isDouble;

package/module/Math/isNumber.d.ts

@@ -1,7 +1,7 @@
 /**
  * 数字かどうか
  * @param  {any} x
- * @param  {boolean} loose 曖昧な判定を許すかどうか(default:true)
+ * @param  {boolean} loose 文字列も対象にするかどうか
+ * @returns boolean
  */
-declare const isNumber: (x: any, loose?: boolean) => boolean;
-export default isNumber;
+export declare const isNumber: (x: any, loose?: boolean) => boolean;

package/module/Math/isNumber.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNumber = void 0;
 /**
  * 数字かどうか
  * @param  {any} x
- * @param  {boolean} loose 曖昧な判定を許すかどうか(default:true)
+ * @param  {boolean} loose 文字列も対象にするかどうか
+ * @returns boolean
  */
 const isNumber = (x, loose = true) => {
     return x !== null && typeof x !== 'boolean' && loose
         ? isFinite(x)
         : Number.isFinite(x);
 };
-exports.default = isNumber;
+exports.isNumber = isNumber;

package/module/Math/isPrimeNumber.d.ts

@@ -1,6 +1,6 @@
 /**
  * 素数判定
  * @param  {number} n
+ * @returns boolean
  */
-declare const isPrimeNumber: (n: number) => boolean;
-export default isPrimeNumber;
+export declare const isPrimeNumber: (n: number) => boolean;