The absolute difference:

$$\forall x, y \in \mathbb{R}, \; |x - y| \in \mathbb{R}_{+}.$$

The function takes two inputs $x$ and $y$ and returns a positive float value which is the absolute difference of the inputs.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.absolute_difference(-10.0, 10.0)
  |> should.equal(20.0)

  maths.absolute_difference(0.0, -2.0)
  |> should.equal(2.0)
}

The inverse cosine function:

$$\forall x \in [-1, 1], \; \cos^{-1}{(x)} = y \in [0, \pi ]$$

The function takes a number $x$ in its domain $[-1, 1]$ as input and returns a numeric value $y$ that lies in the range $[0, \pi ]$ (an angle in radians). If the input value is outside the domain of the function an error is returned.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.acos(1.0)
  |> should.equal(Ok(0.0))

  maths.acos(1.1)
  |> should.be_error()

  maths.acos(-1.1)
  |> should.be_error()
}

The inverse hyperbolic cosine function:

$$\forall x \in [1, +\infty), \; \cosh^{-1}{(x)} = y \in [0, +\infty)$$

The function takes a number $x$ in its domain $[1, +\infty)$ as input and returns a numeric value $y$ that lies in the range $[0, +\infty)$ (an angle in radians). If the input value is outside the domain of the function an error is returned.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.acosh(1.0)
  |> should.equal(Ok(0.0))

  maths.acosh(0.0)
  |> should.be_error()
}

Determine if each value $x_i$ is close to or equivalent to its corresponding reference value $y_i$, in a list of value pairs $(x_i, y_i)$, based on supplied relative $r_{tol}$ and absolute $a_{tol}$ tolerance values. The equivalence of each pair $(x_i, y_i)$ is determined by the equation:

$$|x_i - y_i| \leq (a_{tol} + r_{tol} \cdot |y_i|), \; \forall i=1,…,n.$$

A list of Bool values is returned, where each entry indicates if the corresponding pair satisfies the condition. If all conditions are satisfied, the list will contain only True values.

import gleam/list
import gleeunit/should
import gleam_community/maths

pub fn example () {
  let value = 99.0
  let reference_value = 100.0
  let xarr = list.repeat(value, 42)
  let yarr = list.repeat(reference_value, 42)
  let arr = list.zip(xarr, yarr)
  // We set 'absolute_tolerance' and 'relative_tolerance' such that
  // the values are equivalent if 'value' is within 1 percent of
  // 'reference_value' +/- 0.1
  let relative_tolerance = 0.01
  let absolute_tolerance = 0.1
  let assert Ok(result) =
    maths.all_close(arr, relative_tolerance, absolute_tolerance)
  result
  |> list.all(fn(x) { x == True })
  |> should.be_true()
}

Returns the indices of the maximum values in a given list.

import gleam/float
import gleeunit/should
import gleam_community/maths

pub fn example () {
  []
  |> maths.arg_maximum(float.compare)
  |> should.be_error()

  [4.0, 4.0, 3.0, 2.0, 1.0]
  |> maths.arg_maximum(float.compare)
  |> should.equal(Ok([0, 1]))
}

Returns the indices of the minimum values in a given list.

import gleam/float
import gleeunit/should
import gleam_community/maths

pub fn example () {
  []
  |> maths.arg_minimum(float.compare)
  |> should.be_error()

  [4.0, 4.0, 3.0, 2.0, 1.0]
  |> maths.arg_minimum(float.compare)
  |> should.equal(Ok([4]))
}

The inverse sine function:

$$\forall x \in [-1, 1], \; \sin^{-1}{(x)} = y \in (-\infty, +\infty)$$

The function takes a number $x$ in its domain $[-1, 1]$ as input and returns a numeric value $y$ that lies in the range $[-\frac{\pi}{2}, \frac{\pi}{2}]$ (an angle in radians). If the input value is outside the domain of the function an error is returned.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.asin(0.0)
  |> should.equal(Ok(0.0))

  maths.asin(1.1)
  |> should.be_error()

  maths.asin(-1.1)
  |> should.be_error()
}

