diff --git a/src/gleam_community/maths/arithmetics.gleam b/src/gleam_community/maths/arithmetics.gleam
index a238abc..a205116 100644
--- a/src/gleam_community/maths/arithmetics.gleam
+++ b/src/gleam_community/maths/arithmetics.gleam
@@ -1,6 +1,6 @@
-////<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/katex.min.css" integrity="sha384-GvrOXuhMATgEsSwCs4smul74iXGOixntILdUW9XmUC6+HX0sLNAK3q71HotJqlAn" crossorigin="anonymous">
-////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/katex.min.js" integrity="sha384-cpW21h6RZv/phavutF+AuVYrr+dA8xD9zs6FwLpaCct6O9ctzYFfFr4dgmgccOTx" crossorigin="anonymous"></script>
-////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/contrib/auto-render.min.js" integrity="sha384-+VBxd3r6XgURycqtZ117nYw44OOcIax56Z4dCRWbxyPt0Koah1uHoK0o4+/RRE05" crossorigin="anonymous"></script>
+////<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/katex.min.css" integrity="sha384-wcIxkf4k558AjM3Yz3BBFQUbk/zgIYC2R0QpeeYb+TwlBVMrlgLqwRjRtGZiK7ww" crossorigin="anonymous">
+////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/katex.min.js" integrity="sha384-hIoBPJpTUs74ddyc4bFZSM1TVlQDA60VBbJS0oA934VSz82sBx1X7kSx2ATBDIyd" crossorigin="anonymous"></script>
+////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/contrib/auto-render.min.js" integrity="sha384-43gviWU0YVjaDtb/GhzOouOXtZMP/7XUzwPTstBeZFe/+rCMvRwr4yROQP43s0Xk" crossorigin="anonymous"></script>
 ////<script>
 ////    document.addEventListener("DOMContentLoaded", function() {
 ////        renderMathInElement(document.body, {
@@ -44,6 +44,9 @@
 
 import gleam/int
 import gleam/list
+import gleam/option
+import gleam/pair
+import gleam/result
 import gleam_community/maths/conversion
 import gleam_community/maths/elementary
 import gleam_community/maths/piecewise
@@ -54,8 +57,9 @@ import gleam_community/maths/piecewise
 ///     </a>
 /// </div>
 ///
-/// The function calculates the greatest common multiple of two integers $$x, y \in \mathbb{Z}$$.
-/// The greatest common multiple is the largest positive integer that is divisible by both $$x$$ and $$y$$.
+/// 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$$.
 ///
 /// <details>
 ///     <summary>Example:</summary>
@@ -64,10 +68,10 @@ import gleam_community/maths/piecewise
 ///     import gleam_community/maths/arithmetics
 ///
 ///     pub fn example() {
-///       arithmetics.lcm(1, 1)
+///       arithmetics.gcd(1, 1)
 ///       |> should.equal(1)
 ///   
-///       arithmetics.lcm(100, 10)
+///       arithmetics.gcd(100, 10)
 ///       |> should.equal(10)
 ///
 ///       arithmetics.gcd(-36, -17)
