chore: creating build

packages/typescript/dist/arithmeticOp/index.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ArithmeticOp = (function () {
+    function ArithmeticOp() {
+    }
+    ArithmeticOp.prototype.sum = function () {
+        var numbers = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            numbers[_i] = arguments[_i];
+        }
+        return numbers.reduce(function (acc, curr) { return acc + curr; }, 0);
+    };
+    ArithmeticOp.prototype.sub = function () {
+        var numbers = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            numbers[_i] = arguments[_i];
+        }
+        return numbers.reduce(function (acc, curr) { return acc - curr; });
+    };
+    ArithmeticOp.prototype.mul = function () {
+        var numbers = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            numbers[_i] = arguments[_i];
+        }
+        return numbers.reduce(function (acc, curr) { return acc * curr; }, 1);
+    };
+    ArithmeticOp.prototype.div = function () {
+        var numbers = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            numbers[_i] = arguments[_i];
+        }
+        return numbers.reduce(function (acc, curr) { return acc / curr; });
+    };
+    ArithmeticOp.prototype.mod = function () {
+        var numbers = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            numbers[_i] = arguments[_i];
+        }
+        return numbers.reduce(function (acc, curr) { return acc % curr; });
+    };
+    ArithmeticOp.prototype.power = function (base, exponent) {
+        var result = 1;
+        for (var i = 0; i < exponent; i++) {
+            result *= base;
+        }
+        return result;
+    };
+    ArithmeticOp.prototype.getSum = function () {
+        return this.sum;
+    };
+    ArithmeticOp.prototype.getSub = function () {
+        return this.sub;
+    };
+    ArithmeticOp.prototype.getMul = function () {
+        return this.mul;
+    };
+    ArithmeticOp.prototype.getDiv = function () {
+        return this.div;
+    };
+    ArithmeticOp.prototype.getMod = function () {
+        return this.mod;
+    };
+    ArithmeticOp.prototype.getPower = function () {
+        return this.power;
+    };
+    return ArithmeticOp;
+}());
+exports.default = ArithmeticOp;

packages/typescript/dist/generateCriticalPointInterval/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function generateCriticalPointInterval(min, max) {
+    return Math.random() * (max - min + 1) + min;
+}
+exports.default = generateCriticalPointInterval;

packages/typescript/dist/loganmatic.js

@@ -1,9 +1,32 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var arithmeticOp_1 = __importDefault(require("./arithmeticOp"));
+var generateCriticalPointInterval_1 = __importDefault(require("./generateCriticalPointInterval"));
 var piValue = "3.1415926535897932384626433832795";
