add catalan numbers implementation

Author: fen-dada

math/catalan/catalan.mbt

@@ -0,0 +1,92 @@
+///|
+struct Catalan {
+  values : Array[Int64]
+}
+
+///|
+/// Construct a Catalan number table up to `max_n`.
+///
+/// # Parameters
+/// - `max_n`: the maximum index that should be precomputed. Must be non-negative.
+///
+/// # Returns
+/// - `Catalan`: a table containing Catalan numbers from `C_0` to `C_{max_n}`.
+///
+/// # Example
+/// ```
+/// let catalan = Catalan::new(5)
+/// inspect(catalan.nth(4), content="14")
+/// ```
+pub fn Catalan::new(max_n : Int) -> Catalan {
+  if max_n < 0 {
+    abort("max_n must be non-negative")
+  }
+  let size = max_n + 1
+  let values = Array::make(size, 0L)
+  values[0] = 1L
+  for n in 1..<size {
+    let mut sum : Int64 = 0L
+    for left in 0..<n {
+      sum = sum + values[left] * values[n - 1 - left]
+    }
+    values[n] = sum
+  }
+  Catalan::{ values, }
+}
+
+///|
+/// Get the `n`-th Catalan number from the precomputed table.
+///
+/// # Parameters
+/// - `self`: precomputed Catalan table.
+/// - `n`: the index of the Catalan number.
+///
+/// # Returns
+/// - `Int64`: the value `C_n`.
+///
+/// # Example
+/// ```
+/// let catalan = Catalan::new(10)
+/// inspect(catalan.nth(10), content="16796")
+/// ```
+pub fn nth(self : Catalan, n : Int) -> Int64 {
+  if n < 0 || n >= self.values.length() {
+    abort("n is out of precomputed range")
+  }
+  self.values[n]
+}
+
+///|
+/// Retrieve all precomputed Catalan numbers as an array.
+///
+/// # Parameters
+/// - `self`: precomputed Catalan table.
+///
+/// # Returns
+/// - `Array[Int64]`: Catalan numbers from `C_0` to `C_max`.
+///
+/// # Example
+/// ```
+/// let catalan = Catalan::new(4)
+/// inspect(catalan.values(), content="[1, 1, 2, 5, 14]")
+/// ```
+pub fn values(self : Catalan) -> Array[Int64] {
+  self.values
+}
+
+///|
+/// Compute the `n`-th Catalan number on demand.
+///
+/// # Parameters
+/// - `n`: the desired index. Must be non-negative.
+///
+/// # Returns
+/// - `Int64`: the value `C_n`.
+///
+/// # Example
+/// ```
+/// inspect(catalan_number(3), content="5")
+/// ```
+pub fn catalan_number(n : Int) -> Int64 {
+  Catalan::new(n).nth(n)
+}

math/catalan/catalan_test.mbt

@@ -0,0 +1,30 @@
+///|
+test "sequence prefix" {
+  let catalan = Catalan::new(15)
+  inspect(
+    catalan.values(),
+    content="[1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845]",
+  )
+}
+
+///|
+test "on demand computation" {
+  inspect(catalan_number(0), content="1")
+  inspect(catalan_number(1), content="1")
+  inspect(catalan_number(2), content="2")
+  inspect(catalan_number(3), content="5")
+  inspect(catalan_number(7), content="429")
+  inspect(catalan_number(10), content="16796")
+}
+
+///|
+test "recurrence and large values" {
+  let catalan = Catalan::new(35)
+  let mut convolution : Int64 = 0L
+  for left in 0..<6 {
+    convolution = convolution + catalan.nth(left) * catalan.nth(5 - left)
+  }
+  inspect(convolution, content="132")
+  inspect(catalan.nth(20), content="6564120420")
+  inspect(catalan.nth(35), content="3116285494907301262")
+}

math/catalan/moon.pkg.json

@@ -0,0 +1 @@
+{ }

math/catalan/pkg.generated.mbti

@@ -0,0 +1,18 @@
+// Generated using `moon info`, DON'T EDIT IT
+package "Lampese/Algorithms-Moonbit/math/catalan"
+
+// Values
+fn catalan_number(Int) -> Int64
+
+// Errors
+
+// Types and methods
+type Catalan
+fn Catalan::new(Int) -> Self
+fn Catalan::nth(Self, Int) -> Int64
+fn Catalan::values(Self) -> Array[Int64]
+
+// Type aliases
+
+// Traits
+