@@ -104,8 +108,9 @@ fn do_gcd(x: Int, y: Int) -> Int {
 /// </div>
 ///
 /// 
-/// 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:
+/// 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|,
@@ -113,13 +118,15 @@ fn do_gcd(x: Int, y: Int) -> Int {
 /// 
 /// where $$q$$ is an integer that represents the quotient of the division.
 ///
-/// The Euclidean modulo function of two numbers, is the remainder operation most commonly utilized in 
-/// mathematics. This differs from the standard truncating modulo operation frequently employed in 
-/// programming via the `%` operator. Unlike the `%` operator, which may return negative results 
-/// depending on the divisor's sign, the Euclidean modulo function is designed to
-/// always yield a positive outcome, ensuring consistency with mathematical conventions.
+/// The Euclidean modulo function of two numbers, is the remainder operation most 
+/// commonly utilized in mathematics. This differs from the standard truncating 
+/// modulo operation frequently employed in programming via the `%` operator. 
+/// Unlike the `%` operator, which may return negative results depending on the 
+/// divisor's sign, the Euclidean modulo function is designed to always yield a 
+/// positive outcome, ensuring consistency with mathematical conventions.
 /// 
-/// Note that like the Gleam division operator `/` this will return `0` if one of the arguments is `0`.
+/// Note that like the Gleam division operator `/` this will return `0` if one of
+/// the arguments is `0`.
 ///
 ///
 /// <details>
@@ -161,8 +168,9 @@ pub fn int_euclidean_modulo(x: Int, y: Int) -> Int {
 ///     </a>
 /// </div>
 ///
-/// The function calculates the least common multiple of two integers $$x, y \in \mathbb{Z}$$.
-/// The least common multiple is the smallest positive integer that has both $$x$$ and $$y$$ as factors.
+/// The function calculates the least common multiple of two integers 
+/// $$x, y \in \mathbb{Z}$$. The least common multiple is the smallest positive
+/// integer that has both $$x$$ and $$y$$ as factors.
 ///
 /// <details>
 ///     <summary>Example:</summary>
@@ -200,7 +208,8 @@ pub fn lcm(x: Int, y: Int) -> Int {
 ///     </a>
 /// </div>
 ///
-/// The function returns all the positive divisors of an integer, including the number iteself.
+/// The function returns all the positive divisors of an integer, including the 
+/// number itself.
 ///
 /// <details>
 ///     <summary>Example:</summary>
@@ -251,7 +260,8 @@ fn find_divisors(n: Int) -> List(Int) {
 ///     </a>
 /// </div>
 ///
-/// The function returns all the positive divisors of an integer, excluding the number iteself.
+/// The function returns all the positive divisors of an integer, excluding the 
+/// number iteself.
 ///
 /// <details>
 ///     <summary>Example:</summary>
@@ -289,29 +299,32 @@ pub fn proper_divisors(n: Int) -> List(Int) {
 ///     </a>
 /// </div>
 ///
-/// Calculcate the sum of the elements in a list:
+/// Calculate the (weighted) sum of the elements in a list:
 ///
 /// \\[
-/// \sum_{i=1}^n x_i
+/// \sum_{i=1}^n w_i x_i
 /// \\]
 ///
-/// In the formula, $$n$$ is the length of the list and $$x_i \in \mathbb{R}$$ is the value in the input list indexed by $$i$$.
+/// In the formula, $$n$$ is the length of the list and $$x_i \in \mathbb{R}$$ is
+/// the value in the input list indexed by $$i$$, while the $$w_i \in \mathbb{R}$$
+/// are corresponding weights ($$w_i = 1.0\\;\forall i=1...n$$ by default).
 ///
 /// <details>
 ///     <summary>Example:</summary>
 ///
 ///     import gleeunit/should
+///     import gleam/option
 ///     import gleam_community/maths/arithmetics
 ///
 ///     pub fn example () {
 ///       // An empty list returns an error
 ///       []
-///       |> arithmetics.float_sum()
+///       |> arithmetics.float_sum(option.None)
 ///       |> should.equal(0.0)
 ///
 ///       // Valid input returns a result
 ///       [1.0, 2.0, 3.0]
-///       |> arithmetics.float_sum()
+///       |> arithmetics.float_sum(option.None)
 ///       |> should.equal(6.0)
 ///     }
 /// </details>
@@ -322,12 +335,18 @@ pub fn proper_divisors(n: Int) -> List(Int) {
 ///     </a>
 /// </div>
 ///
-pub fn float_sum(arr: List(Float)) -> Float {
-  case arr {
-    [] -> 0.0
-    _ ->
+pub fn float_sum(arr: List(Float), weights: option.Option(List(Float))) -> Float {
+  case arr, weights {
+    [], _ -> 0.0
+    _, option.None ->
       arr
       |> list.fold(0.0, fn(acc: Float, a: Float) -> Float { a +. acc })
+    _, option.Some(warr) -> {
+      list.zip(arr, warr)
+      |> list.fold(0.0, fn(acc: Float, a: #(Float, Float)) -> Float {
+        pair.first(a) *. pair.second(a) +. acc
+      })
+    }
   }
 }
 
@@ -337,13 +356,14 @@ pub fn float_sum(arr: List(Float)) -> Float {
 ///     </a>
 /// </div>
 ///
-/// Calculcate the sum of the elements in a list:
+/// Calculate the sum of the elements in a list:
 ///
 /// \\[
 /// \sum_{i=1}^n x_i
 /// \\]
 ///
-/// In the formula, $$n$$ is the length of the list and $$x_i \in \mathbb{Z}$$ is the value in the input list indexed by $$i$$.
+/// In the formula, $$n$$ is the length of the list and $$x_i \in \mathbb{Z}$$ is 
+/// the value in the input list indexed by $$i$$.
 ///
 /// <details>
 ///     <summary>Example:</summary>
@@ -385,29 +405,32 @@ pub fn int_sum(arr: List(Int)) -> Int {
 ///     </a>
 /// </div>
 ///
-/// Calculcate the product of the elements in a list:
+/// Calculate the (weighted) product of the elements in a list:
 ///
 /// \\[
-/// \prod_{i=1}^n x_i
+/// \prod_{i=1}^n x_i^{w_i}
 /// \\]
 ///
-/// In the formula, $$n$$ is the length of the list and $$x_i \in \mathbb{R}$$ is the value in the input list indexed by $$i$$.
-///
+/// In the formula, $$n$$ is the length of the list and $$x_i \in \mathbb{R}$$ is
+/// the value in the input list indexed by $$i$$, while the $$w_i \in \mathbb{R}$$
+/// are corresponding weights ($$w_i = 1.0\\;\forall i=1...n$$ by default).
+/// 
 /// <details>
 ///     <summary>Example:</summary>
 ///
 ///     import gleeunit/should
+///     import gleam/option
 ///     import gleam_community/maths/arithmetics
 ///
 ///     pub fn example () {
-///       // An empty list returns 0.0
+///       // An empty list returns 1.0
 ///       []
-///       |> arithmetics.float_product()
-///       |> should.equal(0.0)
+///       |> arithmetics.float_product(option.None)
+///       |> should.equal(1.0)
 ///
 ///       // Valid input returns a result
 ///       [1.0, 2.0, 3.0]
-///       |> arithmetics.float_product()
+///       |> arithmetics.float_product(option.None)
 ///       |> should.equal(6.0)
 ///     }
 /// </details>
@@ -418,12 +441,36 @@ pub fn int_sum(arr: List(Int)) -> Int {
 ///     </a>
 /// </div>
 ///
-pub fn float_product(arr: List(Float)) -> Float {
-  case arr {
-    [] -> 1.0
-    _ ->
+pub fn float_product(
+  arr: List(Float),
+  weights: option.Option(List(Float)),
+) -> Result(Float, String) {
+  case arr, weights {
+    [], _ ->
+      1.0
+      |> Ok
+    _, option.None ->
       arr
       |> list.fold(1.0, fn(acc: Float, a: Float) -> Float { a *. acc })
+      |> Ok
+    _, option.Some(warr) -> {
+      let results =
+        list.zip(arr, warr)
+        |> list.map(fn(a: #(Float, Float)) -> Result(Float, String) {
+          pair.first(a)
+          |> elementary.power(pair.second(a))
+        })
+        |> result.all
+      case results {
+        Ok(prods) ->
+          prods
+          |> list.fold(1.0, fn(acc: Float, a: Float) -> Float { a *. acc })
+          |> Ok
+        Error(msg) ->
+          msg
+          |> Error
+      }
+    }
   }
 }
 
@@ -433,13 +480,14 @@ pub fn float_product(arr: List(Float)) -> Float {
 ///     </a>
 /// </div>
 ///
-/// Calculcate the product of the elements in a list:
+/// Calculate the product of the elements in a list:
 ///
 /// \\[
 /// \prod_{i=1}^n x_i
 /// \\]
 ///
-/// In the formula, $$n$$ is the length of the list and $$x_i \in \mathbb{Z}$$ is the value in the input list indexed by $$i$$.
+/// In the formula, $$n$$ is the length of the list and $$x_i \in \mathbb{Z}$$ is 
+/// the value in the input list indexed by $$i$$.
 ///
 /// <details>
 ///     <summary>Example:</summary>
@@ -448,10 +496,10 @@ pub fn float_product(arr: List(Float)) -> Float {
 ///     import gleam_community/maths/arithmetics
 ///
 ///     pub fn example () {
-///       // An empty list returns 0
+///       // An empty list returns 1
 ///       []
 ///       |> arithmetics.int_product()
-///       |> should.equal(0)
+///       |> should.equal(1)
 ///
 ///       // Valid input returns a result
 ///       [1, 2, 3]
@@ -481,15 +529,16 @@ pub fn int_product(arr: List(Int)) -> Int {
 ///     </a>
 /// </div>
 ///
-/// Calculcate the cumulative sum of the elements in a list:
+/// 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.
+/// 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.
 ///
 /// <details>
 ///     <summary>Example:</summary>
@@ -530,15 +579,16 @@ pub fn float_cumulative_sum(arr: List(Float)) -> List(Float) {
 ///     </a>
 /// </div>
 ///
-/// Calculcate the cumulative sum of the elements in a list:
+/// 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.
+/// 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.
 ///
 /// <details>
 ///     <summary>Example:</summary>
@@ -579,15 +629,17 @@ pub fn int_cumulative_sum(arr: List(Int)) -> List(Int) {
 ///     </a>
 /// </div>
 ///
-/// Calculcate the cumulative product of the elements in a list:
+/// 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.
+/// 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.
 ///
 /// <details>
 ///     <summary>Example:</summary>
@@ -614,7 +666,7 @@ pub fn int_cumulative_sum(arr: List(Int)) -> List(Int) {
 ///     </a>
 /// </div>
 ///
-pub fn float_cumumlative_product(arr: List(Float)) -> List(Float) {
+pub fn float_cumulative_product(arr: List(Float)) -> List(Float) {
   case arr {
     [] -> []
     _ ->
@@ -629,15 +681,17 @@ pub fn float_cumumlative_product(arr: List(Float)) -> List(Float) {
 ///     </a>
 /// </div>
 ///
-/// Calculcate the cumulative product of the elements in a list:
+/// 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.
+/// 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.
 ///
 /// <details>
 ///     <summary>Example:</summary>
diff --git a/src/gleam_community/maths/combinatorics.gleam b/src/gleam_community/maths/combinatorics.gleam
index b16d0ad..f459ef6 100644
--- a/src/gleam_community/maths/combinatorics.gleam
+++ b/src/gleam_community/maths/combinatorics.gleam
@@ -1,6 +1,6 @@
-////<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/katex.min.css" integrity="sha384-GvrOXuhMATgEsSwCs4smul74iXGOixntILdUW9XmUC6+HX0sLNAK3q71HotJqlAn" crossorigin="anonymous">
-////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/katex.min.js" integrity="sha384-cpW21h6RZv/phavutF+AuVYrr+dA8xD9zs6FwLpaCct6O9ctzYFfFr4dgmgccOTx" crossorigin="anonymous"></script>
-////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/contrib/auto-render.min.js" integrity="sha384-+VBxd3r6XgURycqtZ117nYw44OOcIax56Z4dCRWbxyPt0Koah1uHoK0o4+/RRE05" crossorigin="anonymous"></script>
+////<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/katex.min.css" integrity="sha384-wcIxkf4k558AjM3Yz3BBFQUbk/zgIYC2R0QpeeYb+TwlBVMrlgLqwRjRtGZiK7ww" crossorigin="anonymous">
+////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/katex.min.js" integrity="sha384-hIoBPJpTUs74ddyc4bFZSM1TVlQDA60VBbJS0oA934VSz82sBx1X7kSx2ATBDIyd" crossorigin="anonymous"></script>
+////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/contrib/auto-render.min.js" integrity="sha384-43gviWU0YVjaDtb/GhzOouOXtZMP/7XUzwPTstBeZFe/+rCMvRwr4yROQP43s0Xk" crossorigin="anonymous"></script>
 ////<script>
 ////    document.addEventListener("DOMContentLoaded", function() {
 ////        renderMathInElement(document.body, {
diff --git a/src/gleam_community/maths/conversion.gleam b/src/gleam_community/maths/conversion.gleam
index 017aabd..d0eb040 100644
--- a/src/gleam_community/maths/conversion.gleam
+++ b/src/gleam_community/maths/conversion.gleam
@@ -1,6 +1,6 @@
-////<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/katex.min.css" integrity="sha384-GvrOXuhMATgEsSwCs4smul74iXGOixntILdUW9XmUC6+HX0sLNAK3q71HotJqlAn" crossorigin="anonymous">
-////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/katex.min.js" integrity="sha384-cpW21h6RZv/phavutF+AuVYrr+dA8xD9zs6FwLpaCct6O9ctzYFfFr4dgmgccOTx" crossorigin="anonymous"></script>
-////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/contrib/auto-render.min.js" integrity="sha384-+VBxd3r6XgURycqtZ117nYw44OOcIax56Z4dCRWbxyPt0Koah1uHoK0o4+/RRE05" crossorigin="anonymous"></script>
+////<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/katex.min.css" integrity="sha384-wcIxkf4k558AjM3Yz3BBFQUbk/zgIYC2R0QpeeYb+TwlBVMrlgLqwRjRtGZiK7ww" crossorigin="anonymous">
+////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/katex.min.js" integrity="sha384-hIoBPJpTUs74ddyc4bFZSM1TVlQDA60VBbJS0oA934VSz82sBx1X7kSx2ATBDIyd" crossorigin="anonymous"></script>
+////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/contrib/auto-render.min.js" integrity="sha384-43gviWU0YVjaDtb/GhzOouOXtZMP/7XUzwPTstBeZFe/+rCMvRwr4yROQP43s0Xk" crossorigin="anonymous"></script>
 ////<script>
 ////    document.addEventListener("DOMContentLoaded", function() {
 ////        renderMathInElement(document.body, {
diff --git a/src/gleam_community/maths/elementary.gleam b/src/gleam_community/maths/elementary.gleam
index 1b518a4..c71ebf6 100644
--- a/src/gleam_community/maths/elementary.gleam
+++ b/src/gleam_community/maths/elementary.gleam
@@ -1,6 +1,6 @@
-////<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/katex.min.css" integrity="sha384-GvrOXuhMATgEsSwCs4smul74iXGOixntILdUW9XmUC6+HX0sLNAK3q71HotJqlAn" crossorigin="anonymous">
-////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/katex.min.js" integrity="sha384-cpW21h6RZv/phavutF+AuVYrr+dA8xD9zs6FwLpaCct6O9ctzYFfFr4dgmgccOTx" crossorigin="anonymous"></script>
-////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/contrib/auto-render.min.js" integrity="sha384-+VBxd3r6XgURycqtZ117nYw44OOcIax56Z4dCRWbxyPt0Koah1uHoK0o4+/RRE05" crossorigin="anonymous"></script>
+////<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/katex.min.css" integrity="sha384-wcIxkf4k558AjM3Yz3BBFQUbk/zgIYC2R0QpeeYb+TwlBVMrlgLqwRjRtGZiK7ww" crossorigin="anonymous">
+////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/katex.min.js" integrity="sha384-hIoBPJpTUs74ddyc4bFZSM1TVlQDA60VBbJS0oA934VSz82sBx1X7kSx2ATBDIyd" crossorigin="anonymous"></script>
+////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/contrib/auto-render.min.js" integrity="sha384-43gviWU0YVjaDtb/GhzOouOXtZMP/7XUzwPTstBeZFe/+rCMvRwr4yROQP43s0Xk" crossorigin="anonymous"></script>
 ////<script>
 ////    document.addEventListener("DOMContentLoaded", function() {
 ////        renderMathInElement(document.body, {
diff --git a/src/gleam_community/maths/metrics.gleam b/src/gleam_community/maths/metrics.gleam
index 725691b..e663d65 100644
--- a/src/gleam_community/maths/metrics.gleam
+++ b/src/gleam_community/maths/metrics.gleam
@@ -1,6 +1,6 @@
-////<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/katex.min.css" integrity="sha384-GvrOXuhMATgEsSwCs4smul74iXGOixntILdUW9XmUC6+HX0sLNAK3q71HotJqlAn" crossorigin="anonymous">
-////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/katex.min.js" integrity="sha384-cpW21h6RZv/phavutF+AuVYrr+dA8xD9zs6FwLpaCct6O9ctzYFfFr4dgmgccOTx" crossorigin="anonymous"></script>
-////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/contrib/auto-render.min.js" integrity="sha384-+VBxd3r6XgURycqtZ117nYw44OOcIax56Z4dCRWbxyPt0Koah1uHoK0o4+/RRE05" crossorigin="anonymous"></script>
+////<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/katex.min.css" integrity="sha384-wcIxkf4k558AjM3Yz3BBFQUbk/zgIYC2R0QpeeYb+TwlBVMrlgLqwRjRtGZiK7ww" crossorigin="anonymous">
+////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/katex.min.js" integrity="sha384-hIoBPJpTUs74ddyc4bFZSM1TVlQDA60VBbJS0oA934VSz82sBx1X7kSx2ATBDIyd" crossorigin="anonymous"></script>
+////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/contrib/auto-render.min.js" integrity="sha384-43gviWU0YVjaDtb/GhzOouOXtZMP/7XUzwPTstBeZFe/+rCMvRwr4yROQP43s0Xk" crossorigin="anonymous"></script>
 ////<script>
 ////    document.addEventListener("DOMContentLoaded", function() {
 ////        renderMathInElement(document.body, {
@@ -22,14 +22,25 @@
 ////</style>
 ////
 //// ---
-////
-//// Metrics: A module offering functions for calculating distances and other types of metrics.
-////
-//// * **Distances**
+//// 
+//// Metrics: A module offering functions for calculating distances and other 
+//// types of metrics.
+//// 
+//// * **Distance measures**
 ////   * [`norm`](#norm)
-////   * [`manhatten_distance`](#float_manhatten_distance)
-////   * [`minkowski_distance`](#minkowski_distance)
+////   * [`manhattan_distance`](#manhattan_distance)
 ////   * [`euclidean_distance`](#euclidean_distance)
+////   * [`chebyshev_distance`](#chebyshev_distance)
+////   * [`minkowski_distance`](#minkowski_distance)
+////   * [`cosine_similarity`](#cosine_similarity)
+////   * [`canberra_distance`](#canberra_distance)
+////   * [`braycurtis_distance`](#braycurtis_distance)
+//// * **Set & string similarity measures**
+////   * [`jaccard_index`](#jaccard_index)
+////   * [`sorensen_dice_coefficient`](#sorensen_dice_coefficient)
+////   * [`tversky_index`](#tversky_index)
+////   * [`overlap_coefficient`](#overlap_coefficient)
+////   * [`levenshtein_distance`](#levenshtein_distance)
 //// * **Basic statistical measures**
 ////   * [`mean`](#mean)
 ////   * [`median`](#median)
@@ -44,6 +55,66 @@ import gleam_community/maths/arithmetics
 import gleam_community/maths/conversion
 import gleam_community/maths/elementary
 import gleam_community/maths/piecewise
+import gleam/set
+import gleam/float
+import gleam/int
+import gleam/string
+import gleam/option
+
+/// Utility function that checks all lists have the expected length and contents
+/// The function is primarily used by all distance measures taking 'List(Float)'
+/// as input
+fn validate_lists(
+  xarr: List(Float),
+  yarr: List(Float),
+  weights: option.Option(List(Float)),
+) -> Result(Bool, String) {
+  case xarr, yarr {
+    [], _ ->
+      "Invalid input argument: The list xarr is empty."
+      |> Error
+    _, [] ->
+      "Invalid input argument: The list yarr is empty."
+      |> Error
+    _, _ -> {
+      let xarr_length: Int = list.length(xarr)
+      let yarr_length: Int = list.length(yarr)
+      case xarr_length == yarr_length, weights {
+        False, _ ->
+          "Invalid input argument: length(xarr) != length(yarr). Valid input is when length(xarr) == length(yarr)."
+          |> Error
+        True, option.None -> {
+          True
+          |> Ok
+        }
+        True, option.Some(warr) -> {
+          let warr_length: Int = list.length(warr)
+          case xarr_length == warr_length {
+            True -> {
+              validate_weights(warr)
+            }
+            False ->
+              "Invalid input argument: length(weights) != length(xarr) and length(weights) != length(yarr). Valid input is when length(weights) == length(xarr) == length(yarr)."
+              |> Error
+          }
+        }
+      }
+    }
+  }
+}
+
+fn validate_weights(warr: List(Float)) -> Result(Bool, String) {
+  // Check that all the given weights are positive
+  let assert Ok(minimum) = piecewise.list_minimum(warr, float.compare)
+  case minimum >=. 0.0 {
+    False ->
+      "Invalid input argument: One or more weights are negative. Valid input is when all weights are >= 0."
+      |> Error
+    True ->
+      True
+      |> Ok
+  }
+}
 
 /// <div style="text-align: right;">
 ///     <a href="https://github.com/gleam-community/maths/issues">
@@ -51,32 +122,39 @@ import gleam_community/maths/piecewise
 ///     </a>
 /// </div>
 ///
-/// Calculcate the $$p$$-norm of a list (representing a vector):
+/// Calculate the (weighted) $$p$$-norm of a list (representing a vector):
 ///
 /// \\[
-/// \left( \sum_{i=1}^n \left|x_i\right|^{p} \right)^{\frac{1}{p}}
+/// \left( \sum_{i=1}^n w_{i} \left|x_{i}\right|^{p} \right)^{\frac{1}{p}}
 /// \\]
 ///
-/// In the formula, $$n$$ is the length of the list and $$x_i$$ is the value in the input list indexed by $$i$$.
+/// In the formula, $$n$$ is the length of the list and $$x_i$$ is the value in 
+/// the input list indexed by $$i$$, while $$w_i \in \mathbb{R}_{+}$$ is
+/// a corresponding positive weight ($$w_i = 1.0\\;\forall i=1...n$$ by default).
 ///
 /// <details>
 ///     <summary>Example:</summary>
 ///
 ///     import gleeunit/should
+///     import gleam/option
 ///     import gleam_community/maths/elementary
 ///     import gleam_community/maths/metrics
 ///     import gleam_community/maths/predicates
 ///
-///     pub fn example () {
+///     pub fn example() {
 ///       let assert Ok(tol) = elementary.power(-10.0, -6.0)
-///
-///       [1.0, 1.0, 1.0]
-///       |> metrics.norm(1.0)
+///     
+///       let assert Ok(result) =
+///         [1.0, 1.0, 1.0]
+///         |> metrics.norm(1.0, option.None)
+///       result
 ///       |> predicates.is_close(3.0, 0.0, tol)
 ///       |> should.be_true()
-///
-///       [1.0, 1.0, 1.0]
-///       |> metrics.norm(-1.0)
+///     
+///       let assert Ok(result) =
+///         [1.0, 1.0, 1.0]
+///         |> metrics.norm(-1.0, option.None)
+///       result
 ///       |> predicates.is_close(0.3333333333333333, 0.0, tol)
 ///       |> should.be_true()
 ///     }
@@ -88,19 +166,65 @@ import gleam_community/maths/piecewise
 ///     </a>
 /// </div>
 ///
-pub fn norm(arr: List(Float), p: Float) -> Float {
-  case arr {
-    [] -> 0.0
-    _ -> {
-      let agg: Float =
+pub fn norm(
+  arr: List(Float),
+  p: Float,
+  weights: option.Option(List(Float)),
+) -> Result(Float, String) {
+  case arr, weights {
+    [], _ ->
+      0.0
+      |> Ok
+    _, option.None -> {
+      let aggregate: Float =
         arr
-        |> list.fold(0.0, fn(acc: Float, a: Float) -> Float {
+        |> list.fold(0.0, fn(accumulator: Float, element: Float) -> Float {
           let assert Ok(result) =
-            elementary.power(piecewise.float_absolute_value(a), p)
-          result +. acc
+            piecewise.float_absolute_value(element)
+            |> elementary.power(p)
+          result +. accumulator
         })
-      let assert Ok(result) = elementary.power(agg, 1.0 /. p)
+      let assert Ok(result) = elementary.power(aggregate, 1.0 /. p)
       result
+      |> Ok
+    }
+    _, option.Some(warr) -> {
+      let arr_length: Int = list.length(arr)
+      let warr_length: Int = list.length(warr)
+      case arr_length == warr_length {
+        True -> {
+          case validate_weights(warr) {
+            Ok(_) -> {
+              let tuples: List(#(Float, Float)) = list.zip(arr, warr)
+              let aggregate: Float =
+                tuples
+                |> list.fold(
+                  0.0,
+                  fn(accumulator: Float, tuple: #(Float, Float)) -> Float {
+                    let first_element: Float = pair.first(tuple)
+                    let second_element: Float = pair.second(tuple)
+                    let assert Ok(result) =
+                      elementary.power(
+                        piecewise.float_absolute_value(first_element),
+                        p,
+                      )
+                    second_element *. result +. accumulator
+                  },
+                )
+              let assert Ok(result) = elementary.power(aggregate, 1.0 /. p)
+              result
+              |> Ok
+            }
+            Error(msg) ->
+              msg
+              |> Error
+          }
+        }
+        False -> {
+          "Invalid input argument: length(weights) != length(arr). Valid input is when length(weights) == length(arr)."
+          |> Error
+        }
+      }
     }
   }
 }
@@ -111,34 +235,40 @@ pub fn norm(arr: List(Float), p: Float) -> Float {
 ///     </a>
 /// </div>
 ///
-/// Calculcate the Manhatten distance between two lists (representing vectors):
+/// Calculate the (weighted) Manhattan distance between two lists (representing 
+/// vectors):
 ///
 /// \\[
-/// \sum_{i=1}^n \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, j$$.
+/// 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 
+/// ($$w_i = 1.0\\;\forall i=1...n$$ by default).
 ///
 /// <details>
 ///     <summary>Example:</summary>
 ///
 ///     import gleeunit/should
+///     import gleam/option
 ///     import gleam_community/maths/elementary
 ///     import gleam_community/maths/metrics
 ///     import gleam_community/maths/predicates
 ///
-///     pub fn example () {
+///     pub fn example() {
 ///       let assert Ok(tol) = elementary.power(-10.0, -6.0)
 ///
-///       // Empty lists returns 0.0
-///       metrics.float_manhatten_distance([], [])
-///       |> should.equal(Ok(0.0))
-///
-///       // Differing lengths returns error
-///       metrics.manhatten_distance([], [1.0])
+///       // Empty lists returns an error
+///       metrics.manhattan_distance([], [], option.None)
 ///       |> should.be_error()
-///
-///       let assert Ok(result) = metrics.manhatten_distance([0.0, 0.0], [1.0, 2.0])
+///     
+///       // Differing lengths returns error
+///       metrics.manhattan_distance([], [1.0], option.None)
+///       |> should.be_error()
+///     
+///       let assert Ok(result) =
+///         metrics.manhattan_distance([0.0, 0.0], [1.0, 2.0], option.None)
 ///       result
 ///       |> predicates.is_close(3.0, 0.0, tol)
 ///       |> should.be_true()
@@ -151,11 +281,12 @@ pub fn norm(arr: List(Float), p: Float) -> Float {
 ///     </a>
 /// </div>
 ///
-pub fn manhatten_distance(
+pub fn manhattan_distance(
   xarr: List(Float),
   yarr: List(Float),
+  weights: option.Option(List(Float)),
 ) -> Result(Float, String) {
-  minkowski_distance(xarr, yarr, 1.0)
+  minkowski_distance(xarr, yarr, 1.0, weights)
 }
 
 /// <div style="text-align: right;">
@@ -164,40 +295,47 @@ pub fn manhatten_distance(
 ///     </a>
 /// </div>
 ///
-/// Calculcate the Minkowski distance between two lists (representing vectors):
+/// Calculate the (weighted) Minkowski distance between two lists (representing
+/// vectors):
 ///
 /// \\[
-/// \left( \sum_{i=1}^n \left|x_i - y_i \right|^{p} \right)^{\frac{1}{p}}
+/// \left( \sum_{i=1}^n w_{i} \left|x_i - y_i \right|^{p} \right)^{\frac{1}{p}}
 /// \\]
 ///
-/// In the formula, $$p >= 1$$ is the order, $$n$$ is the length of the two lists and $$x_i, y_i$$ are the values in the respective input lists indexed by $$i, j$$.
+/// In the formula, $$p >= 1$$ is the order, $$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 $$w_i \in \mathbb{R}_{+}$$ are corresponding positive weights 
+/// ($$w_i = 1.0\\;\forall i=1...n$$ by default).
 ///
-/// The Minkowski distance is a generalization of both the Euclidean distance ($$p=2$$) and the Manhattan distance ($$p = 1$$).
+/// The Minkowski distance is a generalization of both the Euclidean distance 
+/// ($$p=2$$) and the Manhattan distance ($$p = 1$$).
 ///
 /// <details>
 ///     <summary>Example:</summary>
 ///
 ///     import gleeunit/should
+///     import gleam/option
 ///     import gleam_community/maths/elementary
 ///     import gleam_community/maths/metrics
 ///     import gleam_community/maths/predicates
 ///
-///     pub fn example () {
+///     pub fn example() {
 ///       let assert Ok(tol) = elementary.power(-10.0, -6.0)
-///
-///       // Empty lists returns 0.0
-///       metrics.minkowski_distance([], [], 1.0)
-///       |> should.equal(Ok(0.0))
-///
+///     
+///       // Empty lists returns an error
+///       metrics.minkowski_distance([], [], 1.0, option.None)
+///       |> should.be_error()
+///     
 ///       // Differing lengths returns error
-///       metrics.minkowski_distance([], [1.0], 1.0)
+///       metrics.minkowski_distance([], [1.0], 1.0, option.None)
 ///       |> should.be_error()
 ///
 ///       // Test order < 1
-///       metrics.minkowski_distance([0.0, 0.0], [0.0, 0.0], -1.0)
+///       metrics.minkowski_distance([0.0, 0.0], [0.0, 0.0], -1.0, option.None)
 ///       |> should.be_error()
-///
-///       let assert Ok(result) = metrics.minkowski_distance([0.0, 0.0], [1.0, 2.0], 1.0)
+///     
+///       let assert Ok(result) =
+///         metrics.minkowski_distance([0.0, 0.0], [1.0, 2.0], 1.0, option.None)
 ///       result
 ///       |> predicates.is_close(3.0, 0.0, tol)
 ///       |> should.be_true()
@@ -214,26 +352,30 @@ pub fn minkowski_distance(
   xarr: List(Float),
   yarr: List(Float),
   p: Float,
+  weights: option.Option(List(Float)),
 ) -> Result(Float, String) {
-  let xlen: Int = list.length(xarr)
-  let ylen: Int = list.length(yarr)
-  case xlen == ylen {
-    False ->
-      "Invalid input argument: length(xarr) != length(yarr). Valid input is when length(xarr) == length(yarr)."
+  case validate_lists(xarr, yarr, weights) {
+    Error(msg) ->
+      msg
       |> Error
-    True ->
+    Ok(_) -> {
       case p <. 1.0 {
         True ->
           "Invalid input argument: p < 1. Valid input is p >= 1."
           |> Error
-        False ->
-          list.zip(xarr, yarr)
-          |> list.map(fn(tuple: #(Float, Float)) -> Float {
-            pair.first(tuple) -. pair.second(tuple)
-          })
-          |> norm(p)
+        False -> {
+          let differences: List(Float) =
+            list.zip(xarr, yarr)
+            |> list.map(fn(tuple: #(Float, Float)) -> Float {
+              pair.first(tuple) -. pair.second(tuple)
+            })
+
+          let assert Ok(result) = norm(differences, p, weights)
+          result
           |> Ok
+        }
       }
+    }
   }
 }
 
@@ -243,34 +385,40 @@ pub fn minkowski_distance(
 ///     </a>
 /// </div>
 ///
-/// Calculcate the Euclidean distance between two lists (representing vectors):
+/// Calculate the (weighted) Euclidean distance between two lists (representing 
+/// vectors):
 ///
 /// \\[
-/// \left( \sum_{i=1}^n \left|x_i - y_i \right|^{2} \right)^{\frac{1}{2}}
+/// \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, j$$.
+/// 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 
+/// ($$w_i = 1.0\\;\forall i=1...n$$ by default).
 ///
 /// <details>
 ///     <summary>Example:</summary>
 ///
 ///     import gleeunit/should
+///     import gleam/option
 ///     import gleam_community/maths/elementary
 ///     import gleam_community/maths/metrics
 ///     import gleam_community/maths/predicates
 ///
-///     pub fn example () {
+///     pub fn example() {
 ///       let assert Ok(tol) = elementary.power(-10.0, -6.0)
-///
-///       // Empty lists returns 0.0
-///       metrics.euclidean_distance([], [])
-///       |> should.equal(Ok(0.0))
-///
-///       // Differing lengths returns error
-///       metrics.euclidean_distance([], [1.0])
+///     
+///       // Empty lists returns an error
+///       metrics.euclidean_distance([], [], option.None)
 ///       |> should.be_error()
-///
-///       let assert Ok(result) = metrics.euclidean_distance([0.0, 0.0], [1.0, 2.0])
+///     
+///       // Differing lengths returns an error
+///       metrics.euclidean_distance([], [1.0], option.None)
+///       |> should.be_error()
+///     
+///       let assert Ok(result) =
+///         metrics.euclidean_distance([0.0, 0.0], [1.0, 2.0], option.None)
 ///       result
 ///       |> predicates.is_close(2.23606797749979, 0.0, tol)
 ///       |> should.be_true()
@@ -286,24 +434,87 @@ pub fn minkowski_distance(
 pub fn euclidean_distance(
   xarr: List(Float),
   yarr: List(Float),
+  weights: option.Option(List(Float)),
 ) -> Result(Float, String) {
-  minkowski_distance(xarr, yarr, 2.0)
+  minkowski_distance(xarr, yarr, 2.0, weights)
 }
 
 /// <div style="text-align: right;">
-///     <a href="https://github.com/nicklasxyz/gleam_stats/issues">
+///     <a href="https://github.com/gleam-community/maths/issues">
 ///         <small>Spot a typo? Open an issue!</small>
 ///     </a>
 /// </div>
 ///
-/// Calculcate the arithmetic mean of the elements in a list:
+/// 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$$.
+///
+/// <details>
+///     <summary>Example:</summary>
+///
+///     import gleeunit/should
+///     import gleam_community/maths/elementary
+///     import gleam_community/maths/metrics
+///     import gleam_community/maths/predicates
+///
+///     pub fn example() {
+///       // Empty lists returns an error
+///       metrics.chebyshev_distance([], [])
+///       |> should.be_error()
+///     
+///       // Differing lengths returns error
+///       metrics.chebyshev_distance([], [1.0])
+///       |> should.be_error()
+///     
+///       metrics.chebyshev_distance([-5.0, -10.0, -3.0], [-1.0, -12.0, -3.0])
+///       |> should.equal(Ok(4.0))
+///     }
+/// </details>
+///
+/// <div style="text-align: right;">
+///     <a href="#">
+///         <small>Back to top ↑</small>
+///     </a>
+/// </div>
+///
+pub fn chebyshev_distance(
+  xarr: List(Float),
+  yarr: List(Float),
+) -> Result(Float, String) {
+  case validate_lists(xarr, yarr, option.None) {
+    Error(msg) ->
+      msg
+      |> Error
+    Ok(_) -> {
+      list.zip(xarr, yarr)
+      |> list.map(fn(tuple: #(Float, Float)) -> Float {
+        { pair.first(tuple) -. pair.second(tuple) }
+        |> piecewise.float_absolute_value()
+      })
+      |> piecewise.list_maximum(float.compare)
+    }
+  }
+}
+
+/// <div style="text-align: right;">
+///     <a href="https://github.com/gleam-community/maths/issues">
+///         <small>Spot a typo? Open an issue!</small>
+///     </a>
+/// </div>
+///
+/// Calculate the arithmetic mean of the elements in a list:
 ///
 /// \\[
 /// \bar{x} = \frac{1}{n}\sum_{i=1}^n 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$$.
+/// 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$$.
 ///
 /// <details>
 ///     <summary>Example:</summary>
@@ -337,7 +548,7 @@ pub fn mean(arr: List(Float)) -> Result(Float, String) {
       |> Error
     _ ->
       arr
-      |> arithmetics.float_sum()
+      |> arithmetics.float_sum(option.None)
       |> fn(a: Float) -> Float {
         a /. conversion.int_to_float(list.length(arr))
       }
@@ -346,12 +557,12 @@ pub fn mean(arr: List(Float)) -> Result(Float, String) {
 }
 
 /// <div style="text-align: right;">
-///     <a href="https://github.com/nicklasxyz/gleam_stats/issues">
+///     <a href="https://github.com/gleam-community/maths/issues">
 ///         <small>Spot a typo? Open an issue!</small>
 ///     </a>
 /// </div>
 ///
-/// Calculcate the median of the elements in a list.
+/// Calculate the median of the elements in a list.
 ///
 /// <details>
 ///     <summary>Example:</summary>
@@ -411,19 +622,20 @@ fn do_median(
 }
 
 /// <div style="text-align: right;">
-///     <a href="https://github.com/nicklasxyz/gleam_stats/issues">
+///     <a href="https://github.com/gleam-community/maths/issues">
 ///         <small>Spot a typo? Open an issue!</small>
 ///     </a>
 /// </div>
 ///
-/// Calculcate the sample variance of the elements in a list:
+/// Calculate the sample variance of the elements in a list:
+/// 
 /// \\[
 /// s^{2} = \frac{1}{n - d} \sum_{i=1}^{n}(x_i - \bar{x})
 /// \\]
 ///
-/// 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$$.
-/// Furthermore, $$\bar{x}$$ is the sample mean and $$d$$ is the "Delta
+/// 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$$. 
+/// Furthermore, $$\bar{x}$$ is the sample mean and $$d$$ is the "Delta 
 /// Degrees of Freedom", and is by default set to $$d = 0$$, which gives a biased
 /// estimate of the sample variance. Setting $$d = 1$$ gives an unbiased estimate.
 ///
@@ -472,7 +684,7 @@ pub fn variance(arr: List(Float), ddof: Int) -> Result(Float, String) {
             let assert Ok(result) = elementary.power(a -. mean, 2.0)
             result
           })
-          |> arithmetics.float_sum()
+          |> arithmetics.float_sum(option.None)
           |> fn(a: Float) -> Float {
             a
             /. {
@@ -487,21 +699,22 @@ pub fn variance(arr: List(Float), ddof: Int) -> Result(Float, String) {
 }
 
 /// <div style="text-align: right;">
-///     <a href="https://github.com/nicklasxyz/gleam_stats/issues">
+///     <a href="https://github.com/gleam-community/maths/issues">
 ///         <small>Spot a typo? Open an issue!</small>
 ///     </a>
 /// </div>
 ///
-/// Calculcate the sample standard deviation of the elements in a list:
+/// Calculate the sample standard deviation of the elements in a list:
 /// \\[
 /// s = \left(\frac{1}{n - d} \sum_{i=1}^{n}(x_i - \bar{x})\right)^{\frac{1}{2}}
 /// \\]
 ///
-/// 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$$.
-/// Furthermore, $$\bar{x}$$ is the sample mean and $$d$$ is the "Delta
+/// 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$$. 
+/// Furthermore, $$\bar{x}$$ is the sample mean and $$d$$ is the "Delta 
 /// Degrees of Freedom", and is by default set to $$d = 0$$, which gives a biased
-/// estimate of the sample standard deviation. Setting $$d = 1$$ gives an unbiased estimate.
+/// estimate of the sample standard deviation. Setting $$d = 1$$ gives an unbiased 
+/// estimate.
 ///
 /// <details>
 ///     <summary>Example:</summary>
@@ -552,3 +765,676 @@ pub fn standard_deviation(arr: List(Float), ddof: Int) -> Result(Float, String)
       }
   }
 }
+
+/// <div style="text-align: right;">
+///     <a href="https://github.com/gleam-community/maths/issues">
+///         <small>Spot a typo? Open an issue!</small>
+///     </a>
+/// </div>
+///
+/// The Jaccard index measures similarity between two sets of elements. 
+/// Mathematically, the Jaccard index is defined as:
+/// 
+/// \\[
+/// \frac{|X \cap Y|}{|X \cup Y|} \\; \in \\; \left[0, 1\right]
+/// \\]
+/// 
+/// where:
+///
+/// - $$X$$ and $$Y$$ are two sets being compared,
+/// - $$|X \cap Y|$$ represents the size of the intersection of the two sets
+/// - $$|X \cup Y|$$ denotes the size of the union of the two sets
+/// 
+/// The value of the Jaccard index ranges from 0 to 1, where 0 indicates that the 
+/// two sets share no elements and 1 indicates that the sets are identical. The 
+/// Jaccard index is a special case of the  [Tversky index](#tversky_index) (with
+/// $$\alpha=\beta=1$$).
+/// 
+/// <details>
+///     <summary>Example:</summary>
+///
+///     import gleeunit/should
+///     import gleam_community/maths/metrics
+///     import gleam/set
+///
+///     pub fn example () {
+///       let xset: set.Set(String) = set.from_list(["cat", "dog", "hippo", "monkey"])
+///       let yset: set.Set(String) =
+///         set.from_list(["monkey", "rhino", "ostrich", "salmon"])
+///       metrics.jaccard_index(xset, yset)
+///       |> should.equal(1.0 /. 7.0)
+///     }
+/// </details>
+///
+/// <div style="text-align: right;">
+///     <a href="#">
+///         <small>Back to top ↑</small>
+///     </a>
+/// </div>
+///
+pub fn jaccard_index(xset: set.Set(a), yset: set.Set(a)) -> Float {
+  let assert Ok(result) = tversky_index(xset, yset, 1.0, 1.0)
+  result
+}
+
+/// <div style="text-align: right;">
+///     <a href="https://github.com/gleam-community/maths/issues">
+///         <small>Spot a typo? Open an issue!</small>
+///     </a>
+/// </div>
+///
+/// The Sørensen-Dice coefficient measures the similarity between two sets of 
+/// elements. Mathematically, the coefficient is defined as:
+/// 
+/// \\[
+/// \frac{2 |X \cap Y|}{|X| + |Y|} \\; \in \\; \left[0, 1\right]
+/// \\]
+/// 
+/// where:
+/// - $$X$$ and $$Y$$ are two sets being compared
+/// - $$|X \cap Y|$$ is the size of the intersection of the two sets (i.e., the 
+/// number of elements common to both sets)
+/// - $$|X|$$ and $$|Y|$$ are the sizes of the sets $$X$$ and $$Y$$, respectively
+/// 
+/// The coefficient ranges from 0 to 1, where 0 indicates no similarity (the sets
+/// share no elements) and 1 indicates perfect similarity (the sets are identical).
+/// The higher the coefficient, the greater the similarity between the two sets. 
+/// The Sørensen-Dice coefficient is a special case of the 
+/// [Tversky index](#tversky_index) (with $$\alpha=\beta=0.5$$).
+/// 
+/// <details>
+///     <summary>Example:</summary>
+///
+///     import gleeunit/should
+///     import gleam_community/maths/metrics
+///     import gleam/set
+///
+///     pub fn example () {
+///       let xset: set.Set(String) = set.from_list(["cat", "dog", "hippo", "monkey"])
+///       let yset: set.Set(String) =
+///         set.from_list(["monkey", "rhino", "ostrich", "salmon", "spider"])
+///       metrics.sorensen_dice_coefficient(xset, yset)
+///       |> should.equal(2.0 *. 1.0 /. { 4.0 +. 5.0 })
+///     }
+/// </details>
+///
+/// <div style="text-align: right;">
+///     <a href="#">
+///         <small>Back to top ↑</small>
+///     </a>
+/// </div>
+///
+pub fn sorensen_dice_coefficient(xset: set.Set(a), yset: set.Set(a)) -> Float {
+  let assert Ok(result) = tversky_index(xset, yset, 0.5, 0.5)
+  result
+}
+
+/// <div style="text-align: right;">
+///     <a href="https://github.com/gleam-community/maths/issues">
+///         <small>Spot a typo? Open an issue!</small>
+///     </a>
+/// </div>
+/// 
+/// The Tversky index is a generalization of the Jaccard index and Sørensen-Dice 
+/// coefficient, which adds flexibility through two parameters, $$\alpha$$ and 
+/// $$\beta$$, allowing for asymmetric similarity measures between sets. The 
+/// Tversky index is defined as:
+/// 
+/// \\[
+/// \frac{|X \cap Y|}{|X \cap Y| + \alpha|X - Y| + \beta|Y - X|}
+/// \\]
+/// 
+/// where:
+/// 
+/// - $$X$$ and $$Y$$ are the sets being compared
+/// - $$|X - Y|$$ and $$|Y - X|$$ are the sizes of the relative complements of 
+/// $$Y$$ in $$X$$ and $$X$$ in $$Y$$, respectively,
+/// - $$\alpha$$ and $$\beta$$ are parameters that weigh the relative importance
+/// of the elements unique to $$X$$ and $$Y$$
+/// 
+/// The Tversky index reduces to the Jaccard index when $$\alpha = \beta = 1$$ and
+/// to the Sørensen-Dice coefficient when $$\alpha = \beta = 0.5$$. In general, the
+/// Tversky index can take on any non-negative value, including 0. The index equals
+/// 0 when there is no intersection between the two sets, indicating no similarity. 
+/// However, unlike similarity measures bounded strictly between 0 and 1, the 
+/// Tversky index does not have a strict upper limit of 1 when $$\alpha \neq \beta$$.
+///  
+/// <details>
+///     <summary>Example:</summary>
+///
+///     import gleeunit/should
+///     import gleam_community/maths/metrics
+///     import gleam/set
+///
+///     pub fn example () {
+///       let yset: set.Set(String) = set.from_list(["cat", "dog", "hippo", "monkey"])
+///       let xset: set.Set(String) =
+///         set.from_list(["monkey", "rhino", "ostrich", "salmon"])
+///       // Test Jaccard index (alpha = beta = 1)
+///       metrics.tversky_index(xset, yset, 1.0, 1.0)
+///       |> should.equal(1.0 /. 7.0)
+///     }
+/// </details>
+///
+/// <div style="text-align: right;">
+///     <a href="#">
+///         <small>Back to top ↑</small>
+///     </a>
+/// </div>
+///
+pub fn tversky_index(
+  xset: set.Set(a),
+  yset: set.Set(a),
+  alpha: Float,
+  beta: Float,
+) -> Result(Float, String) {
+  case alpha >=. 0.0, beta >=. 0.0 {
+    True, True -> {
+      let intersection: Float =
+        set.intersection(xset, yset)
+        |> set.size()
+        |> conversion.int_to_float()
+      let difference1: Float =
+        set.difference(xset, yset)
+        |> set.size()
+        |> conversion.int_to_float()
+      let difference2: Float =
+        set.difference(yset, xset)
+        |> set.size()
+        |> conversion.int_to_float()
+      intersection
+      /. { intersection +. alpha *. difference1 +. beta *. difference2 }
+      |> Ok
+    }
+    False, True -> {
+      "Invalid input argument: alpha < 0. Valid input is alpha >= 0."
+      |> Error
+    }
+    True, False -> {
+      "Invalid input argument: beta < 0. Valid input is beta >= 0."
+      |> Error
+    }
+    _, _ -> {
+      "Invalid input argument: alpha < 0 and beta < 0. Valid input is alpha >= 0 and beta >= 0."
+      |> Error
+    }
+  }
+}
+
+/// <div style="text-align: right;">
+///     <a href="https://github.com/gleam-community/maths/issues">
+///         <small>Spot a typo? Open an issue!</small>
+///     </a>
+/// </div>
+/// 
+/// The Overlap coefficient, also known as the Szymkiewicz–Simpson coefficient, is
+/// a measure of similarity between two sets that focuses on the size of the 
+/// intersection relative to the smaller of the two sets. It is defined 
+/// mathematically as:
+///
+/// \\[
+/// \frac{|X \cap Y|}{\min(|X|, |Y|)} \\; \in \\; \left[0, 1\right]
+/// \\]
+///
+/// where:
+///
+/// - $$X$$ and $$Y$$ are the sets being compared
+/// - $$|X \cap Y|$$ is the size of the intersection of the sets
+/// - $$\min(|X|, |Y|)$$ is the size of the smaller set among $$X$$ and $$Y$$
+///
+/// The coefficient ranges from 0 to 1, where 0 indicates no overlap and 1 
+/// indicates that the smaller set is a suyset of the larger set. This 
+/// measure is especially useful in situations where the similarity in terms
+/// of the proportion of overlap is more relevant than the difference in sizes 
+/// between the two sets.
+///
+/// <details>
+///     <summary>Example:</summary>
+///
+///     import gleeunit/should
+///     import gleam_community/maths/metrics
+///     import gleam/set
+///
+///     pub fn example () {
+///       let set_a: set.Set(String) =
+///         set.from_list(["horse", "dog", "hippo", "monkey", "bird"])
+///       let set_b: set.Set(String) =
+///         set.from_list(["monkey", "bird", "ostrich", "salmon"])
+///       metrics.overlap_coefficient(set_a, set_b)
+///       |> should.equal(2.0 /. 4.0)
+///     }
+/// </details>
+///
+/// <div style="text-align: right;">
+///     <a href="#">
+///         <small>Back to top ↑</small>
+///     </a>
+/// </div>
+///
+pub fn overlap_coefficient(xset: set.Set(a), yset: set.Set(a)) -> Float {
+  let intersection: Float =
+    set.intersection(xset, yset)
+    |> set.size()
+    |> conversion.int_to_float()
+  let minsize: Float =
+    piecewise.minimum(set.size(xset), set.size(yset), int.compare)
+    |> conversion.int_to_float()
+  intersection /. minsize
+}
+
+/// <div style="text-align: right;">
+///     <a href="https://github.com/gleam-community/maths/issues">
+///         <small>Spot a typo? Open an issue!</small>
+///     </a>
+/// </div>
+/// 
+/// 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 
+/// ($$w_i = 1.0\\;\forall i=1...n$$ by default). 
+/// 
+/// 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. 
+/// 
+/// <details>
+///     <summary>Example:</summary>
+///
+///     import gleeunit/should
+///     import gleam/option
+///     import gleam_community/maths/metrics
+///
+///     pub fn example() {
+///       // Two orthogonal vectors
+///       metrics.cosine_similarity([-1.0, 1.0, 0.0], [1.0, 1.0, -1.0], option.None)
+///       |> should.equal(Ok(0.0))
+///     
+///       // Two identical (parallel) vectors
+///       metrics.cosine_similarity([1.0, 2.0, 3.0], [1.0, 2.0, 3.0], option.None)
+///       |> should.equal(Ok(1.0))
+///     
+///       // Two parallel, but oppositely oriented vectors
+///       metrics.cosine_similarity([-1.0, -2.0, -3.0], [1.0, 2.0, 3.0], option.None)
+///       |> should.equal(Ok(-1.0))
+///     }
+/// </details>
+///
+/// <div style="text-align: right;">
+///     <a href="#">
+///         <small>Back to top ↑</small>
+///     </a>
+/// </div>
+///
+pub fn cosine_similarity(
+  xarr: List(Float),
+  yarr: List(Float),
+  weights: option.Option(List(Float)),
+) -> Result(Float, String) {
+  case validate_lists(xarr, yarr, weights) {
+    Error(msg) ->
+      msg
+      |> Error
+    Ok(_) -> {
+      let zipped_arr: List(#(Float, Float)) = list.zip(xarr, yarr)
+
+      let numerator_elements: List(Float) =
+        zipped_arr
+        |> list.map(fn(tuple: #(Float, Float)) -> Float {
+          pair.first(tuple) *. pair.second(tuple)
+        })
+
+      case weights {
+        option.None -> {
+          let numerator: Float =
+            numerator_elements
+            |> arithmetics.float_sum(option.None)
+
+          let assert Ok(xarr_norm) = norm(xarr, 2.0, option.None)
+          let assert Ok(yarr_norm) = norm(yarr, 2.0, option.None)
+          let denominator: Float = {
+            xarr_norm *. yarr_norm
+          }
+          numerator /. denominator
+          |> Ok
+        }
+        _ -> {
+          let numerator: Float =
+            numerator_elements
+            |> arithmetics.float_sum(weights)
+
+          let assert Ok(xarr_norm) = norm(xarr, 2.0, weights)
+          let assert Ok(yarr_norm) = norm(yarr, 2.0, weights)
+          let denominator: Float = {
+            xarr_norm *. yarr_norm
+          }
+          numerator /. denominator
+          |> Ok
+        }
+      }
+    }
+  }
+}
+
+/// <div style="text-align: right;">
+///     <a href="https://github.com/gleam-community/maths/issues">
+///         <small>Spot a typo? Open an issue!</small>
+///     </a>
+/// </div>
+/// 
+/// Calculate the Levenshtein distance between two strings, i.e., measure the 
+/// difference between two strings (essentially sequences). It is defined as 
+/// the minimum number of single-character edits required to change one string
+/// into the other, using operations:
+/// - insertions
+/// - deletions
+/// - substitutions
+/// 
+/// Note: The implementation is primarily based on the Elixir implementation 
+/// [levenshtein](https://hex.pm/packages/levenshtein).
+/// 
+/// <details>
+///     <summary>Example:</summary>
+///
+///     import gleeunit/should
+///     import gleam_community/maths/metrics
+///
+///     pub fn example () {
+///       metrics.levenshtein_distance("hello", "hello")
+///       |> should.equal(0)
+///       
+///       metrics.levenshtein_distance("cat", "cut")
+///       |> should.equal(1)
+///       
+///       metrics.levenshtein_distance("kitten", "sitting")
+///       |> should.equal(3)
+///     }
+/// </details>
+///
+/// <div style="text-align: right;">
+///     <a href="#">
+///         <small>Back to top ↑</small>
+///     </a>
+/// </div>
+///
+///
+pub fn levenshtein_distance(xstring: String, ystring: String) -> Int {
+  case xstring, ystring {
+    xstring, ystring if xstring == ystring -> {
+      0
+    }
+    xstring, ystring if xstring == "" -> {
+      string.length(ystring)
+    }
+    xstring, ystring if ystring == "" -> {
+      string.length(xstring)
+    }
+    _, _ -> {
+      let xstring_graphemes = string.to_graphemes(xstring)
+      let ystring_graphemes = string.to_graphemes(ystring)
+      let ystring_length = list.length(ystring_graphemes)
+      let distance_list = list.range(0, ystring_length)
+
+      do_edit_distance(xstring_graphemes, ystring_graphemes, distance_list, 1)
+    }
+  }
+}
+
+fn do_edit_distance(
+  xstring: List(String),
+  ystring: List(String),
+  distance_list: List(Int),
+  step: Int,
+) -> Int {
+  case xstring {
+    // Safe as 'distance_list' is never empty
+    [] -> {
+      let assert Ok(last) = list.last(distance_list)
+      last
+    }
+    [xstring_head, ..xstring_tail] -> {
+      let new_distance_list =
+        distance_list_helper(ystring, distance_list, xstring_head, [step], step)
+      do_edit_distance(xstring_tail, ystring, new_distance_list, step + 1)
+    }
+  }
+}
+
+fn distance_list_helper(
+  ystring: List(String),
+  distance_list: List(Int),
+  grapheme: String,
+  new_distance_list: List(Int),
+  last_distance: Int,
+) -> List(Int) {
+  case ystring {
+    [] -> list.reverse(new_distance_list)
+    [ystring_head, ..ystring_tail] -> {
+      let assert [distance_list_head, ..distance_list_tail] = distance_list
+      let difference = case ystring_head == grapheme {
+        True -> {
+          0
+        }
+        False -> {
+          1
+        }
+      }
+      let assert [first, ..] = distance_list_tail
+      let min =
+        last_distance + 1
+        |> piecewise.minimum(first + 1, int.compare)
+        |> piecewise.minimum(distance_list_head + difference, int.compare)
+      distance_list_helper(
+        ystring_tail,
+        distance_list_tail,
+        grapheme,
+        [min, ..new_distance_list],
+        min,
+      )
+    }
+  }
+}
+
+/// <div style="text-align: right;">
+///     <a href="https://github.com/gleam-community/maths/issues">
+///         <small>Spot a typo? Open an issue!</small>
+///     </a>
+/// </div>
+/// 
+/// 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 
+/// ($$w_i = 1.0\\;\forall i=1...n$$ by default). 
+///
+/// <details>
+///     <summary>Example:</summary>
+///
+///     import gleeunit/should
+///     import gleam/option
+///     import gleam_community/maths/metrics
+///
+///     pub fn example() {
+///       // Empty lists returns an error
+///       metrics.canberra_distance([], [], option.None)
+///       |> should.be_error()
+///     
+///       // Different sized lists returns an error
+///       metrics.canberra_distance([1.0, 2.0], [1.0, 2.0, 3.0, 4.0], option.None)
+///       |> should.be_error()
+///     
+///       // Valid inputs
+///       metrics.canberra_distance([1.0, 2.0], [-2.0, -1.0], option.None)
+///       |> should.equal(Ok(2.0))
+///     
+///       metrics.canberra_distance([1.0, 0.0], [0.0, 2.0], option.Some([1.0, 0.5]))
+///     }
+/// </details>
+///
+/// <div style="text-align: right;">
+///     <a href="#">
+///         <small>Back to top ↑</small>
+///     </a>
+/// </div>
+///
+///
+pub fn canberra_distance(
+  xarr: List(Float),
+  yarr: List(Float),
+  weights: option.Option(List(Float)),
+) -> Result(Float, String) {
+  case validate_lists(xarr, yarr, weights) {
+    Error(msg) ->
+      msg
+      |> Error
+    Ok(_) -> {
+      let arr: List(Float) =
+        list.zip(xarr, yarr)
+        |> list.map(canberra_distance_helper)
+
+      case weights {
+        option.None -> {
+          arr
+          |> arithmetics.float_sum(option.None)
+          |> Ok
+        }
+        _ -> {
+          arr
+          |> arithmetics.float_sum(weights)
+          |> Ok
+        }
+      }
+    }
+  }
+}
+
+fn canberra_distance_helper(tuple: #(Float, Float)) -> Float {
+  let numerator: Float =
+    piecewise.float_absolute_value({ pair.first(tuple) -. pair.second(tuple) })
+  let denominator: Float = {
+    piecewise.float_absolute_value(pair.first(tuple))
+    +. piecewise.float_absolute_value(pair.second(tuple))
+  }
+  numerator /. denominator
+}
+
+/// <div style="text-align: right;">
+///     <a href="https://github.com/gleam-community/maths/issues">
+///         <small>Spot a typo? Open an issue!</small>
+///     </a>
+/// </div>
+/// 
+/// 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 
+/// ($$w_i = 1.0\\;\forall i=1...n$$ by default).
+/// 
+/// The Bray-Curtis distance is in the range $$[0, 1]$$ if all entries $$x_i, y_i$$ are
+/// positive.
+///
+/// <details>
+///     <summary>Example:</summary>
+///
+///     import gleeunit/should
+///     import gleam/option
+///     import gleam_community/maths/metrics
+///
+///     pub fn example() {
+///       // Empty lists returns an error
+///       metrics.braycurtis_distance([], [], option.None)
+///       |> should.be_error()
+///     
+///       // Different sized lists returns an error
+///       metrics.braycurtis_distance([1.0, 2.0], [1.0, 2.0, 3.0, 4.0], option.None)
+///       |> should.be_error()
+///     
+///       // Valid inputs
+///       metrics.braycurtis_distance([1.0, 0.0], [0.0, 2.0], option.None)
+///       |> should.equal(Ok(1.0))
+///     
+///       metrics.braycurtis_distance([1.0, 2.0], [3.0, 4.0], option.Some([0.5, 1.0]))
+///       |> should.equal(Ok(0.375))
+///     }
+/// </details>
+///
+/// <div style="text-align: right;">
+///     <a href="#">
+///         <small>Back to top ↑</small>
+///     </a>
+/// </div>
+///
+///
+pub fn braycurtis_distance(
+  xarr: List(Float),
+  yarr: List(Float),
+  weights: option.Option(List(Float)),
+) -> Result(Float, String) {
+  case validate_lists(xarr, yarr, weights) {
+    Error(msg) ->
+      msg
+      |> Error
+    Ok(_) -> {
+      let zipped_arr: List(#(Float, Float)) = list.zip(xarr, yarr)
+      let numerator_elements: List(Float) =
+        zipped_arr
+        |> list.map(fn(tuple: #(Float, Float)) -> Float {
+          piecewise.float_absolute_value({
+            pair.first(tuple) -. pair.second(tuple)
+          })
+        })
+      let denominator_elements: List(Float) =
+        zipped_arr
+        |> list.map(fn(tuple: #(Float, Float)) -> Float {
+          piecewise.float_absolute_value({
+            pair.first(tuple) +. pair.second(tuple)
+          })
+        })
+
+      case weights {
+        option.None -> {
+          let numerator =
+            numerator_elements
+            |> arithmetics.float_sum(option.None)
+          let denominator =
+            denominator_elements
+            |> arithmetics.float_sum(option.None)
+          { numerator /. denominator }
+          |> Ok
+        }
+        _ -> {
+          let numerator =
+            numerator_elements
+            |> arithmetics.float_sum(weights)
+          let denominator =
+            denominator_elements
+            |> arithmetics.float_sum(weights)
+          { numerator /. denominator }
+          |> Ok
+        }
+      }
+    }
+  }
+}
diff --git a/src/gleam_community/maths/piecewise.gleam b/src/gleam_community/maths/piecewise.gleam
index da48e0f..452e93d 100644
--- a/src/gleam_community/maths/piecewise.gleam
+++ b/src/gleam_community/maths/piecewise.gleam
@@ -1,6 +1,6 @@
-////<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/katex.min.css" integrity="sha384-GvrOXuhMATgEsSwCs4smul74iXGOixntILdUW9XmUC6+HX0sLNAK3q71HotJqlAn" crossorigin="anonymous">
-////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/katex.min.js" integrity="sha384-cpW21h6RZv/phavutF+AuVYrr+dA8xD9zs6FwLpaCct6O9ctzYFfFr4dgmgccOTx" crossorigin="anonymous"></script>
-////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/contrib/auto-render.min.js" integrity="sha384-+VBxd3r6XgURycqtZ117nYw44OOcIax56Z4dCRWbxyPt0Koah1uHoK0o4+/RRE05" crossorigin="anonymous"></script>
+////<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/katex.min.css" integrity="sha384-wcIxkf4k558AjM3Yz3BBFQUbk/zgIYC2R0QpeeYb+TwlBVMrlgLqwRjRtGZiK7ww" crossorigin="anonymous">
+////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/katex.min.js" integrity="sha384-hIoBPJpTUs74ddyc4bFZSM1TVlQDA60VBbJS0oA934VSz82sBx1X7kSx2ATBDIyd" crossorigin="anonymous"></script>
+////<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/contrib/auto-render.min.js" integrity="sha384-43gviWU0YVjaDtb/GhzOouOXtZMP/7XUzwPTstBeZFe/+rCMvRwr4yROQP43s0Xk" crossorigin="anonymous"></script>
 ////<script>
 ////    document.addEventListener("DOMContentLoaded", function() {
 ////        renderMathInElement(document.body, {
@@ -490,7 +490,7 @@ fn do_ceiling(a: Float) -> Float
 /// The absolute value:
 ///
 /// \\[
-///  \forall x, y \in \mathbb{R}, \\; |x|  \in \mathbb{R}_{+}.
+///  \forall x \in \mathbb{R}, \\; |x|  \in \mathbb{R}_{+}. 
 /// \\]
 ///
 /// The function takes an input $$x$$ and returns a positive float value.
@@ -519,7 +519,7 @@ pub fn float_absolute_value(x: Float) -> Float {
 /// The absolute value:
 ///
 /// \\[
-///  \forall x, y \in \mathbb{Z}, \\; |x|  \in \mathbb{Z}_{+}.
+///  \forall x \in \mathbb{Z}, \\; |x|  \in \mathbb{Z}_{+}. 
 /// \\]
 ///
 /// The function takes an input $$x$$ and returns a positive integer value.
@@ -592,7 +592,8 @@ pub fn float_absolute_difference(a: Float, b: Float) -> Float {
 ///  \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 the absolute difference of the inputs.
+/// The function takes two inputs $$x$$ and $$y$$ and returns a positive integer
+/// value which is the the absolute difference of the inputs.
 ///
 /// <details>
 ///     <summary>Example:</summary>
@@ -698,7 +699,8 @@ fn do_int_sign(a: Int) -> Int
 ///     </a>
 /// </div>
 ///
-/// The function takes two arguments $$x, y \in \mathbb{R}$$ and returns $$x$$ such that it has the same sign as $$y$$.
+/// The function takes two arguments $$x, y \in \mathbb{R}$$ and returns $$x$$ 
+/// such that it has the same sign as $$y$$.
 ///
 /// <div style="text-align: right;">
 ///     <a href="#">
@@ -723,7 +725,8 @@ pub fn float_copy_sign(x: Float, y: Float) -> Float {
 ///     </a>
 /// </div>
 ///
-/// The function takes two arguments $$x, y \in \mathbb{Z}$$ and returns $$x$$ such that it has the same sign as $$y$$.
+/// The function takes two arguments $$x, y \in \mathbb{Z}$$ and returns $$x$$ 
+/// such that it has the same sign as $$y$$.
 ///
 /// <div style="text-align: right;">
 ///     <a href="#">
diff --git a/src/gleam_community/maths/predicates.gleam b/src/gleam_community/maths/predicates.gleam
index f8d357c..e13f41d 100644
--- a/src/gleam_community/maths/predicates.gleam
+++ b/src/gleam_community/maths/predicates.gleam
@@ -23,7 +23,8 @@
 //// 
 //// ---
 //// 
-//// Predicates: A module containing functions for testing various mathematical properties of numbers.
+//// Predicates: A module containing functions for testing various mathematical 
+//// properties of numbers.
 //// 
 //// * **Tests**
 ////   * [`is_close`](#is_close)
@@ -33,6 +34,7 @@
 ////   * [`is_perfect`](#is_perfect)
 ////   * [`is_even`](#is_even)
 ////   * [`is_odd`](#is_odd)
+////   * [`is_prime`](#is_prime)
 
 import gleam/pair
 import gleam/int
@@ -49,8 +51,9 @@ import gleam_community/maths/arithmetics
 /// </div>
 ///
 /// Determine if a given value $$a$$ is close to or equivalent to a reference value 
-/// $$b$$ 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:
+/// $$b$$ 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:
 ///
 /// \\[
 ///     \|a - b\| \leq (a_{tol} + r_{tol} \cdot \|b\|)
@@ -61,7 +64,7 @@ import gleam_community/maths/arithmetics
 ///     <summary>Example</summary>
 ///
 ///     import gleeunit/should
-///     import gleam_community/maths/tests
+///     import gleam_community/maths/predicates
 ///
 ///     pub fn example () {
 ///       let val: Float = 99.
@@ -108,14 +111,15 @@ fn float_absolute_difference(a: Float, b: Float) -> Float {
 ///     </a>
 /// </div>
 ///
-/// Determine if a list of values are close to or equivalent to a another list of reference values.
+/// Determine if a list of values are close to or equivalent to a another list of
+/// reference values.
 ///
 /// <details>
 ///     <summary>Example:</summary>
 ///
 ///     import gleeunit/should
 ///     import gleam/list
-///     import gleam_community/maths/tests
+///     import gleam_community/maths/predicates
 ///
 ///     pub fn example () {
 ///       let val: Float = 99.
@@ -126,7 +130,7 @@ fn float_absolute_difference(a: Float, b: Float) -> Float {
 ///       // if 'val' is within 1 percent of 'ref_val' +/- 0.1
 ///       let rtol: Float = 0.01
 ///       let atol: Float = 0.10
-///       tests.all_close(xarr, yarr, rtol, atol)
+///       predicates.all_close(xarr, yarr, rtol, atol)
 ///       |> fn(zarr: Result(List(Bool), String)) -> Result(Bool, Nil) {
 ///         case zarr {
 ///           Ok(arr) ->
@@ -175,19 +179,20 @@ pub fn all_close(
 ///
 /// Determine if a given value is fractional.
 /// 
-/// `True` is returned if the given value is fractional, otherwise `False` is returned. 
+/// `True` is returned if the given value is fractional, otherwise `False` is 
+/// returned. 
 /// 
 /// <details>
 ///     <summary>Example</summary>
 ///
 ///     import gleeunit/should
-///     import gleam_community/maths/tests
+///     import gleam_community/maths/predicates
 ///
 ///     pub fn example () {
-///       tests.is_fractional(0.3333)
+///       predicates.is_fractional(0.3333)
 ///       |> should.equal(True)
 ///       
-///       tests.is_fractional(1.0)
+///       predicates.is_fractional(1.0)
 ///       |> should.equal(False)
 ///     }
 /// </details>
@@ -212,21 +217,22 @@ fn do_ceiling(a: Float) -> Float
 ///     </a>
 /// </div>
 ///
-/// A function that tests whether a given integer value $$x \in \mathbb{Z}$$ is a power of another integer value $$y \in \mathbb{Z}$$.  
+/// A function that tests whether a given integer value $$x \in \mathbb{Z}$$ is a
+/// power of another integer value $$y \in \mathbb{Z}$$.  
 ///
 /// <details>
 ///     <summary>Example:</summary>
 ///
 ///     import gleeunit/should
-///     import gleam_community/maths/tests
+///     import gleam_community/maths/predicates
 ///
 ///     pub fn example() {
 ///       // Check if 4 is a power of 2 (it is)
-///       tests.is_power(4, 2)
+///       predicates.is_power(4, 2)
 ///       |> should.equal(True)
 ///
 ///       // Check if 5 is a power of 2 (it is not)
-///       tests.is_power(5, 2)
+///       predicates.is_power(5, 2)
 ///       |> should.equal(False)
 ///     }
 /// </details>
@@ -251,7 +257,9 @@ pub fn is_power(x: Int, y: Int) -> Bool {
 ///     </a>
 /// </div>
 ///
-/// A function that tests whether a given integer value $$n \in \mathbb{Z}$$ is a perfect number. A number is perfect if it is equal to the sum of its proper positive divisors.
+/// A function that tests whether a given integer value $$n \in \mathbb{Z}$$ is a
+/// perfect number. A number is perfect if it is equal to the sum of its proper 
+/// positive divisors.
 /// 
 /// <details>
 ///     <summary>Details</summary>
@@ -266,13 +274,13 @@ pub fn is_power(x: Int, y: Int) -> Bool {
 ///     <summary>Example:</summary>
 ///
 ///     import gleeunit/should
-///     import gleam_community/maths/tests
+///     import gleam_community/maths/predicates
 ///
 ///     pub fn example() {
-///       tests.is_perfect(6)
+///       predicates.is_perfect(6)
 ///       |> should.equal(True)
 ///
-///       tests.is_perfect(28)
+///       predicates.is_perfect(28)
 ///       |> should.equal(True)
 ///     }
 /// </details>
@@ -308,13 +316,13 @@ fn do_sum(arr: List(Int)) -> Int {
 ///     <summary>Example:</summary>
 ///
 ///     import gleeunit/should
-///     import gleam_community/maths/tests
+///     import gleam_community/maths/predicates
 ///
 ///     pub fn example() {
-///       tests.is_even(-3)
+///       predicates.is_even(-3)
 ///       |> should.equal(False)
 ///     
-///       tests.is_even(-4)
+///       predicates.is_even(-4)
 ///       |> should.equal(True)
 ///     }
 /// </details>
@@ -341,13 +349,13 @@ pub fn is_even(x: Int) -> Bool {
 ///     <summary>Example:</summary>
 ///
 ///     import gleeunit/should
-///     import gleam_community/maths/tests
+///     import gleam_community/maths/predicates
 ///
 ///     pub fn example() {
-///       tests.is_odd(-3)
+///       predicates.is_odd(-3)
 ///       |> should.equal(True)
 ///     
-///       tests.is_odd(-4)
+///       predicates.is_odd(-4)
 ///       |> should.equal(False)
 ///     }
 /// </details>
@@ -361,3 +369,97 @@ pub fn is_even(x: Int) -> Bool {
 pub fn is_odd(x: Int) -> Bool {
   x % 2 != 0
 }
+
+/// <div style="text-align: right;">
+///     <a href="https://github.com/gleam-community/maths/issues">
+///         <small>Spot a typo? Open an issue!</small>
+///     </a>
+/// </div>
+///
+/// A function that tests whether a given integer value $$x \in \mathbb{Z}$$ is a 
+/// prime number. A prime number is a natural number greater than 1 that has no 
+/// positive divisors other than 1 and itself.
+/// 
+/// The function uses the Miller-Rabin primality test to assess if $$x$$ is prime. 
+/// It is a probabilistic test, so it can mistakenly identify a composite number 
+/// as prime. However, the probability of such errors decreases with more testing
+/// iterations (the function uses 64 iterations internally, which is typically 
+/// more than sufficient). The Miller-Rabin test is particularly useful for large
+/// numbers.
+/// 
+/// <details>
+///     <summary>Details</summary>
+///
+///   Examples of prime numbers:
+///   - $$2$$ is a prime number since it has only two divisors: $$1$$ and $$2$$.
+///   - $$7$$ is a prime number since it has only two divisors: $$1$$ and $$7$$.
+///   - $$4$$ is not a prime number since it has divisors other than $$1$$ and itself, such as $$2$$.
+///
+/// </details>
+///
+/// <details>
+///     <summary>Example:</summary>
+///
+///     import gleeunit/should
+///     import gleam_community/maths/predicates
+///
+///     pub fn example() {
+///       predicates.is_prime(2)
+///       |> should.equal(True)
+///
+///       predicates.is_prime(4)
+///       |> should.equal(False)
+///       
+///       // Test the 2nd Carmichael number
+///       predicates.is_prime(1105)
+///       |> should.equal(False)
+///     }
+/// </details>
+///
+/// <div style="text-align: right;">
+///     <a href="#">
+///         <small>Back to top ↑</small>
+///     </a>
+/// </div>
+///
+pub fn is_prime(x: Int) -> Bool {
+  case x {
+    x if x < 2 -> {
+      False
+    }
+    x if x == 2 -> {
+      True
+    }
+    _ -> {
+      miller_rabin_test(x, 64)
+    }
+  }
+}
+
+fn miller_rabin_test(n: Int, k: Int) -> Bool {
+  case n, k {
+    _, 0 -> True
+    _, _ -> {
+      // Generate a random int in the range [2, n]
+      let random_candidate: Int = 2 + int.random(n - 2)
+      case powmod_with_check(random_candidate, n - 1, n) == 1 {
+        True -> miller_rabin_test(n, k - 1)
+        False -> False
+      }
+    }
+  }
+}
+
+fn powmod_with_check(base: Int, exponent: Int, modulus: Int) -> Int {
+  case exponent, { exponent % 2 } == 0 {
+    0, _ -> 1
+    _, True -> {
+      let x: Int = powmod_with_check(base, exponent / 2, modulus)
+      case { x * x } % modulus, x != 1 && x != { modulus - 1 } {
+        1, True -> 0
+        _, _ -> { x * x } % modulus
+      }
+    }
+    _, _ -> { base * powmod_with_check(base, exponent - 1, modulus) } % modulus
+  }
+}
diff --git a/src/gleam_community/maths/sequences.gleam b/src/gleam_community/maths/sequences.gleam
index 9a5cb56..0ec8118 100644
--- a/src/gleam_community/maths/sequences.gleam
+++ b/src/gleam_community/maths/sequences.gleam
@@ -23,7 +23,8 @@
 //// 
 //// ---
 //// 
-//// Sequences: A module containing functions for generating various types of sequences, ranges and intervals.
+//// Sequences: A module containing functions for generating various types of 
+//// sequences, ranges and intervals.
 //// 
 //// * **Ranges and intervals**
 ////   * [`arange`](#arange)
@@ -42,8 +43,10 @@ import gleam/list
 ///     </a>
 /// </div>
 ///
-/// The function returns a list with evenly spaced values within a given interval based on a start, stop value and a given increment (step-length) between consecutive values. 
-/// The list returned includes the given start value but excludes the stop value.
+/// The function returns a list with evenly spaced values within a given interval 
+/// based on a start, stop value and a given increment (step-length) between 
+/// consecutive values. The list returned includes the given start value but 
+/// excludes the stop value.
 ///
 /// <details>
 ///     <summary>Example:</summary>
@@ -98,7 +101,8 @@ pub fn arange(start: Float, stop: Float, step: Float) -> List(Float) {
 ///     </a>
 /// </div>
 ///
-/// Generate a linearly spaced list of points over a specified interval. The endpoint of the interval can optionally be included/excluded.
+/// Generate a linearly spaced list of points over a specified interval. The 
+/// endpoint of the interval can optionally be included/excluded.
 ///
 /// <details>
 ///     <summary>Example:</summary>
@@ -176,7 +180,8 @@ pub fn linear_space(
 ///     </a>
 /// </div>
 ///
-/// Generate a logarithmically spaced list of points over a specified interval. The endpoint of the interval can optionally be included/excluded.
+/// Generate a logarithmically spaced list of points over a specified interval. The 
+/// endpoint of the interval can optionally be included/excluded.
 ///
 /// <details>
 ///     <summary>Example:</summary>
@@ -236,8 +241,11 @@ pub fn logarithmic_space(
 ///     </a>
 /// </div>
 ///
-/// The function returns a list of numbers spaced evenly on a log scale (a geometric progression). Each point in the list is a constant multiple of the previous.
-/// The function is similar to the [`logarithmic_space`](#logarithmic_space) function, but with endpoints specified directly.
+/// The function returns a list of numbers spaced evenly on a log scale (a 
+/// geometric progression). Each point in the list is a constant multiple of the 
+/// previous. The function is similar to the 
+/// [`logarithmic_space`](#logarithmic_space) function, but with endpoints 
+/// specified directly.
 ///
 /// <details>
 ///     <summary>Example:</summary>
@@ -283,7 +291,7 @@ pub fn geometric_space(
 ) -> Result(List(Float), String) {
   case start == 0.0 || stop == 0.0 {
     True ->
-      ""
+      "Invalid input: Neither 'start' nor 'stop' can be zero, as they must be non-zero for logarithmic calculations."
       |> Error
     False ->
       case num > 0 {
diff --git a/src/gleam_community/maths/special.gleam b/src/gleam_community/maths/special.gleam
index 12e2f87..6b86e5a 100644
--- a/src/gleam_community/maths/special.gleam
+++ b/src/gleam_community/maths/special.gleam
@@ -100,8 +100,8 @@ pub fn erf(x: Float) -> Float {
 ///     </a>
 /// </div>
 ///
-/// 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 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.
@@ -174,7 +174,7 @@ pub fn incomplete_gamma(a: Float, x: Float) -> Result(Float, String) {
     }
 
     False ->
-      "Invlaid input argument: a <= 0 or x < 0. Valid input is a > 0 and x >= 0."
+      "Invalid input argument: a <= 0 or x < 0. Valid input is a > 0 and x >= 0."
       |> Error
   }
 }
diff --git a/test/gleam_community/maths/arithmetics_test.gleam b/test/gleam_community/maths/arithmetics_test.gleam
index aa694b7..990fce6 100644
--- a/test/gleam_community/maths/arithmetics_test.gleam
+++ b/test/gleam_community/maths/arithmetics_test.gleam
@@ -1,5 +1,6 @@
 import gleam_community/maths/arithmetics
 import gleeunit/should
+import gleam/option
 
 pub fn int_gcd_test() {
   arithmetics.gcd(1, 1)
@@ -100,16 +101,16 @@ pub fn int_divisors_test() {
 pub fn float_list_sum_test() {
   // An empty list returns 0
   []
-  |> arithmetics.float_sum()
+  |> arithmetics.float_sum(option.None)
   |> should.equal(0.0)
 
   // Valid input returns a result
   [1.0, 2.0, 3.0]
-  |> arithmetics.float_sum()
+  |> arithmetics.float_sum(option.None)
   |> should.equal(6.0)
 
   [-2.0, 4.0, 6.0]
-  |> arithmetics.float_sum()
+  |> arithmetics.float_sum(option.None)
   |> should.equal(8.0)
 }
 
@@ -132,17 +133,17 @@ pub fn int_list_sum_test() {
 pub fn float_list_product_test() {
   // An empty list returns 0
   []
-  |> arithmetics.float_product()
-  |> should.equal(1.0)
+  |> arithmetics.float_product(option.None)
+  |> should.equal(Ok(1.0))
 
   // Valid input returns a result
   [1.0, 2.0, 3.0]
-  |> arithmetics.float_product()
-  |> should.equal(6.0)
+  |> arithmetics.float_product(option.None)
+  |> should.equal(Ok(6.0))
 
   [-2.0, 4.0, 6.0]
-  |> arithmetics.float_product()
-  |> should.equal(-48.0)
+  |> arithmetics.float_product(option.None)
+  |> should.equal(Ok(-48.0))
 }
 
 pub fn int_list_product_test() {
@@ -196,16 +197,16 @@ pub fn int_list_cumulative_sum_test() {
 pub fn float_list_cumulative_product_test() {
   // An empty lists returns an empty list
   []
-  |> arithmetics.float_cumumlative_product()
+  |> arithmetics.float_cumulative_product()
   |> should.equal([])
 
   // Valid input returns a result
   [1.0, 2.0, 3.0]
-  |> arithmetics.float_cumumlative_product()
+  |> arithmetics.float_cumulative_product()
   |> should.equal([1.0, 2.0, 6.0])
 
   [-2.0, 4.0, 6.0]
-  |> arithmetics.float_cumumlative_product()
+  |> arithmetics.float_cumulative_product()
   |> should.equal([-2.0, -8.0, -48.0])
 }
 
diff --git a/test/gleam_community/maths/metrics_test.gleam b/test/gleam_community/maths/metrics_test.gleam
index 8e407e6..43263cb 100644
--- a/test/gleam_community/maths/metrics_test.gleam
+++ b/test/gleam_community/maths/metrics_test.gleam
@@ -2,160 +2,292 @@ import gleam_community/maths/elementary
 import gleam_community/maths/metrics
 import gleam_community/maths/predicates
 import gleeunit/should
+import gleam/set
+import gleam/option
 
 pub fn float_list_norm_test() {
   let assert Ok(tol) = elementary.power(-10.0, -6.0)
 
   // An empty lists returns 0.0
   []
-  |> metrics.norm(1.0)
-  |> should.equal(0.0)
+  |> metrics.norm(1.0, option.None)
+  |> should.equal(Ok(0.0))
 
   // Check that the function agrees, at some arbitrary input
   // points, with known function values
-  [1.0, 1.0, 1.0]
-  |> metrics.norm(1.0)
+  let assert Ok(result) =
+    [1.0, 1.0, 1.0]
+    |> metrics.norm(1.0, option.None)
+  result
   |> predicates.is_close(3.0, 0.0, tol)
   |> should.be_true()
 
-  [1.0, 1.0, 1.0]
-  |> metrics.norm(-1.0)
+  let assert Ok(result) =
+    [1.0, 1.0, 1.0]
+    |> metrics.norm(-1.0, option.None)
+  result
   |> predicates.is_close(0.3333333333333333, 0.0, tol)
   |> should.be_true()
 
-  [-1.0, -1.0, -1.0]
-  |> metrics.norm(-1.0)
+  let assert Ok(result) =
+    [-1.0, -1.0, -1.0]
+    |> metrics.norm(-1.0, option.None)
+  result
   |> predicates.is_close(0.3333333333333333, 0.0, tol)
   |> should.be_true()
 
-  [-1.0, -1.0, -1.0]
-  |> metrics.norm(1.0)
+  let assert Ok(result) =
+    [-1.0, -1.0, -1.0]
+    |> metrics.norm(1.0, option.None)
+  result
   |> predicates.is_close(3.0, 0.0, tol)
   |> should.be_true()
 
-  [-1.0, -2.0, -3.0]
-  |> metrics.norm(-10.0)
+  let assert Ok(result) =
+    [-1.0, -2.0, -3.0]
+    |> metrics.norm(-10.0, option.None)
+  result
   |> predicates.is_close(0.9999007044905545, 0.0, tol)
   |> should.be_true()
 
-  [-1.0, -2.0, -3.0]
-  |> metrics.norm(-100.0)
+  let assert Ok(result) =
+    [-1.0, -2.0, -3.0]
+    |> metrics.norm(-100.0, option.None)
+  result
   |> predicates.is_close(1.0, 0.0, tol)
   |> should.be_true()
 
-  [-1.0, -2.0, -3.0]
-  |> metrics.norm(2.0)
+  let assert Ok(result) =
+    [-1.0, -2.0, -3.0]
+    |> metrics.norm(2.0, option.None)
+  result
   |> predicates.is_close(3.7416573867739413, 0.0, tol)
   |> should.be_true()
 }
 
-pub fn float_list_manhatten_test() {
+pub fn float_list_manhattan_test() {
   let assert Ok(tol) = elementary.power(-10.0, -6.0)
 
-  // Empty lists returns 0.0
-  metrics.manhatten_distance([], [])
-  |> should.equal(Ok(0.0))
-
-  // Differing lengths returns error
-  metrics.manhatten_distance([], [1.0])
+  // Empty lists returns an error
+  metrics.manhattan_distance([], [], option.None)
   |> should.be_error()
 
-  // Manhatten distance (p = 1)
-  let assert Ok(result) = metrics.manhatten_distance([0.0, 0.0], [1.0, 2.0])
+  // Differing lengths returns error
+  metrics.manhattan_distance([], [1.0], option.None)
+  |> should.be_error()
+
+  // Try with valid input (same as Minkowski distance with p = 1)
+  let assert Ok(result) =
+    metrics.manhattan_distance([0.0, 0.0], [1.0, 2.0], option.None)
   result
   |> predicates.is_close(3.0, 0.0, tol)
   |> should.be_true()
+
+  metrics.manhattan_distance([1.0, 2.0, 3.0], [4.0, 5.0, 6.0], option.None)
+  |> should.equal(Ok(9.0))
+
+  metrics.manhattan_distance(
+    [1.0, 2.0, 3.0],
+    [4.0, 5.0, 6.0],
+    option.Some([1.0, 1.0, 1.0]),
+  )
+  |> should.equal(Ok(9.0))
+
+  metrics.manhattan_distance(
+    [1.0, 2.0, 3.0],
+    [4.0, 5.0, 6.0],
+    option.Some([1.0, 2.0, 3.0]),
+  )
+  |> should.equal(Ok(18.0))
+
+  // Try invalid input with weights (different sized lists returns an error)
+  metrics.manhattan_distance(
+    [1.0, 2.0, 3.0],
+    [4.0, 5.0, 6.0],
+    option.Some([7.0, 8.0]),
+  )
+  |> should.be_error()
+
+  // Try invalid input with weights that are negative
+  metrics.manhattan_distance(
+    [1.0, 2.0, 3.0],
+    [4.0, 5.0, 6.0],
+    option.Some([-7.0, -8.0, -9.0]),
+  )
+  |> should.be_error()
 }
 
-// pub fn int_list_manhatten_test() {
-//   // Empty lists returns 0
-//   metrics.int_manhatten_distance([], [])
-//   |> should.equal(Ok(0))
-
-//   // Differing lengths returns error
-//   metrics.int_manhatten_distance([], [1])
-//   |> should.be_error()
-
-//   let assert Ok(result) = metrics.int_manhatten_distance([0, 0], [1, 2])
-//   result
-//   |> should.equal(3)
-// }
-
 pub fn float_list_minkowski_test() {
   let assert Ok(tol) = elementary.power(-10.0, -6.0)
 
-  // Empty lists returns 0.0
-  metrics.minkowski_distance([], [], 1.0)
-  |> should.equal(Ok(0.0))
+  // Empty lists returns an error
+  metrics.minkowski_distance([], [], 1.0, option.None)
+  |> should.be_error()
 
   // Differing lengths returns error
-  metrics.minkowski_distance([], [1.0], 1.0)
+  metrics.minkowski_distance([], [1.0], 1.0, option.None)
   |> should.be_error()
 
   // Test order < 1
-  metrics.minkowski_distance([0.0, 0.0], [0.0, 0.0], -1.0)
+  metrics.minkowski_distance([0.0, 0.0], [0.0, 0.0], -1.0, option.None)
   |> should.be_error()
 
   // Check that the function agrees, at some arbitrary input
   // points, with known function values
   let assert Ok(result) =
-    metrics.minkowski_distance([1.0, 1.0], [1.0, 1.0], 1.0)
+    metrics.minkowski_distance([1.0, 1.0], [1.0, 1.0], 1.0, option.None)
   result
   |> predicates.is_close(0.0, 0.0, tol)
   |> should.be_true()
 
   let assert Ok(result) =
-    metrics.minkowski_distance([0.0, 0.0], [1.0, 1.0], 10.0)
+    metrics.minkowski_distance([0.0, 0.0], [1.0, 1.0], 10.0, option.None)
   result
   |> predicates.is_close(1.0717734625362931, 0.0, tol)
   |> should.be_true()
 
   let assert Ok(result) =
-    metrics.minkowski_distance([0.0, 0.0], [1.0, 1.0], 100.0)
+    metrics.minkowski_distance([0.0, 0.0], [1.0, 1.0], 100.0, option.None)
   result
   |> predicates.is_close(1.0069555500567189, 0.0, tol)
   |> should.be_true()
 
   let assert Ok(result) =
-    metrics.minkowski_distance([0.0, 0.0], [1.0, 1.0], 10.0)
+    metrics.minkowski_distance([0.0, 0.0], [1.0, 1.0], 10.0, option.None)
   result
   |> predicates.is_close(1.0717734625362931, 0.0, tol)
   |> should.be_true()
 
   // Euclidean distance (p = 2)
   let assert Ok(result) =
-    metrics.minkowski_distance([0.0, 0.0], [1.0, 2.0], 2.0)
+    metrics.minkowski_distance([0.0, 0.0], [1.0, 2.0], 2.0, option.None)
   result
   |> predicates.is_close(2.23606797749979, 0.0, tol)
   |> should.be_true()
 
-  // Manhatten distance (p = 1)
+  // Manhattan distance (p = 1)
   let assert Ok(result) =
-    metrics.minkowski_distance([0.0, 0.0], [1.0, 2.0], 1.0)
+    metrics.minkowski_distance([0.0, 0.0], [1.0, 2.0], 1.0, option.None)
   result
   |> predicates.is_close(3.0, 0.0, tol)
   |> should.be_true()
+
+  // Try different valid input
+  let assert Ok(result) =
+    metrics.minkowski_distance(
+      [1.0, 2.0, 3.0],
+      [4.0, 5.0, 6.0],
+      4.0,
+      option.None,
+    )
+  result
+  |> predicates.is_close(3.9482220388574776, 0.0, tol)
+  |> should.be_true()
+
+  let assert Ok(result) =
+    metrics.minkowski_distance(
+      [1.0, 2.0, 3.0],
+      [4.0, 5.0, 6.0],
+      4.0,
+      option.Some([1.0, 1.0, 1.0]),
+    )
+  result
+  |> predicates.is_close(3.9482220388574776, 0.0, tol)
+  |> should.be_true()
+
+  let assert Ok(result) =
+    metrics.minkowski_distance(
+      [1.0, 2.0, 3.0],
+      [4.0, 5.0, 6.0],
+      4.0,
+      option.Some([1.0, 2.0, 3.0]),
+    )
+  result
+  |> predicates.is_close(4.6952537402198615, 0.0, tol)
+  |> should.be_true()
+
+  // Try invalid input with weights (different sized lists returns an error)
+  metrics.minkowski_distance(
+    [1.0, 2.0, 3.0],
+    [4.0, 5.0, 6.0],
+    2.0,
+    option.Some([7.0, 8.0]),
+  )
+  |> should.be_error()
+
+  // Try invalid input with weights that are negative
+  metrics.minkowski_distance(
+    [1.0, 2.0, 3.0],
+    [4.0, 5.0, 6.0],
+    2.0,
+    option.Some([-7.0, -8.0, -9.0]),
+  )
+  |> should.be_error()
 }
 
 pub fn float_list_euclidean_test() {
   let assert Ok(tol) = elementary.power(-10.0, -6.0)
 
-  // Empty lists returns 0.0
-  metrics.euclidean_distance([], [])
-  |> should.equal(Ok(0.0))
-
-  // Differing lengths returns error
-  metrics.euclidean_distance([], [1.0])
+  // Empty lists returns an error
+  metrics.euclidean_distance([], [], option.None)
   |> should.be_error()
 
-  // Euclidean distance (p = 2)
-  let assert Ok(result) = metrics.euclidean_distance([0.0, 0.0], [1.0, 2.0])
+  // Differing lengths returns error
+  metrics.euclidean_distance([], [1.0], option.None)
+  |> should.be_error()
+
+  // Try with valid input (same as Minkowski distance with p = 2)
+  let assert Ok(result) =
+    metrics.euclidean_distance([0.0, 0.0], [1.0, 2.0], option.None)
   result
   |> predicates.is_close(2.23606797749979, 0.0, tol)
   |> should.be_true()
+
+  // Try different valid input
+  let assert Ok(result) =
+    metrics.euclidean_distance([1.0, 2.0, 3.0], [4.0, 5.0, 6.0], option.None)
+  result
+  |> predicates.is_close(5.196152422706632, 0.0, tol)
+  |> should.be_true()
+
+  let assert Ok(result) =
+    metrics.euclidean_distance(
+      [1.0, 2.0, 3.0],
+      [4.0, 5.0, 6.0],
+      option.Some([1.0, 1.0, 1.0]),
+    )
+  result
+  |> predicates.is_close(5.196152422706632, 0.0, tol)
+  |> should.be_true()
+
+  let assert Ok(result) =
+    metrics.euclidean_distance(
+      [1.0, 2.0, 3.0],
+      [4.0, 5.0, 6.0],
+      option.Some([1.0, 2.0, 3.0]),
+    )
+  result
+  |> predicates.is_close(7.3484692283495345, 0.0, tol)
+  |> should.be_true()
+
+  // Try invalid input with weights (different sized lists returns an error)
+  metrics.euclidean_distance(
+    [1.0, 2.0, 3.0],
+    [4.0, 5.0, 6.0],
+    option.Some([7.0, 8.0]),
+  )
+  |> should.be_error()
+
+  // Try invalid input with weights that are negative
+  metrics.euclidean_distance(
+    [1.0, 2.0, 3.0],
+    [4.0, 5.0, 6.0],
+    option.Some([-7.0, -8.0, -9.0]),
+  )
+  |> should.be_error()
 }
 
-pub fn example_mean_test() {
+pub fn mean_test() {
   // An empty list returns an error
   []
   |> metrics.mean()
@@ -167,7 +299,7 @@ pub fn example_mean_test() {
   |> should.equal(Ok(2.0))
 }
 
-pub fn example_median_test() {
+pub fn median_test() {
   // An empty list returns an error
   []
   |> metrics.median()
@@ -183,7 +315,7 @@ pub fn example_median_test() {
   |> should.equal(Ok(2.5))
 }
 
-pub fn example_variance_test() {
+pub fn variance_test() {
   // Degrees of freedom
   let ddof: Int = 1
 
@@ -198,7 +330,7 @@ pub fn example_variance_test() {
   |> should.equal(Ok(1.0))
 }
 
-pub fn example_standard_deviation_test() {
+pub fn standard_deviation_test() {
   // Degrees of freedom
   let ddof: Int = 1
 
@@ -212,3 +344,330 @@ pub fn example_standard_deviation_test() {
   |> metrics.standard_deviation(ddof)
   |> should.equal(Ok(1.0))
 }
+
+pub fn jaccard_index_test() {
+  metrics.jaccard_index(set.from_list([]), set.from_list([]))
+  |> should.equal(0.0)
+
+  let set_a: set.Set(Int) = set.from_list([0, 1, 2, 5, 6, 8, 9])
+  let set_b: set.Set(Int) = set.from_list([0, 2, 3, 4, 5, 7, 9])
+  metrics.jaccard_index(set_a, set_b)
+  |> should.equal(4.0 /. 10.0)
+
+  let set_c: set.Set(Int) = set.from_list([0, 1, 2, 3, 4, 5])
+  let set_d: set.Set(Int) = set.from_list([6, 7, 8, 9, 10])
+  metrics.jaccard_index(set_c, set_d)
+  |> should.equal(0.0 /. 11.0)
+
+  let set_e: set.Set(String) = set.from_list(["cat", "dog", "hippo", "monkey"])
+  let set_f: set.Set(String) =
+    set.from_list(["monkey", "rhino", "ostrich", "salmon"])
+  metrics.jaccard_index(set_e, set_f)
+  |> should.equal(1.0 /. 7.0)
+}
+
+pub fn sorensen_dice_coefficient_test() {
+  metrics.sorensen_dice_coefficient(set.from_list([]), set.from_list([]))
+  |> should.equal(0.0)
+
+  let set_a: set.Set(Int) = set.from_list([0, 1, 2, 5, 6, 8, 9])
+  let set_b: set.Set(Int) = set.from_list([0, 2, 3, 4, 5, 7, 9])
+  metrics.sorensen_dice_coefficient(set_a, set_b)
+  |> should.equal(2.0 *. 4.0 /. { 7.0 +. 7.0 })
+
+  let set_c: set.Set(Int) = set.from_list([0, 1, 2, 3, 4, 5])
+  let set_d: set.Set(Int) = set.from_list([6, 7, 8, 9, 10])
+  metrics.sorensen_dice_coefficient(set_c, set_d)
+  |> should.equal(2.0 *. 0.0 /. { 6.0 +. 5.0 })
+
+  let set_e: set.Set(String) = set.from_list(["cat", "dog", "hippo", "monkey"])
+  let set_f: set.Set(String) =
+    set.from_list(["monkey", "rhino", "ostrich", "salmon", "spider"])
+  metrics.sorensen_dice_coefficient(set_e, set_f)
+  |> should.equal(2.0 *. 1.0 /. { 4.0 +. 5.0 })
+}
+
+pub fn overlap_coefficient_test() {
+  metrics.overlap_coefficient(set.from_list([]), set.from_list([]))
+  |> should.equal(0.0)
+
+  let set_a: set.Set(Int) = set.from_list([0, 1, 2, 5, 6, 8, 9])
+  let set_b: set.Set(Int) = set.from_list([0, 2, 3, 4, 5, 7, 9])
+  metrics.overlap_coefficient(set_a, set_b)
+  |> should.equal(4.0 /. 7.0)
+
+  let set_c: set.Set(Int) = set.from_list([0, 1, 2, 3, 4, 5])
+  let set_d: set.Set(Int) = set.from_list([6, 7, 8, 9, 10])
+  metrics.overlap_coefficient(set_c, set_d)
+  |> should.equal(0.0 /. 5.0)
+
+  let set_e: set.Set(String) =
+    set.from_list(["horse", "dog", "hippo", "monkey", "bird"])
+  let set_f: set.Set(String) =
+    set.from_list(["monkey", "bird", "ostrich", "salmon"])
+  metrics.overlap_coefficient(set_e, set_f)
+  |> should.equal(2.0 /. 4.0)
+}
+
+pub fn cosine_similarity_test() {
+  let assert Ok(tol) = elementary.power(-10.0, -6.0)
+
+  // Empty lists returns an error
+  metrics.cosine_similarity([], [], option.None)
+  |> should.be_error()
+
+  // One empty list returns an error
+  metrics.cosine_similarity([1.0, 2.0, 3.0], [], option.None)
+  |> should.be_error()
+
+  // One empty list returns an error
+  metrics.cosine_similarity([], [1.0, 2.0, 3.0], option.None)
+  |> should.be_error()
+
+  // Different sized lists returns an error
+  metrics.cosine_similarity([1.0, 2.0], [1.0, 2.0, 3.0, 4.0], option.None)
+  |> should.be_error()
+
+  // Two orthogonal vectors (represented by lists)
+  metrics.cosine_similarity([-1.0, 1.0, 0.0], [1.0, 1.0, -1.0], option.None)
+  |> should.equal(Ok(0.0))
+
+  // Two identical (parallel) vectors (represented by lists)
+  metrics.cosine_similarity([1.0, 2.0, 3.0], [1.0, 2.0, 3.0], option.None)
+  |> should.equal(Ok(1.0))
+
+  // Two parallel, but oppositely oriented vectors (represented by lists)
+  metrics.cosine_similarity([-1.0, -2.0, -3.0], [1.0, 2.0, 3.0], option.None)
+  |> should.equal(Ok(-1.0))
+
+  // Try with arbitrary valid input 
+  let assert Ok(result) =
+    metrics.cosine_similarity([1.0, 2.0, 3.0], [4.0, 5.0, 6.0], option.None)
+  result
+  |> predicates.is_close(0.9746318461970762, 0.0, tol)
+  |> should.be_true()
+
+  // Try valid input with weights
+  let assert Ok(result) =
+    metrics.cosine_similarity(
+      [1.0, 2.0, 3.0],
+      [4.0, 5.0, 6.0],
+      option.Some([1.0, 1.0, 1.0]),
+    )
+  result
+  |> predicates.is_close(0.9746318461970762, 0.0, tol)
+  |> should.be_true()
+
+  // Try with different weights
+  let assert Ok(result) =
+    metrics.cosine_similarity(
+      [1.0, 2.0, 3.0],
+      [4.0, 5.0, 6.0],
+      option.Some([1.0, 2.0, 3.0]),
+    )
+  result
+  |> predicates.is_close(0.9855274566525745, 0.0, tol)
+  |> should.be_true()
+
+  // Try invalid input with weights (different sized lists returns an error)
+  metrics.cosine_similarity(
+    [1.0, 2.0, 3.0],
+    [4.0, 5.0, 6.0],
+    option.Some([7.0, 8.0]),
+  )
+  |> should.be_error()
+
+  // Try invalid input with weights that are negative
+  metrics.cosine_similarity(
+    [1.0, 2.0, 3.0],
+    [4.0, 5.0, 6.0],
+    option.Some([-7.0, -8.0, -9.0]),
+  )
+  |> should.be_error()
+}
+
+pub fn chebyshev_distance_test() {
+  // Empty lists returns an error
+  metrics.chebyshev_distance([], [])
+  |> should.be_error()
+
+  // One empty list returns an error
+  metrics.chebyshev_distance([1.0, 2.0, 3.0], [])
+  |> should.be_error()
+
+  // One empty list returns an error
+  metrics.chebyshev_distance([], [1.0, 2.0, 3.0])
+  |> should.be_error()
+
+  // Different sized lists returns an error
+  metrics.chebyshev_distance([1.0, 2.0], [1.0, 2.0, 3.0, 4.0])
+  |> should.be_error()
+
+  // Try different types of valid input
+  metrics.chebyshev_distance([1.0, 0.0], [0.0, 2.0])
+  |> should.equal(Ok(2.0))
+
+  metrics.chebyshev_distance([1.0, 0.0], [2.0, 0.0])
+  |> should.equal(Ok(1.0))
+
+  metrics.chebyshev_distance([1.0, 0.0], [-2.0, 0.0])
+  |> should.equal(Ok(3.0))
+
+  metrics.chebyshev_distance([-5.0, -10.0, -3.0], [-1.0, -12.0, -3.0])
+  |> should.equal(Ok(4.0))
+
+  metrics.chebyshev_distance([1.0, 2.0, 3.0], [1.0, 2.0, 3.0])
+  |> should.equal(Ok(0.0))
+}
+
+pub fn levenshtein_distance_test() {
+  // Try different types of valid input...
+
+  // Requires 5 insertions to transform the empty string into "hello"
+  metrics.levenshtein_distance("", "hello")
+  |> should.equal(5)
+  // Requires 5 deletions to remove all characters from "hello" to match the empty string
+  metrics.levenshtein_distance("hello", "")
+  |> should.equal(5)
+
+  // Requires 2 deletions to remove two 'b's and 1 substitution to change 'b' to 'a'
+  metrics.levenshtein_distance("bbb", "a")
+  |> should.equal(3)
+  // Requires 2 insertions to add two 'b's and 1 substitution to change 'a' to 'b'
+  metrics.levenshtein_distance("a", "bbb")
+  |> should.equal(3)
+
+  // No changes needed, since the strings are identical
+  metrics.levenshtein_distance("hello", "hello")
+  |> should.equal(0)
+
+  // Requires 1 substitution to change 'a' to 'u'
+  metrics.levenshtein_distance("cat", "cut")
+  |> should.equal(1)
+
+  // Requires 2 substitutions (k -> s, e -> i) and 1 insertion (g at the end)
+  metrics.levenshtein_distance("kitten", "sitting")
+  |> should.equal(3)
+
+  // Some more complex cases, involving multiple insertions, deletions, and substitutions
+  metrics.levenshtein_distance("gggtatccat", "cctaggtccct")
+  |> should.equal(6)
+
+  metrics.levenshtein_distance(
+    "This is a longer string",
+    "This is also a much longer string",
+  )
+  |> should.equal(10)
+}
+
+pub fn canberra_distance_test() {
+  // Empty lists returns an error
+  metrics.canberra_distance([], [], option.None)
+  |> should.be_error()
+
+  // One empty list returns an error
+  metrics.canberra_distance([1.0, 2.0, 3.0], [], option.None)
+  |> should.be_error()
+
+  // One empty list returns an error
+  metrics.canberra_distance([], [1.0, 2.0, 3.0], option.None)
+  |> should.be_error()
+
+  // Different sized lists returns an error
+  metrics.canberra_distance([1.0, 2.0], [1.0, 2.0, 3.0, 4.0], option.None)
+  |> should.be_error()
+
+  // Try different types of valid input
+  metrics.canberra_distance([0.0, 0.0], [0.0, 0.0], option.None)
+  |> should.equal(Ok(0.0))
+
+  metrics.canberra_distance([1.0, 2.0], [-2.0, -1.0], option.None)
+  |> should.equal(Ok(2.0))
+
+  metrics.canberra_distance([1.0, 0.0], [0.0, 2.0], option.None)
+  |> should.equal(Ok(2.0))
+
+  metrics.canberra_distance([1.0, 0.0], [2.0, 0.0], option.None)
+  |> should.equal(Ok(1.0 /. 3.0))
+
+  metrics.canberra_distance([1.0, 0.0], [0.0, 2.0], option.Some([1.0, 1.0]))
+  |> should.equal(Ok(2.0))
+
+  metrics.canberra_distance([1.0, 0.0], [0.0, 2.0], option.Some([1.0, 0.5]))
+  |> should.equal(Ok(1.5))
+
+  metrics.canberra_distance([1.0, 0.0], [0.0, 2.0], option.Some([0.5, 0.5]))
+  |> should.equal(Ok(1.0))
+
+  // Different sized lists (weights) returns an error
+  metrics.canberra_distance(
+    [1.0, 2.0, 3.0],
+    [1.0, 2.0, 3.0],
+    option.Some([1.0]),
+  )
+  |> should.be_error()
+
+  // Try invalid input with weights that are negative
+  metrics.canberra_distance(
+    [1.0, 2.0, 3.0],
+    [4.0, 5.0, 6.0],
+    option.Some([-7.0, -8.0, -9.0]),
+  )
+  |> should.be_error()
+}
+
+pub fn braycurtis_distance_test() {
+  // Empty lists returns an error
+  metrics.braycurtis_distance([], [], option.None)
+  |> should.be_error()
+
+  // One empty list returns an error
+  metrics.braycurtis_distance([1.0, 2.0, 3.0], [], option.None)
+  |> should.be_error()
+
+  // One empty list returns an error
+  metrics.braycurtis_distance([], [1.0, 2.0, 3.0], option.None)
+  |> should.be_error()
+
+  // Different sized lists returns an error
+  metrics.braycurtis_distance([1.0, 2.0], [1.0, 2.0, 3.0, 4.0], option.None)
+  |> should.be_error()
+
+  // Try different types of valid input
+  metrics.braycurtis_distance([0.0, 0.0], [0.0, 0.0], option.None)
+  |> should.equal(Ok(0.0))
+
+  metrics.braycurtis_distance([1.0, 2.0], [-2.0, -1.0], option.None)
+  |> should.equal(Ok(3.0))
+
+  metrics.braycurtis_distance([1.0, 0.0], [0.0, 2.0], option.None)
+  |> should.equal(Ok(1.0))
+
+  metrics.braycurtis_distance([1.0, 2.0], [3.0, 4.0], option.None)
+  |> should.equal(Ok(0.4))
+
+  metrics.braycurtis_distance([1.0, 2.0], [3.0, 4.0], option.Some([1.0, 1.0]))
+  |> should.equal(Ok(0.4))
+
+  metrics.braycurtis_distance([1.0, 2.0], [3.0, 4.0], option.Some([0.5, 1.0]))
+  |> should.equal(Ok(0.375))
+
+  metrics.braycurtis_distance([1.0, 2.0], [3.0, 4.0], option.Some([0.25, 0.25]))
+  |> should.equal(Ok(0.4))
+
+  // Different sized lists (weights) returns an error
+  metrics.braycurtis_distance(
+    [1.0, 2.0, 3.0],
+    [1.0, 2.0, 3.0],
+    option.Some([1.0]),
+  )
+  |> should.be_error()
+
+  // Try invalid input with weights that are negative
+  metrics.braycurtis_distance(
+    [1.0, 2.0, 3.0],
+    [4.0, 5.0, 6.0],
+    option.Some([-7.0, -8.0, -9.0]),
+  )
+  |> should.be_error()
+}
diff --git a/test/gleam_community/maths/predicates_test.gleam b/test/gleam_community/maths/predicates_test.gleam
index a7a13d8..b2e6d57 100644
--- a/test/gleam_community/maths/predicates_test.gleam
+++ b/test/gleam_community/maths/predicates_test.gleam
@@ -136,3 +136,41 @@ pub fn int_is_perfect_test() {
   predicates.is_perfect(13)
   |> should.equal(False)
 }
+
+pub fn int_is_prime_test() {
+  // Test a negative integer, i.e., not a natural number
+  predicates.is_prime(-7)
+  |> should.equal(False)
+
+  predicates.is_prime(1)
+  |> should.equal(False)
+
+  predicates.is_prime(2)
+  |> should.equal(True)
+
+  predicates.is_prime(3)
+  |> should.equal(True)
+
+  predicates.is_prime(5)
+  |> should.equal(True)
+
+  predicates.is_prime(7)
+  |> should.equal(True)
+
+  predicates.is_prime(11)
+  |> should.equal(True)
+
+  predicates.is_prime(42)
+  |> should.equal(False)
+
+  predicates.is_prime(7919)
+  |> should.equal(True)
+
+  // Test 1st Carmichael number
+  predicates.is_prime(561)
+  |> should.equal(False)
+
+  // Test 2nd Carmichael number
+  predicates.is_prime(1105)
+  |> should.equal(False)
+}