Added the test cases for bisection method euler method and binary to decimal conversion

Author: mapcrafter2048

maths/bisection_method.ts

@@ -1,5 +1,4 @@
 /**
- * @function bisectionMethod 
  * @description Bisection method is a root-finding method that applies to any continuous function for which one knows two values with opposite signs.
  * @param  {number} a - The first value
  * @param  {number} b - The second value
@@ -12,6 +11,15 @@
  */
 
 export const bisectionMethod = (a: number, b: number, e: number, f: Function): number => {
+
+    if (e <= 0) { 
+        throw new Error('Error threshold must be positive')
+    }
+
+    if (f(a) * f(b) >= 0) { 
+        throw new Error('f(a) and f(b) should have opposite signs')
+    }
+
     let c = a
     while ((b - a) >= e) {
         c = (a + b) / 2

maths/decimal_convert.ts

@@ -1,11 +1,10 @@
 /**
- * @function decimalConvert
  * @description Convert the binary to decimal.
  * @param {string} binary - The input binary
  * @return {number} - Decimal of binary.
  * @see [DecimalConvert](https://www.programiz.com/javascript/examples/binary-decimal)
- * @example decimalConvert(1100) = 12
- * @example decimalConvert(1110) = 14
+ * @example decimalConvert("1100") = 12
+ * @example decimalConvert("1110") = 14
  */
 
 export const decimalConvert = (binary: string): number => {

maths/euler_method.ts

@@ -1,5 +1,4 @@
 /**
- * @function eulerMethod
  * @description Euler's method is a first-order numerical procedure for solving ordinary differential equations (ODEs) with a given initial value.
  * @param {number} x0 - The initial value of x
  * @param {number} y0 - The initial value of y
@@ -13,6 +12,15 @@
  */
 
 export const eulerMethod = (x0: number, y0: number, h: number, n: number, f: Function): number => {
+
+    if (typeof f !== 'function') { 
+        throw new Error('f must be a function')
+    }
+
+    if (n < 0) {
+        throw new Error('Number of iterations must be non-negative')
+    }
+
     let x = x0
     let y = y0
 

maths/test/bisection_method.test.ts

@@ -0,0 +1,41 @@
+import { bisectionMethod } from "../bisection_method";
+
+describe('bisectionMethod', () => {
+
+    it('should find the root of f(x) = x^2 - 3 between [1, 2]', () => {
+        const result = bisectionMethod(1, 2, 0.01, (x: number) => x ** 2 - 3);
+        expect(result).toBeCloseTo(1.732, 2);
+    });
+
+    it('should find the root of f(x) = x^3 - x - 2 between [1, 2]', () => {
+        const result = bisectionMethod(1, 2, 0.001, (x: number) => x ** 3 - x - 2);
+        expect(result).toBeCloseTo(1.521, 3);
+    });
+
+    it('should find the root of f(x) = x^2 + x - 6 between [1, 3]', () => {
+        const result = bisectionMethod(1, 3, 0.01, (x: number) => x ** 2 + x - 6);
+        expect(result).toBeCloseTo(1.816, 2);
+    });
+
+    it('should find the root of f(x) = cos(x) - x between [0, 1]', () => {
+        const result = bisectionMethod(0, 1, 0.001, (x: number) => Math.cos(x) - x);
+        expect(result).toBeCloseTo(0.739, 3);
+    });
+
+    it('should find the root of f(x) = e^x - 3 between [0, 2]', () => {
+        const result = bisectionMethod(0, 2, 0.001, (x: number) => Math.exp(x) - 3);
+        expect(result).toBeCloseTo(1.099, 3);
+    });
+
+    it('should throw an error when f(a) and f(b) have the same sign', () => {
+        expect(() => bisectionMethod(1, 2, 0.01, (x: number) => x ** 2 + 1)).toThrow(
+            'f(a) and f(b) should have opposite signs'
+        );
+    });
+
+    it('should throw an error when error threshold is non-positive', () => {
+        expect(() => bisectionMethod(1, 2, -0.01, (x: number) => x ** 2 - 2)).toThrow(
+            'Error threshold must be positive'
+        );
+    });
+});

maths/test/decimal_convert.test.ts

@@ -0,0 +1,40 @@
+import { decimalConvert } from "../decimal_convert";
+
+describe('decimalConvert', () => {
+    it('should convert "1100" to 12', () => {
+        expect(decimalConvert("1100")).toBe(12);
+    });
+
+    it('should convert "1110" to 14', () => {
+        expect(decimalConvert("1110")).toBe(14);
+    });
+
+    it('should convert "0" to 0', () => {
+        expect(decimalConvert("0")).toBe(0);
+    });
+
+    it('should convert "1" to 1', () => {
+        expect(decimalConvert("1")).toBe(1);
+    });
+
+    it('should convert "101" to 5', () => {
+        expect(decimalConvert("101")).toBe(5);
+    });
+
+    it('should handle an empty string by returning 0', () => {
+        expect(decimalConvert("")).toBe(0);
+    });
+
+    it('should convert a binary string with leading zeros "0001" to 1', () => {
+        expect(decimalConvert("0001")).toBe(1);
+    });
+
+    it('should throw an error when the input is not a valid binary string', () => {
+        expect(() => decimalConvert("102")).toThrow('Invalid binary input');
+    });
+
+    it('should throw an error when the input contains non-numeric characters', () => {
+        expect(() => decimalConvert("abc")).toThrow('Invalid binary input');
+    });
+
+});

maths/test/euler_method.test.ts

@@ -0,0 +1,43 @@
+import { eulerMethod } from './eulerMethod';
+
+describe('eulerMethod', () => {
+    it('should compute y for a linear function (x + y)', () => {
+        const result = eulerMethod(0, 1, 0.1, 10, (x, y) => x + y);
+        expect(result).toBeCloseTo(2.5937424601, 5);
+    });
+
+    it('should compute y for a multiplicative function (x * y)', () => {
+        const result = eulerMethod(0, 1, 0.1, 10, (x, y) => x * y);
+        expect(result).toBeCloseTo(1.7715614317, 5);
+    });
+
+    it('should return the initial value y0 when there are zero iterations', () => {
+        const result = eulerMethod(0, 1, 0.1, 0, (x, y) => x + y);
+        expect(result).toBe(1);
+    });
+
+    it('should return the correct value for a very small step size', () => {
+        const result = eulerMethod(0, 1, 0.01, 100, (x, y) => x + y);
+        expect(result).toBeCloseTo(2.7048138294, 5);
+    });
+
+    it('should return the correct value after one iteration', () => {
+        const result = eulerMethod(0, 1, 0.1, 1, (x, y) => x + y);
+        expect(result).toBeCloseTo(1.1, 5);
+    });
+
+    it('should return the initial value y0 when step size is zero', () => {
+        const result = eulerMethod(0, 1, 0, 10, (x, y) => x + y);
+        expect(result).toBe(1);
+    });
+
+    it('should return correct value for negative step size', () => {
+        const result = eulerMethod(1, 1, -0.1, 10, (x, y) => x + y);
+        expect(result).toBeCloseTo(0.3162798676, 5);
+    });
+
+    it('should throw an error when number of iterations is negative', () => {
+        expect(() => eulerMethod(0, 1, 0.1, -5, (x, y) => x + y)).toThrow('Number of iterations must be non-negative');
+    });
+
+});