-var Calculator = (function () {
+var Calculator = (function (_super) {
+    __extends(Calculator, _super);
     function Calculator() {
-        this.EulerNumber = this.createEulerNumber();
-        this.Pi = parseFloat(piValue);
+        var _this = _super.call(this) || this;
+        _this.EulerNumber = _this.createEulerNumber();
+        _this.Pi = parseFloat(piValue);
+        return _this;
     }
     Calculator.prototype.createEulerNumber = function (n) {
         if (n === void 0) { n = 9999; }
@@ -30,24 +53,21 @@ var Calculator = (function () {
         else if (answer1 > 0 && answer2 > 0) {
             criticalPoint1 = criticalPoint2 * -1;
         }
-        function generateCriticalPointInterval(min, max) {
-            return Math.random() * (max - min + 1) + min;
-        }
         var criticalPoint3;
         if (answer1 > answer2) {
             if (Number(answer1) - Number(answer2) > 1) {
-                criticalPoint3 = generateCriticalPointInterval(Math.ceil(Number(answer2) + 0.2), Number(answer1));
+                criticalPoint3 = (0, generateCriticalPointInterval_1.default)(Math.ceil(Number(answer2) + 0.2), Number(answer1));
             }
             else {
-                criticalPoint3 = generateCriticalPointInterval(Number(answer2) + 0.2, Number(answer1));
+                criticalPoint3 = (0, generateCriticalPointInterval_1.default)(Number(answer2) + 0.2, Number(answer1));
             }
         }
         else {
             if (Number(answer2) - Number(answer1) > 1) {
-                criticalPoint3 = generateCriticalPointInterval(Math.ceil(Number(answer1) + 0.2), Number(answer2));
+                criticalPoint3 = (0, generateCriticalPointInterval_1.default)(Math.ceil(Number(answer1) + 0.2), Number(answer2));
             }
             else {
-                criticalPoint3 = generateCriticalPointInterval(Number(answer1) + 0.2, Number(answer2));
+                criticalPoint3 = (0, generateCriticalPointInterval_1.default)(Number(answer1) + 0.2, Number(answer2));
             }
         }
         if (delta < 0) {
@@ -550,6 +570,9 @@ var Calculator = (function () {
             return this.ruffiniDevice(valueA, valueB, valueC, valueD, raizes_1, checkedYes);
         }
     };
+    Calculator.prototype.getRufinhoDevice = function () {
+        return this.ruffiniDevice;
+    };
     return Calculator;
-}());
+}(arithmeticOp_1.default));
 module.exports = new Calculator();

packages/typescript/types/arithmeticOp/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Represents a class for performing arithmetic operations.
+ */
+export default class ArithmeticOp {
+    /**
+     * Calculates the sum of the given numbers.
+     * @param numbers - The numbers to be summed.
+     * @returns The sum of the numbers.
+     */
+    protected sum(...numbers: number[]): number;
+    /**
+     * Calculates the difference between the given numbers.
+     * @param numbers - The numbers to be subtracted.
+     * @returns The difference between the numbers.
+     */
+    protected sub(...numbers: number[]): number;
+    /**
+     * Calculates the product of the given numbers.
+     * @param numbers - The numbers to be multiplied.
+     * @returns The product of the numbers.
+     */
+    protected mul(...numbers: number[]): number;
+    /**
+     * Calculates the division of the given numbers.
+     * @param numbers - The numbers to be divided.
+     * @returns The division of the numbers.
+     */
+    protected div(...numbers: number[]): number;
+    /**
+     * Calculates the modulo of the given numbers.
+     * @param numbers - The numbers to be modded.
+     * @returns The modulo of the numbers.
+     */
+    protected mod(...numbers: number[]): number;
+    /**
+     * Calculates the power of the given base and exponent.
+     * @param base - The base number.
+     * @param exponent - The exponent number.
+     * @returns The power of the base and exponent.
+     */
+    protected power(base: number, exponent: number): number;
+    getSum(): (...numbers: number[]) => number;
+    getSub(): (...numbers: number[]) => number;
+    getMul(): (...numbers: number[]) => number;
+    getDiv(): (...numbers: number[]) => number;
+    getMod(): (...numbers: number[]) => number;
+    getPower(): (base: number, exponent: number) => number;
+}

packages/typescript/types/generateCriticalPointInterval/index.d.ts

@@ -0,0 +1 @@
+export default function generateCriticalPointInterval(min: number, max: number): number;

packages/typescript/types/loganmatic.d.ts

@@ -1,11 +1,12 @@
+import ArithmeticOp from "./arithmeticOp";
 import { ReturnTypesForEquation, ReturnTypesForEquation2upDegree } from "./types/loganmatic";
 /**
  * @author - Gabriel Logan
  * @description - Program created as a math library in English
  * @example - import Mathematics from "loganmatic"
  * console.log(Mathematics.Pi)
  */
-declare class Calculator {
+declare class Calculator extends ArithmeticOp {
     EulerNumber: number;
     Pi: number;
     constructor();
@@ -166,6 +167,13 @@ declare class Calculator {
      * @return - It has only 1 real root in X = -3.344171229347796
      */
     cubicEquation(a?: number, b?: number, c?: number, d?: number, approximate?: boolean): ReturnTypesForEquation2upDegree;
+    getRufinhoDevice(): (valueA: number, valueB: number, valueC: number, valueD: number, raizes: number[], checkedYes: boolean) => {
+        value: number[];
+        msg: string;
+    } | {
+        value: null;
+        msg: string;
+    };
 }
 declare const _default: Calculator;
 export = _default;