New math functions

maths/binary_exponentiation.ts

@@ -0,0 +1,37 @@
+/**
+ * @function binaryExponent
+ * @description Returns the power of a number A raised to the power of B with binary exponentiation
+ * @summary Binary exponentiation calculatoes A^B in logarithmic time of B instead of linear time
+ * @param {Number} num - An array of two natural numbers, [A, B], where A^B will be solved
+ * @return {number} A^B
+ * @see [Wikipedia](https://cp-algorithms.com/algebra/binary-exp.html)
+ * @example binaryExponent([5, 2]) = 25
+ * @example binaryExponent([10, 18]) = 1000000000000000000
+ */
+
+export const binaryExponent = (numbers: number[]): number => {
+    // raise errors upon invalid inputs
+    if (numbers.length != 2) {
+        throw new TypeError('Invalid Input')
+    }
+    for(let i=0; i < numbers.length; i++){
+        if (numbers[i] < 0 || !Number.isInteger(numbers[i])) {
+            throw new TypeError('Invalid Input')
+        }
+    }
+
+    // binary exponentiation algorithm
+    // if B == 0
+    if (numbers[1] === 0) {
+        // A^0 = 1
+        return 1;
+    }
+    let res = Math.pow(numbers[0], Math.floor(numbers[1] / 2));
+    // if B is even or odd
+    if (numbers[1] % 2 === 1) {
+        return res * res * numbers[0];
+    } 
+    else {
+        return res * res;
+    }
+  }

maths/co_prime.ts

@@ -0,0 +1,51 @@
+/**
+ * @function coPrime
+ * @description Determine if given two numbers have no common factor (are coprimes). The common factor cannot be 1 or itself.
+ * @param {number} num - An array of two natural numbers (positive integers not including 0).
+ * @return {boolean} - Whether the given two number are coprimes
+ * @see https://en.wikipedia.org/wiki/Coprime_integers
+ * @example isPrime(2, 3) = 0
+ * @example isPrime(3, 6) = 2
+ */
+export const coPrime = (numbers: number[]): boolean => {
+    // raise corresponding errors upon invalid inputs
+    if (numbers.length != 2) {
+        throw new TypeError('Invalid Input')
+    }
+    for(let i=0; i < numbers.length; i++){
+        if (numbers[i] < 1 || !Number.isInteger(numbers[i])) {
+            throw new TypeError('Invalid Input')
+        }
+    }
+
+    // handle input being 1
+    if (numbers[0] === 1 || numbers[1] === 1) return false
+
+    let factors0 = []
+    let factors1 = []
+
+    // iterate from 2 to the square root of num to find a factor
+    // add factors to arrays
+    for (let i = 2; i <= Math.sqrt(numbers[0]); i++) {
+      if (numbers[0] % i === 0) {
+        factors0.push(i)
+      }
+    }
+    for (let i = 2; i <= Math.sqrt(numbers[1]); i++) {
+        if (numbers[1] % i === 0) {
+          factors1.push(i)
+        }
+    }
+    console.log(factors0)
+    console.log(factors1)
+
+    // check if same factors
+    for (let i = 0; i <= factors0.length; i++) {
+        if (factors1.includes(factors0[i])) {
+            return false
+        }
+    }
+
+    // if the entire loop runs without finding a similar factor, return true
+    return true
+  }

maths/geometric_mean.ts

@@ -0,0 +1,39 @@
+/**
+ * @function geometricMean
+ * @description Returns the geometric mean of the provided array of numbers
+ * @summary The geometric mean of an array of numbers a_1, a_2,..., a_n is given by (a_1 * a_2 * ... * a_n)^(1/n)
+ * So, for example, the geometric mean of numbers 1, 2, 3, 4 is (1 * 2 * 3 * 4) ^ (1/4)
+ * @param {number[]} numbers - Array of numeric values
+ * @return {number} The aliquot sum of the number
+ * @see [Wikipedia](https://en.wikipedia.org/wiki/Geometric_mean)
+ * @example aliquotSum([2, 8]) = 4
+ * @example aliquotSum([4, 8, 16]) = 8
+ */
+export const geometricMean = (numbers: number[]): number => {
+  if (numbers.length < 1) {
+    throw new TypeError('Invalid Input')
+  }
+  for(let i=0; i < numbers.length; i++){
+    if (numbers[i] === 0) {
+        return 0
+    }
+  }
+  for(let i=0; i < numbers.length; i++){
+    if (numbers[i] < 0) {
+        throw new TypeError('Invalid Input')
+    }
+  }
+
+  // This loop multiplies all values in the 'numbers' array using an array reducer
+  const product = numbers.reduce((product, current) => product * current, 1)
+
+  // Divide product by the length of the 'numbers' array.
+  let geo_mean = product ** (1/numbers.length)
+
+  // Round to nearest integer if close enough due to imprecise float
+  if (Math.abs(geo_mean - Math.round(geo_mean)) < 0.000000000000001) {
+    geo_mean = Math.round(geo_mean);
+  }
+
+  return geo_mean;
+}

