@gabrielrufino/cerebrum 1.0.0 → 1.0.1

package/dist/Math/Fibonacci.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fibonacci = void 0;
+class Fibonacci {
+    constructor(n) {
+        this.n = n;
+        if (n < 1)
+            throw new RangeError('Input should be a positive integer');
+    }
+    execute() {
+        if ([1, 2].includes(this.n))
+            return 1;
+        return new Fibonacci(this.n - 1).execute() + new Fibonacci(this.n - 2).execute();
+    }
+}
+exports.Fibonacci = Fibonacci;

package/dist/Math/LinearRegression.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinearRegression = void 0;
+class LinearRegression {
+    constructor(values) {
+        this.values = values;
+        this._slope = null;
+        this._intercept = null;
+        if (values.length === 0) {
+            throw new Error('The input data must not be empty.');
+        }
+        return this;
+    }
+    calculate() {
+        const length = this.values.length;
+        const sumX = this.values.reduce((acc, curr) => acc + curr.x, 0);
+        const sumY = this.values.reduce((acc, curr) => acc + curr.y, 0);
+        const sumXY = this.values.reduce((acc, curr) => acc + curr.x * curr.y, 0);
+        const sumXSquare = this.values.reduce((acc, curr) => acc + Math.pow(curr.x, 2), 0);
+        const denominator = length * sumXSquare - sumX * sumX;
+        if (denominator === 0) {
+            throw new Error('The input data points are collinear or insufficient for regression.');
+        }
+        this._slope = (length * sumXY - sumX * sumY) / denominator;
+        this._intercept = (sumY * sumXSquare - sumX * sumXY) / denominator;
+        return this;
+    }
+    predict(x) {
+        if (this._slope === null || this._intercept === null) {
+            throw new Error('You need to calculate the regression before making predictions.');
+        }
+        return this._slope * x + this._intercept;
+    }
+    get slope() {
+        return this._slope;
+    }
+    get intercept() {
+        return this._intercept;
+    }
+}
+exports.LinearRegression = LinearRegression;

package/dist/Math/TwoSum.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwoSum = void 0;
+class TwoSum {
+    constructor(numbers, target) {
+        this.numbers = numbers;
+        this.target = target;
+    }
+    execute() {
+        let left = 0;
+        let right = this.numbers.length - 1;
+        while (left < right) {
+            const sum = this.numbers[left] + this.numbers[right];
+            if (sum === this.target) {
+                return [left, right];
+            }
+            else if (sum < this.target) {
+                left++;
+            }
+            else {
+                right--;
+            }
+        }
+        return null;
+    }
+}
+exports.TwoSum = TwoSum;

package/dist/Sort/BubbleSort.js

@@ -2,16 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BubbleSort = void 0;
 class BubbleSort {
-    constructor() { }
-    static execute(numbers) {
-        for (let i = 0; i < numbers.length - 1; i++) {
-            for (let j = 0; j < numbers.length - i - 1; j++) {
-                if (numbers[j] > numbers[j + 1]) {
-                    [numbers[j], numbers[j + 1]] = [numbers[j + 1], numbers[j]];
+    constructor(numbers) {
+        this.numbers = numbers;
+        return this;
+    }
+    execute() {
+        for (let i = 0; i < this.numbers.length - 1; i++) {
+            for (let j = 0; j < this.numbers.length - i - 1; j++) {
+                if (this.numbers[j] > this.numbers[j + 1]) {
+                    [this.numbers[j], this.numbers[j + 1]] = [this.numbers[j + 1], this.numbers[j]];
                 }
             }
         }
-        return numbers;
+        return [...this.numbers];
     }
 }
 exports.BubbleSort = BubbleSort;

package/dist/Sort/SelectionSort.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectionSort = void 0;
+class SelectionSort {
+    constructor(numbers) {
+        this.numbers = numbers;
+        return this;
+    }
+    execute() {
+        for (let i = 0; i < this.numbers.length - 1; i++) {
+            let minIndex = i;
+            for (let j = i + 1; j < this.numbers.length; j++) {
+                if (this.numbers[j] < this.numbers[minIndex]) {
+                    minIndex = j;
+                }
+            }
+            [this.numbers[i], this.numbers[minIndex]] = [this.numbers[minIndex], this.numbers[i]];
+        }
+        return [...this.numbers];
+    }
+}
+exports.SelectionSort = SelectionSort;

package/dist/index.js

@@ -14,4 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Math/Fibonacci"), exports);
 __exportStar(require("./Sort/BubbleSort"), exports);
+__exportStar(require("./Sort/SelectionSort"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gabrielrufino/cerebrum",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Algorithms made in TypeScript",
   "main": "dist/index.js",
   "type": "module",