diff --git a/maths/bisection_method.ts b/maths/bisection_method.ts
new file mode 100644
index 00000000..2788570c
--- /dev/null
+++ b/maths/bisection_method.ts
@@ -0,0 +1,39 @@
+/**
+ * @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
+ * @param {number} e - The error value
+ * @param {Function} f - The function
+ * @return {number} - The root of the function
+ * @see [BisectionMethod](https://en.wikipedia.org/wiki/Bisection_method)
+ * @example bisectionMethod(1, 2, 0.01, (x) => x**2 - 2) = 1.4140625
+ * @example bisectionMethod(1, 2, 0.01, (x) => x**2 - 3) = 1.732421875
+ */
+
+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 (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
+}
diff --git a/maths/decimal_convert.ts b/maths/decimal_convert.ts
new file mode 100644
index 00000000..85210ba7
--- /dev/null
+++ b/maths/decimal_convert.ts
@@ -0,0 +1,18 @@
+/**
+ * @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
+ */
+
+export const decimalConvert = (binary: string): number => {
+ let decimal = 0
+ let binaryArr = binary.split('').reverse()
+
+ for (let i = 0; i < binaryArr.length; i++) {
+ decimal += parseInt(binaryArr[i]) * Math.pow(2, i)
+ }
+
+ return decimal
+}
diff --git a/maths/euler_method.ts b/maths/euler_method.ts
new file mode 100644
index 00000000..91164ae8
--- /dev/null
+++ b/maths/euler_method.ts
@@ -0,0 +1,38 @@
+/**
+ * @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
+ * @param {number} h - The step size
+ * @param {number} n - The number of iterations
+ * @param {Function} f - The function
+ * @return {number} - The value of y at x
+ * @see [EulerMethod](https://en.wikipedia.org/wiki/Euler_method)
+ * @example eulerMethod(0, 1, 0.1, 10, (x, y) => x + y) = 2.5937424601
+ * @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 => {
+ 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
+
+ for (let i = 0; i < n; i++) {
+ y = y + h * f(x, y)
+ x = x + h
+ }
+
+ return y
+}
diff --git a/maths/test/bisection_method.test.ts b/maths/test/bisection_method.test.ts
new file mode 100644
index 00000000..fb78d756
--- /dev/null
+++ b/maths/test/bisection_method.test.ts
@@ -0,0 +1,28 @@
+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.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)
+ })
+})
diff --git a/maths/test/decimal_convert.test.ts b/maths/test/decimal_convert.test.ts
new file mode 100644
index 00000000..c21fadea
--- /dev/null
+++ b/maths/test/decimal_convert.test.ts
@@ -0,0 +1,31 @@
+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)
+ })
+})
diff --git a/maths/test/euler_method.test.ts b/maths/test/euler_method.test.ts
new file mode 100644
index 00000000..f833757b
--- /dev/null
+++ b/maths/test/euler_method.test.ts
@@ -0,0 +1,42 @@
+import { eulerMethod } from '../euler_method'
+
+describe('eulerMethod', () => {
+ 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)
+ })
+})
pFad - Phonifier reborn
Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.
Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.
Alternative Proxies:
Alternative Proxy
pFad Proxy
pFad v3 Proxy
pFad v4 Proxy