diff --git a/maths/bisection_method.ts b/maths/bisection_method.ts index ec3e7235..6116d068 100644 --- a/maths/bisection_method.ts +++ b/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 diff --git a/maths/decimal_convert.ts b/maths/decimal_convert.ts index 2413378e..2003c289 100644 --- a/maths/decimal_convert.ts +++ b/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 => { diff --git a/maths/euler_method.ts b/maths/euler_method.ts index bc4c4b7c..e77858c9 100644 --- a/maths/euler_method.ts +++ b/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 diff --git a/maths/test/bisection_method.test.ts b/maths/test/bisection_method.test.ts new file mode 100644 index 00000000..a7dde1e6 --- /dev/null +++ b/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' + ); + }); +}); \ No newline at end of file diff --git a/maths/test/decimal_convert.test.ts b/maths/test/decimal_convert.test.ts new file mode 100644 index 00000000..14dd838a --- /dev/null +++ b/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'); + }); + +}); \ No newline at end of file diff --git a/maths/test/euler_method.test.ts b/maths/test/euler_method.test.ts new file mode 100644 index 00000000..0abb0170 --- /dev/null +++ b/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'); + }); + +});