Update the test cases and revised the cases

Author: mapcrafter2048

maths/bisection_method.ts

@@ -10,26 +10,30 @@
  * @example bisectionMethod(1, 2, 0.01, (x) => x**2 - 3) = 1.732421875
  */
 
-export const bisectionMethod = (a: number, b: number, e: number, f: Function): number => {
+export const bisectionMethod = (
+  a: number,
+  b: number,
+  e: number,
+  f: Function
+): number => {
+  if (e <= 0) {
+    throw new Error('Error threshold must be positive')
+  }
 
-    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')
-    }
+  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
-        if (f(c) === 0.0) {
-            break
-        } else if (f(c) * f(a) < 0) {
-            b = c
-        } else {
-            a = c
-        }
+  let c = a
+  while (Math.abs(b - a) / 2 >= e) {
+    c = (a + b) / 2
+    if (Math.abs(f(c)) < 1e-9) {
+      break
+    } else if (f(c) * f(a) < 0) {
+      b = c
+    } else {
+      a = c
     }
-    return c
-}
+  }
+  return c
+}

maths/decimal_convert.ts

@@ -4,16 +4,15 @@
  * @return {number} - Decimal of binary.
  * @see [DecimalConvert](https://www.programiz.com/javascript/examples/binary-decimal)
  * @example decimalConvert("1100") = 12
- * @example decimalConvert("1110") = 14
  */
 
 export const decimalConvert = (binary: string): number => {
-    let decimal = 0
-    let binaryArr = binary.split('').reverse()
+  let decimal = 0
+  let binaryArr = binary.split('').reverse()
 
-    for (let i = 0; i < binaryArr.length; i++) {
-        decimal += parseInt(binaryArr[i]) * Math.pow(2, i)
-    }
+  for (let i = 0; i < binaryArr.length; i++) {
+    decimal += parseInt(binaryArr[i]) * Math.pow(2, i)
+  }
 
-    return decimal
+  return decimal
 }

maths/euler_method.ts

@@ -11,23 +11,28 @@
  * @example eulerMethod(0, 1, 0.1, 10, (x, y) => x * y) = 1.7715614317
  */
 
-export const eulerMethod = (x0: number, y0: number, h: number, n: number, f: Function): number => {
+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 (typeof f !== 'function') { 
-        throw new Error('f must be a function')
-    }
+  if (n < 0) {
+    throw new Error('Number of iterations must be non-negative')
+  }
 
-    if (n < 0) {
-        throw new Error('Number of iterations must be non-negative')
-    }
+  let x = x0
+  let y = y0
 
-    let x = x0
-    let y = y0
+  for (let i = 0; i < n; i++) {
+    y = y + h * f(x, y)
+    x = x + h
+  }
 
-    for (let i = 1; i <= n; i++) {
-        y = y + h * f(x, y)
-        x = x + h
-    }
-
-    return y
-}
+  return y
+}

maths/test/bisection_method.test.ts

@@ -1,41 +1,28 @@
-import { bisectionMethod } from "../bisection_method";
+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'
-        );
-    });
-});
+  it('should find the root of f(x) = x^2 - 3 between [1, 2]', () => {
+    const result = bisectionMethod(1, 2, 0.001, (x: number) => x ** 2 - 3)
+    expect(result).toBeCloseTo(1.732, 3)
+  })
+
+  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.001, (x: number) => x ** 2 + x - 6)
+    expect(result).toBeCloseTo(2, 3)
+  })
+
+  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, 2)
+  })
+
+  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, 2)
+  })
+})

maths/test/decimal_convert.test.ts

@@ -1,40 +1,31 @@
-import { decimalConvert } from "../decimal_convert";
+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');
-    });
-
-});
+  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)
+  })
+})

maths/test/euler_method.test.ts

@@ -1,43 +1,42 @@
-import { eulerMethod } from './eulerMethod';
+import { eulerMethod } from '../euler_method'
 
 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');
-    });
-
-});
+  it('should compute y for dy/dx = y with y(0) = 1 at x = 1', () => {
+    const result = eulerMethod(0, 1, 0.1, 10, (x: number, y: number) => y)
+    expect(result).toBeCloseTo(2.59374, 5)
+  })
+
+  it('should compute y for dy/dx = -2y with y(0) = 1 at x = 1', () => {
+    const result = eulerMethod(0, 1, 0.1, 10, (x: number, y: number) => -2 * y)
+    const expectedResult = 1 * Math.pow(0.8, 10)
+    expect(result).toBeCloseTo(expectedResult, 5)
+  })
+
+  it('should compute y for dy/dx = x with y(0) = 0 at x = 1', () => {
+    const result = eulerMethod(0, 0, 0.1, 10, (x: number, y: number) => x)
+    expect(result).toBeCloseTo(0.45, 2)
+  })
+
+  it('should compute y for dy/dx = x + y with y(0) = 1 at x = 0.5', () => {
+    const h = 0.1
+    const n = 5
+    const result = eulerMethod(0, 1, h, n, (x: number, y: number) => x + y)
+    expect(result).toBeCloseTo(1.72102, 5)
+  })
+
+  it('should compute y for dy/dx = x^2 with y(0) = 0 at x = 1', () => {
+    const result = eulerMethod(0, 0, 0.2, 5, (x: number, y: number) => x ** 2)
+    expect(result).toBeCloseTo(0.24, 3)
+  })
+
+  it('should handle negative step size for dy/dx = y with y(1) = e', () => {
+    const result = eulerMethod(
+      1,
+      Math.E,
+      -0.001,
+      1000,
+      (x: number, y: number) => y
+    )
+    expect(result).toBeCloseTo(1, 2)
+  })
+})