maths/hexagon_area.ts

@@ -0,0 +1,28 @@
+/**
+ * @function hexArea
+ * @description Returns area of a regular hexagon
+ * @summary Finds the area of a regular hexagon (all 6 sides are equal lenght)  
+ * @param {Number} num - A natural number
+ * @return {number} The area of a regular hexagon
+ * @see [Wikipedia](https://en.wikipedia.org/wiki/Hexagon)
+ * @example hexArea(3) = 23.382685902179844
+ * @example hexArea(10) = 259.8076211353316
+ */
+
+export const hexArea = (side: number): number => {
+    if (side <= 0) {
+      throw new TypeError('Invalid Input')
+    }
+
+    let area = ((3 * (3 ** (1/2)) / 2)) * (side ** 2)
+
+    // Round to nearest integer if close enough due to imprecise float
+    if (Math.abs(area - Math.round(area)) < 0.000000000000001) {
+        area = Math.round(area);
+    }
+
+    return area
+  }
+
+
+

maths/octagon_area.ts

@@ -0,0 +1,25 @@
+/**
+ * @function octArea
+ * @description Returns area of a regular octagon
+ * @summary Finds the area of a regular octagon (all 8 sides are equal lenght)  
+ * @param {Number} num - A natural number
+ * @return {number} The area of a regular octagon
+ * @see [Wikipedia](https://en.wikipedia.org/wiki/Octagon)
+ * @example octArea(3) = 43.45584412271571
+ * @example octArea(10) = 482.84271247461896
+ */
+
+export const octArea = (side: number): number => {
+    if (side <= 0) {
+      throw new TypeError('Invalid Input')
+    }
+
+    let area = (2 * (1 + (2 ** (1/2)))) * (side ** 2)
+
+    // Round to nearest integer if close enough due to imprecise float
+    if (Math.abs(area - Math.round(area)) < 0.000000000000001) {
+        area = Math.round(area);
+    }
+
+    return area
+  }

maths/pentagon_area.ts

@@ -0,0 +1,25 @@
+/**
+ * @function pentArea
+ * @description Returns area of a regular pentagon
+ * @summary Finds the area of a regular pentagon (all 5 sides are equal lenght)  
+ * @param {Number} num - A natural number
+ * @return {number} The area of a regular pentagon
+ * @see [Wikipedia](https://en.wikipedia.org/wiki/Pentagon)
+ * @example pentArea(1) = 1.72048
+ * @example pentArea(8) = 110.11055
+ */
+
+export const pentArea = (side: number): number => {
+    if (side <= 0) {
+      throw new TypeError('Invalid Input')
+    }
+
+    let area = (1/4) * ((5 * (5 + 2 * (5 ** (1/2)))) ** (1/2)) * (side ** 2)
+
+    // Round to nearest integer if close enough due to imprecise float
+    if (Math.abs(area - Math.round(area)) < 0.000000000000001) {
+        area = Math.round(area);
+    }
+
+    return area
+  }

maths/test/binary_exponentiation.test.ts

@@ -0,0 +1,29 @@
+import { binaryExponent } from '../binary_exponentiation'
+
+describe('Tests for HexArea', () => {
+  it('should be a function', () => {
+    expect(typeof binaryExponent).toEqual('function')
+  })
+
+  it('should throw error for invalid input', () => {
+    expect(() => binaryExponent([])).toThrow()
+  })
+
+  it('should throw error for invalid input', () => {
+    expect(() => binaryExponent([-1, 1])).toThrow()
+  })
+
+  it('should throw error for invalid input', () => {
+    expect(() => binaryExponent([0])).toThrow()
+  })
+
+  it('should return A^B', () => {
+    const binaryExponentFunction = binaryExponent([1, 0])
+    expect(binaryExponentFunction).toBe(1)
+  })
+
+  it('should return A^B', () => {
+    const binaryExponentFunction = binaryExponent([10, 18])
+    expect(binaryExponentFunction).toBe(1000000000000000000)
+  })
+})