The inverse hyperbolic sine function:

$$\forall x \in (-\infty, \infty), \; \sinh^{-1}{(x)} = y \in (-\infty, +\infty)$$

The function takes a number $x$ in its domain $(-\infty, +\infty)$ as input and returns a numeric value $y$ that lies in the range $(-\infty, +\infty)$ (an angle in radians).

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.asinh(0.0)
  |> should.equal(0.0)
}

The inverse tangent function:

$$\forall x \in (-\infty, \infty), \; \tan^{-1}{(x)} = y \in [-\frac{\pi}{2}, \frac{\pi}{2}]$$

The function takes a number $x$ in its domain $(-\infty, +\infty)$ as input and returns a numeric value $y$ that lies in the range $[-\frac{\pi}{2}, \frac{\pi}{2}]$ (an angle in radians).

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.atan(0.0)
  |> should.equal(0.0)
}

The inverse 2-argument tangent function:

$$\text{atan2}(y, x) = \begin{cases} \tan^{-1}(\frac y x) &\text{if } x > 0, \\ \tan^{-1}(\frac y x) + \pi &\text{if } x < 0 \text{ and } y \ge 0, \\ \tan^{-1}(\frac y x) - \pi &\text{if } x < 0 \text{ and } y < 0, \\ +\frac{\pi}{2} &\text{if } x = 0 \text{ and } y > 0, \\ -\frac{\pi}{2} &\text{if } x = 0 \text{ and } y < 0, \\ \text{undefined} &\text{if } x = 0 \text{ and } y = 0. \end{cases}$$

The function returns the angle in radians from the x-axis to the line containing the origin $(0, 0)$ and a point given as input with coordinates $(x, y)$. The numeric value returned by $\text{atan2}(y, x)$ is in the range $[-\pi, \pi]$.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.atan2(0.0, 0.0)
  |> should.equal(0.0)
}

The inverse hyperbolic tangent function:

$$\forall x \in (-1, 1), \; \tanh^{-1}{(x)} = y \in (-\infty, +\infty)$$

The function takes a number $x$ in its domain $(-1, 1)$ as input and returns a numeric value $y$ that lies in the range $(-\infty, \infty)$ (an angle in radians). If the input value is outside the domain of the function an error is returned.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.atanh(0.0)
  |> should.equal(Ok(0.0))

  maths.atanh(1.0)
  |> should.be_error()

  maths.atanh(-1.0)
  |> should.be_error()
}

The beta function over the real numbers:

$$\text{B}(x, y) = \frac{\Gamma(x) \cdot \Gamma(y)}{\Gamma(x + y)}$$

The beta function is evaluated through the use of the gamma function.

Calculate the Bray-Curtis distance between two lists:

$$\frac{\sum_{i=1}^n \left| x_i - y_i \right|} {\sum_{i=1}^n \left| x_i + y_i \right|}$$

In the formula, $n$ is the length of the two lists, and $x_i, y_i$ are the values in the respective input lists indexed by $i$.

The Bray-Curtis distance is in the range $[0, 1]$ if all entries $x_i, y_i$ are positive.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.braycurtis_distance([])
  |> should.be_error()

  maths.braycurtis_distance([#(1.0, 3.0), #(2.0, 4.0)])
  |> should.equal(Ok(0.4))
}

Calculate the weighted Bray-Curtis distance between two lists:

$$\frac{\sum_{i=1}^n w_{i} \left| x_i - y_i \right|} {\sum_{i=1}^n w_{i}\left| x_i + y_i \right|}$$

In the formula, $n$ is the length of the two lists, and $x_i, y_i$ are the values in the respective input lists indexed by $i$, while the $w_i \in \mathbb{R}_{+}$ are corresponding positive weights.

The Bray-Curtis distance is in the range $[0, 1]$ if all entries $x_i, y_i$ are positive and $w_i = 1.0\;\forall i=1…n$.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.braycurtis_distance_with_weights([])
  |> should.be_error()

  maths.braycurtis_distance_with_weights([#(1.0, 3.0, 0.5), #(2.0, 4.0, 1.0)])
  |> should.equal(Ok(0.375))
}

Calculate the Canberra distance between two lists:

$$\sum_{i=1}^n \frac{\left| x_i - y_i \right|} {\left| x_i \right| + \left| y_i \right|}$$

In the formula, $n$ is the length of the two lists, and $x_i, y_i$ are the values in the respective input lists indexed by $i$.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.canberra_distance([])
  |> should.be_error()

  maths.canberra_distance([#(1.0, -2.0), #(2.0, -1.0)])
  |> should.equal(Ok(2.0))
}

Calculate the weighted Canberra distance between two lists:

$$\sum_{i=1}^n w_{i}\frac{\left| x_i - y_i \right|} {\left| x_i \right| + \left| y_i \right|}$$

In the formula, $n$ is the length of the two lists, and $x_i, y_i$ are the values in the respective input lists indexed by $i$, while the $w_i \in \mathbb{R}_{+}$ are corresponding positive weights.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.canberra_distance_with_weights([])
  |> should.be_error()

  maths.canberra_distance_with_weights([#(1.0, -2.0, 0.5), #(2.0, -1.0, 1.0)])
  |> should.equal(Ok(1.5))
}

Generate a set containing all combinations of pairs of elements coming from two given sets.

import gleam/set
import gleeunit/should
import gleam_community/maths

pub fn example () {
  set.from_list([])
  |> maths.cartesian_product(set.from_list([]))
  |> should.equal(set.from_list([]))

  set.from_list([1.0, 10.0])
  |> maths.cartesian_product(set.from_list([1.0, 2.0]))
  |> should.equal(
    set.from_list([#(1.0, 1.0), #(1.0, 2.0), #(10.0, 1.0), #(10.0, 2.0)]),
  )
}

Converts Cartesian coordinates $(x, y)$ to polar coordinates $(r, \theta)$.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.cartesian_to_polar(1.0, 0.0)
  |> should.equal((1.0, 0.0))

  maths.cartesian_to_polar(0.0, 1.0)
  |> should.equal((1.0, float.pi() /. 2.0))
}

Calculate the Chebyshev distance between two lists (representing vectors):

$$\text{max}_{i=1}^n \left|x_i - y_i \right|$$

In the formula, $n$ is the length of the two lists and $x_i, y_i$ are the values in the respective input lists indexed by $i$.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.chebyshev_distance([#(-5.0, -1.0), #(-10.0, -12.0), #(-3.0, -3.0)])
  |> should.equal(Ok(4.0))
}

Calculate the weighted Chebyshev distance between two lists (representing vectors):

$$\text{max}_{i=1}^n w_i \left|x_i - y_i \right|$$

In the formula, $n$ is the length of the two lists and $x_i, y_i$ are the values in the respective input lists indexed by $i$, while the $w_i \in \mathbb{R}_{+}$ are corresponding positive weights.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.chebyshev_distance_with_weights([
    #(-5.0, -1.0, 0.5),
    #(-10.0, -12.0, 1.0),
    #(-3.0, -3.0, 1.0),
  ])
  |> should.equal(Ok(2.0))
}

A combinatorial function for computing the number of $k$-combinations of $n$ elements without repetitions:

$$C(n, k) = \binom{n}{k} = \frac{n!}{k! (n-k)!}$$

Also known as “$n$ choose $k$” or the binomial coefficient.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.combination(-1, 1)
  |> should.be_error()

  maths.combination(4, 0)
  |> should.equal(Ok(1))

  maths.combination(4, 4)
  |> should.equal(Ok(1))

  maths.combination(13, 5)
  |> should.equal(Ok(1287))
}

A combinatorial function for computing the number of $k$-combinations of $n$ elements with repetitions:

$$C^*(n, k) = \binom{n + k - 1}{k} = \frac{(n + k - 1)!}{k! (n - 1)!}$$

Also known as the “stars and bars” problem in maths. Furthermore, the implementation uses an efficient iterative multiplicative formula for computing the result.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.combination_with_repetitions(-1, 1)
  |> should.be_error()

  maths.combination_with_repetitions(2, 3)
  |> should.equal(Ok(4))

  maths.combination_with_repetitions(13, 5)
  |> should.equal(Ok(6188))
}

The function takes two arguments $x, y \in \mathbb{R}$ and returns $x$ such that it has the same sign as $y$.

Calculate Pearson’s sample correlation coefficient to determine the linear relationship between the elements in two lists of equal length. The correlation coefficient $r_{xy} \in [-1, 1]$ is calculated as:

$$r_{xy} =\frac{\sum ^n _{i=1}(x_i - \bar{x})(y_i - \bar{y})}{\sqrt{\sum^n _{i=1}(x_i - \bar{x})^2} \sqrt{\sum^n _{i=1}(y_i - \bar{y})^2}}$$

In the formula, $n$ is the sample size (the length of the input lists), $x_i$, $y_i$ are the corresponding sample points indexed by $i$ and $\bar{x}$, $\bar{y}$ are the sample means.

import gleeunit/should
import gleam_community/maths

pub fn example () {
  // An empty lists returns an error
  maths.correlation([], [])
  |> should.be_error()

  // Perfect positive correlation
  let xarr =
    list.range(0, 100)
    |> list.map(fn(x) { int.to_float(x) })
  let yarr =
    list.range(0, 100)
    |> list.map(fn(y) { int.to_float(y) })
  list.zip(xarr, yarr)
  |> maths.correlation()
  |> should.equal(Ok(1.0))

  // Perfect negative correlation
  let xarr =
    list.range(0, 100)
    |> list.map(fn(x) { -1.0 *. int.to_float(x) })
  let yarr =
    list.range(0, 100)
    |> list.map(fn(y) { int.to_float(y) })
  list.zip(xarr, yarr)
  |> maths.correlation()
  |> should.equal(Ok(-1.0))

  // No correlation (independent variables)
  let xarr = [1.0, 2.0, 3.0, 4.0]
  let yarr = [5.0, 5.0, 5.0, 5.0]
  list.zip(xarr, yarr)
  |> maths.correlation()
  |> should.equal(Ok(0.0))
}

The cosine function:

$$\forall x \in (-\infty, +\infty), \; \cos{(x)} = y \in [-1, 1]$$

The function takes a number $x$ in its domain $(-\infty, \infty)$ (an angle in radians) as input and returns a numeric value $y$ that lies in the range $[-1, 1]$.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.cos(0.0)
  |> should.equal(1.0)

  maths.cos(maths.pi())
  |> should.equal(-1.0)
}

The hyperbolic cosine function:

$$\forall x \in (-\infty, \infty), \; \cosh{(x)} = y \in (-\infty, +\infty)$$

The function takes a number $x$ in its domain $(-\infty, \infty)$ as input (an angle in radians) and returns a numeric value $y$ that lies in the range $(-\infty, \infty)$. If the input value is too large an overflow error might occur.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.cosh(0.0)
  |> should.equal(0.0)
}

Calculate the cosine similarity between two lists (representing vectors):

$$\frac{\sum_{i=1}^n x_i \cdot y_i} {\left(\sum_{i=1}^n x_i^2\right)^{\frac{1}{2}} \cdot \left(\sum_{i=1}^n y_i^2\right)^{\frac{1}{2}}} \; \in \; \left[-1, 1\right]$$

In the formula, $n$ is the length of the two lists and $x_i$, $y_i$ are the values in the respective input lists indexed by $i$.

The cosine similarity provides a value between -1 and 1, where 1 means the vectors are in the same direction, -1 means they are in exactly opposite directions, and 0 indicates orthogonality.

import gleam/option
import gleeunit/should
import gleam_community/maths

pub fn example() {
  // Two orthogonal vectors
  maths.cosine_similarity([#(-1.0, 1.0), #(1.0, 1.0), #(0.0, -1.0)])
  |> should.equal(Ok(0.0))

  // Two identical (parallel) vectors
  maths.cosine_similarity([#(1.0, 1.0), #(2.0, 2.0), #(3.0, 3.0)])
  |> should.equal(Ok(1.0))

  // Two parallel, but oppositely oriented vectors
  maths.cosine_similarity([#(-1.0, 1.0), #(-2.0, 2.0), #(-3.0, 3.0)])
  |> should.equal(Ok(-1.0))
}

Calculate the weighted cosine similarity between two lists (representing vectors):

$$\frac{\sum_{i=1}^n w_{i} \cdot x_i \cdot y_i} {\left(\sum_{i=1}^n w_{i} \cdot x_i^2\right)^{\frac{1}{2}} \cdot \left(\sum_{i=1}^n w_{i} \cdot y_i^2\right)^{\frac{1}{2}}} \; \in \; \left[-1, 1\right]$$

In the formula, $n$ is the length of the two lists and $x_i$, $y_i$ are the values in the respective input lists indexed by $i$, while the $w_i \in \mathbb{R}_{+}$ are corresponding positive weights.

The cosine similarity provides a value between -1 and 1, where 1 means the vectors are in the same direction, -1 means they are in exactly opposite directions, and 0 indicates orthogonality.

import gleam/option
import gleeunit/should
import gleam_community/maths

pub fn example() {
  let assert Ok(tolerance) = float.power(10.0, -6.0)

  let assert Ok(result) =
    maths.cosine_similarity_with_weights([
      #(1.0, 1.0, 2.0),
      #(2.0, 2.0, 3.0),
      #(3.0, 3.0, 4.0),
    ])
  result
  |> maths.is_close(1.0, 0.0, tolerance)
  |> should.be_true()

  let assert Ok(result) =
    maths.cosine_similarity_with_weights([
      #(-1.0, 1.0, 1.0),
      #(-2.0, 2.0, 0.5),
      #(-3.0, 3.0, 0.33),
    ])
  result
  |> maths.is_close(-1.0, 0.0, tolerance)
  |> should.be_true()
}

Calculate the cumulative product of the elements in a list:

$$v_j = \prod_{i=1}^j x_i \;\; \forall j = 1,\dots, n$$

In the formula, $v_j$ is the $j$’th element in the cumulative product of $n$ elements. That is, $n$ is the length of the list and $x_i \in \mathbb{R}$ is the value in the input list indexed by $i$. The value $v_j$ is thus the sum of the $1$ to $j$ first elements in the given list.

import gleeunit/should
import gleam_community/maths

pub fn example () {
  []
  |> maths.cumulative_product()
  |> should.equal([])

  [1.0, 2.0, 3.0]
  |> maths.cumulative_product()
  |> should.equal([1.0, 2.0, 6.0])
}

Calculate the cumulative sum of the elements in a list:

$$v_j = \sum_{i=1}^j x_i \;\; \forall j = 1,\dots, n$$

In the formula, $v_j$ is the $j$’th element in the cumulative sum of $n$ elements. That is, $n$ is the length of the list and $x_i \in \mathbb{R}$ is the value in the input list indexed by $i$. The value $v_j$ is thus the sum of the $1$ to $j$ first elements in the given list.

import gleeunit/should
import gleam_community/maths

pub fn example () {
  []
  |> maths.cumulative_sum()
  |> should.equal([])

  [1.0, 2.0, 3.0]
  |> maths.cumulative_sum()
  |> should.equal([1.0, 3.0, 6.0])
}

Convert a value in degrees to a value measured in radians. That is, $1 \text{ degrees } = \frac{\pi}{180} \text{ radians }$.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.degrees_to_radians(360.)
  |> should.equal(2. *. maths.pi())
}

The function returns all the positive divisors of an integer, including the number itself.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.divisors(4)
  |> should.equal([1, 2, 4])

  maths.divisors(6)
  |> should.equal([1, 2, 3, 6])

  maths.divisors(13)
  |> should.equal([1, 13])
}

Euler’s number $e \approx 2.71828\dots$.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  let assert Ok(tolerance) = float.power(10.0, -6.0)

  // Test that the constant is approximately equal to 2.7128...
  maths.e()
  |> maths.is_close(2.7182818284590452353602, 0.0, tolerance)
  |> should.be_true()
}

The error function.

Calculate the Euclidean distance between two lists (representing vectors):

$$\left( \sum_{i=1}^n \left|x_i - y_i \right|^{2} \right)^{\frac{1}{2}}$$

In the formula, $n$ is the length of the two lists and $x_i, y_i$ are the values in the respective input lists indexed by $i$.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  let assert Ok(tolerance) = float.power(10.0, -6.0)

  let assert Ok(result) = maths.euclidean_distance([#(1.0, 2.0), #(3.0, 4.0)])
  result
  |> maths.is_close(1.4142135623730951, 0.0, tolerance)
  |> should.be_true()
}

Calculate the weighted Euclidean distance between two lists (representing vectors):

$$\left( \sum_{i=1}^n w_{i} \left|x_i - y_i \right|^{2} \right)^{\frac{1}{2}}$$

In the formula, $n$ is the length of the two lists and $x_i, y_i$ are the values in the respective input lists indexed by $i$, while the $w_i \in \mathbb{R}_{+}$ are corresponding positive weights.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  let assert Ok(tolerance) = float.power(10.0, -6.0)

  let assert Ok(result) =
    maths.euclidean_distance_with_weights([#(1.0, 2.0, 0.5), #(3.0, 4.0, 1.0)])
  result
  |> maths.is_close(1.224744871391589, 0.0, tolerance)
  |> should.be_true()
}

Given two integers, $x$ (dividend) and $y$ (divisor), the Euclidean modulo of $x$ by $y$, denoted as $x \mod y$, is the remainder $r$ of the division of $x$ by $y$, such that:

$$x = q \cdot y + r \quad \text{and} \quad 0 \leq r < |y|,$$

where $q$ is an integer that represents the quotient of the division.

Note that like the Gleam division operator / this will return 0 if one of the arguments is 0.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.euclidean_modulo(15, 4)
  |> should.equal(3)

  maths.euclidean_modulo(-3, -2)
  |> should.equal(1)

  maths.euclidean_modulo(5, 0)
  |> should.equal(0)
}

The exponential function:

$$\forall x \in (-\infty, \infty), \; e^{x} = y \in (0, +\infty)$$

where $e \approx 2.71828\dots$ is Eulers’ number.

Note: If the input value $x$ is too large an overflow error might occur.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.exponential(0.0)
  |> should.equal(1.0)
}

Returns a tuple consisting of the minimum and maximum values of a given list.

import gleam/float
import gleeunit/should
import gleam_community/maths

pub fn example () {
  []
  |> maths.extrema(float.compare)
  |> should.be_error()

  [4.0, 4.0, 3.0, 2.0, 1.0]
  |> maths.extrema(float.compare)
  |> should.equal(Ok(#(1.0, 4.0)))
}

A combinatorial function for computing the total number of combinations of $n$ elements, that is $n!$.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.factorial(-1)
  |> should.be_error()

  maths.factorial(0)
  |> should.equal(Ok(1))

  maths.factorial(3)
  |> should.equal(Ok(6))
}

The function flips the sign of a given input value $x \in \mathbb{R}$.

The gamma function over the real numbers. The function is essentially equal to the factorial for any positive integer argument: $\Gamma(n) = (n - 1)!$

The implemented gamma function is approximated through Lanczos approximation using the same coefficients used by the GNU Scientific Library.

The function calculates the greatest common divisor of two integers $x, y \in \mathbb{Z}$. The greatest common divisor is the largest positive integer that is divisible by both $x$ and $y$.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.gcd(1, 1)
  |> should.equal(1)

  maths.gcd(100, 10)
  |> should.equal(10)

  maths.gcd(-36, -17)
  |> should.equal(1)
}

Calculate the geometric mean $\bar{x}$ of the elements in a list:

$$\bar{x} = \left(\prod^{n}_{i=1} x_i\right)^{\frac{1}{n}}$$

In the formula, $n$ is the sample size (the length of the list) and $x_i$ is the sample point in the input list indexed by $i$. Note: The geometric mean is only defined for positive numbers.

import gleeunit/should
import gleam_community/maths

pub fn example () {
  // An empty list returns an error
  []
  |> maths.geometric_mean()
  |> should.be_error()

  // List with negative numbers returns an error
  [-1.0, -3.0, -6.0]
  |> maths.geometric_mean()
  |> should.be_error()

  // Valid input returns a result
  [1.0, 3.0, 9.0]
  |> maths.geometric_mean()
  |> should.equal(Ok(3.0))
}

The function returns a list of a geometric progression between two specified values, where each value is a constant multiple of the previous one. Unlike logarithmic_space, this function allows specifying the starting and ending values (start and stop) directly, without requiring them to be transformed into exponents.

Internally, the function computes the logarithms of start and stop and generates evenly spaced points in the logarithmic domain (using base 10). These points are then transformed back into their original scale to create a sequence of values that grow multiplicatively.

The start and stop values must be positive, as logarithms are undefined for non-positive values. The number of points (steps) must also be positive; specifying zero or a negative value will result in an error.

import gleam/yielder
import gleeunit/should
import gleam_community/maths

pub fn example () {
  let assert Ok(tolerance) = float.power(10.0, -6.0)
  let assert Ok(logspace) = maths.geometric_space(10.0, 1000.0, 3, True)
  let pairs = logspace |> list.zip([10.0, 100.0, 1000.0])
  let assert Ok(result) = maths.all_close(pairs, 0.0, tolerance)
  result
  |> list.all(fn(x) { x == True })
  |> should.be_true()

  // Input (start and stop can't be less than or equal to 0.0)
  maths.geometric_space(0.0, 1000.0, 3, False)
  |> should.be_error()

  maths.geometric_space(-1000.0, 0.0, 3, False)
  |> should.be_error()

  // A negative number of points (-3) does not work
  maths.geometric_space(10.0, 1000.0, -3, False)
  |> should.be_error()
}

The golden ratio: $\phi = \frac{1 + \sqrt{5}}{2}$.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.golden_ratio()
  |> should.equal(1.618033988749895)
}

Calculate the harmonic mean $\bar{x}$ of the elements in a list:

$$\bar{x} = \frac{n}{\sum_{i=1}^{n}\frac{1}{x_i}}$$

In the formula, $n$ is the sample size (the length of the list) and $x_i$ is the sample point in the input list indexed by $i$. Note: The harmonic mean is only defined for positive numbers.

import gleeunit/should
import gleam_community/maths

pub fn example () {
  // An empty list returns an error
  []
  |> maths.harmonic_mean()
  |> should.be_error()

  // List with negative numbers returns an error
  [-1.0, -3.0, -6.0]
  |> maths.harmonic_mean()
  |> should.be_error()

  // Valid input returns a result
  [1.0, 3.0, 6.0]
  |> maths.harmonic_mean()
  |> should.equal(Ok(2.0))
}

The lower incomplete gamma function over the real numbers.

The implemented incomplete gamma function is evaluated through a power series expansion.

The absolute difference:

$$\forall x, y \in \mathbb{Z}, \; |x - y| \in \mathbb{Z}_{+}.$$

The function takes two inputs $x$ and $y$ and returns a positive integer value which is the absolute difference of the inputs.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.absolute_difference(-10, 10)
  |> should.equal(20)

  maths.absolute_difference(0, -2)
  |> should.equal(2)
}

The function takes two arguments $x, y \in \mathbb{Z}$ and returns $x$ such that it has the same sign as $y$.

Calculate the cumulative product of the elements in a list:

$$v_j = \prod_{i=1}^j x_i \;\; \forall j = 1,\dots, n$$

In the formula, $v_j$ is the $j$’th element in the cumulative product of $n$ elements. That is, $n$ is the length of the list and $x_i \in \mathbb{Z}$ is the value in the input list indexed by $i$. The value $v_j$ is thus the product of the $1$ to $j$ first elements in the given list.

import gleeunit/should
import gleam_community/maths

pub fn example () {
  []
  |> maths.int_cumulative_product()
  |> should.equal([])

  [1, 2, 3]
  |> maths.int_cumulative_product()
  |> should.equal([1, 2, 6])
}

Calculate the cumulative sum of the elements in a list:

$$v_j = \sum_{i=1}^j x_i \;\; \forall j = 1,\dots, n$$

In the formula, $v_j$ is the $j$’th element in the cumulative sum of $n$ elements. That is, $n$ is the length of the list and $x_i \in \mathbb{Z}$ is the value in the input list indexed by $i$. The value $v_j$ is thus the sum of the $1$ to $j$ first elements in the given list.

import gleeunit/should
import gleam_community/maths

pub fn example () {
  []
  |> maths.int_cumulative_sum()
  |> should.equal([])

  [1, 2, 3]
  |> maths.int_cumulative_sum()
  |> should.equal([1, 3, 6])
}

The function flips the sign of a given input value $x \in \mathbb{Z}$.

The function takes an input $x \in \mathbb{Z}$ and returns the sign of the input, indicating whether it is positive (+1), negative (-1), or zero (0).

Calculate the interquartile range (IQR) of the elements in a list.

import gleeunit/should
import gleam_community/maths

pub fn example () {
  // An empty list returns an error
  []
  |> maths.interquartile_range()
  |> should.be_error()

  // Valid input returns a result
  [1.0, 2.0, 3.0, 4.0, 5.0]
  |> maths.interquartile_range()
  |> should.equal(Ok(3.0))
}

A function that tests whether a given real number $x \in \mathbb{R}$ is strictly between two other real numbers, $a,b \in \mathbb{R}$, such that $a < x < b$.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.is_between(5.5, 5.0, 6.0)
  |> should.equal(True)

  maths.is_between(5.0, 5.0, 6.0)
  |> should.equal(False)

  maths.is_between(6.0, 5.0, 6.0)
  |> should.equal(False)
}

Determine if a given value $x$ is close to or equivalent to a reference value $y$ based on supplied relative $r_{tol}$ and absolute $a_{tol}$ tolerance values. The equivalance of the two given values are then determined based on the equation:

$$|x - y| \leq (a_{tol} + r_{tol} \cdot |y|)$$

True is returned if the statement holds, otherwise False is returned.

import gleeunit/should
import gleam_community/maths

pub fn example () {
  let value = 99.
  let reference_value = 100.
  // We set 'absolute_tolerance' and 'relative_tolerance' such that the values are
  // equivalent if 'value' is within 1 percent of 'reference_value' +/- 0.1
  let relative_tolerance = 0.01
  let absolute_tolerance = 0.10
  maths.is_close(value, reference_value, relative_tolerance, absolute_tolerance)
  |> should.be_true()
}

A function that tests whether a given integer $n \in \mathbb{Z}$ is divisible by another integer $d \in \mathbb{Z}$, such that $n \mod d = 0$.

import gleeunit/should
import gleam_community/maths

pub fn example() {
  maths.is_divisible(10, 2)
  |> should.equal(True)

  maths.is_divisible(7, 3)
  |> should.equal(False)
}

Determine if a given value $x$ is fractional, i.e., if it contains a fractional part:

$$x - \lfloor x \rfloor > 0$$

True is returned if the given value is fractional (i.e., it has a non-zero decimal part), otherwise False is returned.

import gleeunit/should
import gleam_community/maths

pub fn example () {
  maths.is_fractional(0.3333)
  |> should.equal(True)

  maths.is_fractional(1.0)
  |> should.equal(False)
}

A function that tests whether a given integer $m \in \mathbb{Z}$ is a multiple of another integer $k \in \mathbb{Z}$, such that $m = k \cdot q$, with $q \in \mathbb{Z}$.