maths/test/co_prime.test.ts

@@ -0,0 +1,25 @@
+import { coPrime } from '../co_prime'
+
+describe('Tests for CoPrime', () => {
+  it('should be a function', () => {
+    expect(typeof coPrime).toEqual('function')
+  })
+
+  it('should throw error for invalid input', () => {
+    expect(() => coPrime([1])).toThrow()
+  })
+
+  it('should throw error for invalid input (less than 1)', () => {
+    expect(() => coPrime([1, -3])).toThrow()
+  })
+
+  it('should return if two numbers are coprimes', () => {
+    const coPrimeFunction = coPrime([4, 8])
+    expect(coPrimeFunction).toBe(false)
+  })
+
+  it('should return if two numbers are coprimes', () => {
+    const coPrimeFunction = coPrime([9, 16])
+    expect(coPrimeFunction).toBe(true)
+  })
+})

maths/test/geometric_mean.test.ts

@@ -0,0 +1,30 @@
+import { geometricMean } from '../geometric_mean'
+
+describe('Tests for GeometricMean', () => {
+  it('should be a function', () => {
+    expect(typeof geometricMean).toEqual('function')
+  })
+
+  it('should throw error for invalid input', () => {
+    expect(() => geometricMean([])).toThrow()
+  })
+
+  it('should throw error for invalid input (negative numbers)', () => {
+    expect(() => geometricMean([1, -3, 4, -7])).toThrow()
+  })
+
+  it('should return 0 if 0 is in array', () => {
+    const meanFunction = geometricMean([4, 8, 16, -3, 0])
+    expect(meanFunction).toBe(0)
+  })
+
+  it('should return the geometric mean of an array of numbers', () => {
+    const meanFunction = geometricMean([4, 8, 16])
+    expect(meanFunction).toBe(8)
+  })
+
+  it('should return the geometric mean of an array of decimal numbers', () => {
+    const meanFunction = geometricMean([1.2, 3.4, 5])
+    expect(meanFunction).toBe(2.7323944160944684)
+  })
+})

maths/test/hexagon_area.test.ts

@@ -0,0 +1,25 @@
+import { hexArea } from '../hexagon_area'
+
+describe('Tests for HexArea', () => {
+  it('should be a function', () => {
+    expect(typeof hexArea).toEqual('function')
+  })
+
+  it('should throw error for invalid input', () => {
+    expect(() => hexArea(0)).toThrow()
+  })
+
+  it('should throw error for invalid input', () => {
+    expect(() => hexArea(-1)).toThrow()
+  })
+
+  it('should return if hexagon area', () => {
+    const hexFunction = hexArea(3)
+    expect(hexFunction).toBe(23.382685902179844)
+  })
+
+  it('should return if hexagon area', () => {
+    const hexFunction = hexArea(10)
+    expect(hexFunction).toBe(259.8076211353316)
+  })
+})

maths/test/octagon_area.test.ts

@@ -0,0 +1,25 @@
+import { octArea } from '../octagon_area'
+
+describe('Tests for HexArea', () => {
+  it('should be a function', () => {
+    expect(typeof octArea).toEqual('function')
+  })
+
+  it('should throw error for invalid input', () => {
+    expect(() => octArea(0)).toThrow()
+  })
+
+  it('should throw error for invalid input', () => {
+    expect(() => octArea(-1)).toThrow()
+  })
+
+  it('should return octagon area', () => {
+    const octFunction = octArea(3)
+    expect(octFunction).toBe(43.45584412271571)
+  })
+
+  it('should return if octagon area', () => {
+    const octFunction = octArea(10)
+    expect(octFunction).toBe(482.84271247461896)
+  })
+})

maths/test/pentagon_area.test.ts

@@ -0,0 +1,25 @@
+import { pentArea } from '../pentagon_area'
+
+describe('Tests for HexArea', () => {
+  it('should be a function', () => {
+    expect(typeof pentArea).toEqual('function')
+  })
+
+  it('should throw error for invalid input', () => {
+    expect(() => pentArea(0)).toThrow()
+  })
+
+  it('should throw error for invalid input', () => {
+    expect(() => pentArea(-1)).toThrow()
+  })
+
+  it('should return if pentagon area', () => {
+    const pentFunction = pentArea(5)
+    expect(pentFunction).toBe(43.01193501472417)
+  })
+
+  it('should return if pentagon area', () => {
+    const pentFunction = pentArea(15)
+    expect(pentFunction).toBe(387.10741513251753)
+  })
+})