mirror of
https://github.com/sigmasternchen/gleam-community-maths
synced 2025-03-15 07:59:01 +00:00
657 lines
16 KiB
Gleam
657 lines
16 KiB
Gleam
import gleam/list
|
|
import gleam/set
|
|
import gleam/yielder
|
|
import gleam_community/maths
|
|
import gleeunit/should
|
|
|
|
pub fn int_factorial_test() {
|
|
// Invalid input gives an error (factorial of negative number)
|
|
maths.factorial(-1)
|
|
|> should.be_error()
|
|
|
|
// Valid inputs for factorial of small numbers
|
|
maths.factorial(0)
|
|
|> should.equal(Ok(1))
|
|
|
|
maths.factorial(1)
|
|
|> should.equal(Ok(1))
|
|
|
|
maths.factorial(2)
|
|
|> should.equal(Ok(2))
|
|
|
|
maths.factorial(3)
|
|
|> should.equal(Ok(6))
|
|
|
|
maths.factorial(4)
|
|
|> should.equal(Ok(24))
|
|
}
|
|
|
|
pub fn int_combination_with_repetitions_test() {
|
|
// Invalid input: k < 0 should return an error
|
|
maths.combination_with_repetitions(1, -1)
|
|
|> should.be_error()
|
|
|
|
// Invalid input: n < 0 should return an error
|
|
maths.combination_with_repetitions(-1, 1)
|
|
|> should.be_error()
|
|
|
|
// Valid input: k > n with repetition allowed
|
|
maths.combination_with_repetitions(2, 3)
|
|
|> should.equal(Ok(4))
|
|
|
|
maths.combination_with_repetitions(4, 0)
|
|
|> should.equal(Ok(1))
|
|
|
|
// Valid input: k = n with repetition allows more combinations
|
|
maths.combination_with_repetitions(4, 4)
|
|
|> should.equal(Ok(35))
|
|
|
|
maths.combination_with_repetitions(4, 2)
|
|
|> should.equal(Ok(10))
|
|
|
|
maths.combination_with_repetitions(7, 5)
|
|
|> should.equal(Ok(462))
|
|
// NOTE: Tests with the 'combination' function that produce values that exceed
|
|
// precision of the JavaScript 'Number' primitive will result in errors
|
|
}
|
|
|
|
pub fn int_combination_without_repetitions_test() {
|
|
// Valid input: k > n without repetition gives 0 combinations
|
|
maths.combination(2, 3)
|
|
|> should.equal(Ok(0))
|
|
|
|
// Valid input: k = n without repetition gives 1 combination
|
|
maths.combination(4, 4)
|
|
|> should.equal(Ok(1))
|
|
|
|
// Valid input: zero combinations (k=0) should always yield 1 combination
|
|
maths.combination(4, 0)
|
|
|> should.equal(Ok(1))
|
|
|
|
// Valid input: k < n without and with repetition
|
|
maths.combination(4, 2)
|
|
|> should.equal(Ok(6))
|
|
|
|
// Valid input with larger values of n and k
|
|
maths.combination(7, 5)
|
|
|> should.equal(Ok(21))
|
|
}
|
|
|
|
pub fn math_permutation_with_repetitions_test() {
|
|
// Invalid input: k < 0 should return an error
|
|
maths.permutation_with_repetitions(1, -1)
|
|
|> should.be_error()
|
|
|
|
// Valid input: k > n with repetition allowed gives non-zero permutations
|
|
maths.permutation_with_repetitions(2, 3)
|
|
|> should.equal(Ok(8))
|
|
|
|
maths.permutation_with_repetitions(4, 0)
|
|
|> should.equal(Ok(1))
|
|
|
|
// Valid input: k = n permutations with repetition
|
|
maths.permutation_with_repetitions(4, 4)
|
|
|> should.equal(Ok(256))
|
|
|
|
maths.permutation_with_repetitions(4, 2)
|
|
|> should.equal(Ok(16))
|
|
|
|
maths.permutation_with_repetitions(6, 2)
|
|
|> should.equal(Ok(36))
|
|
|
|
maths.permutation_with_repetitions(6, 3)
|
|
|> should.equal(Ok(216))
|
|
}
|
|
|
|
pub fn math_permutation_without_repetitions_test() {
|
|
// Invalid input: k < 0 should return an error
|
|
maths.permutation(1, -1)
|
|
|> should.be_error()
|
|
|
|
// Invalid input: n < 0 should return an error
|
|
maths.permutation(-1, 1)
|
|
|> should.be_error()
|
|
|
|
// Valid input: k > n without repetition gives 0 permutations
|
|
maths.permutation(2, 3)
|
|
|> should.equal(Ok(0))
|
|
|
|
// Valid input: k = 0 should always yield 1 permutation
|
|
maths.permutation(4, 0)
|
|
|> should.equal(Ok(1))
|
|
|
|
// Valid input: k = n permutations without repetition
|
|
maths.permutation(4, 4)
|
|
|> should.equal(Ok(24))
|
|
|
|
// Valid input: k < n permutations without and with repetition
|
|
maths.permutation(4, 2)
|
|
|> should.equal(Ok(12))
|
|
|
|
// Valid input with larger values of n and k
|
|
maths.permutation(6, 2)
|
|
|> should.equal(Ok(30))
|
|
|
|
maths.permutation(6, 3)
|
|
|> should.equal(Ok(120))
|
|
}
|
|
|
|
pub fn list_cartesian_product_test() {
|
|
// An empty list returns an empty list as the Cartesian product
|
|
let xset = set.from_list([])
|
|
let yset = set.from_list([])
|
|
let expected_result = set.from_list([])
|
|
xset
|
|
|> maths.cartesian_product(yset)
|
|
|> should.equal(expected_result)
|
|
|
|
// Cartesian product of two sets with the same elements
|
|
let xset = set.from_list([1, 2, 3])
|
|
let yset = set.from_list([1, 2, 3])
|
|
let expected_result =
|
|
set.from_list([
|
|
#(1, 1),
|
|
#(1, 2),
|
|
#(1, 3),
|
|
#(2, 1),
|
|
#(2, 2),
|
|
#(2, 3),
|
|
#(3, 1),
|
|
#(3, 2),
|
|
#(3, 3),
|
|
])
|
|
xset
|
|
|> maths.cartesian_product(yset)
|
|
|> should.equal(expected_result)
|
|
|
|
// Cartesian product with floating-point numbers
|
|
let xset = set.from_list([1.0, 10.0])
|
|
let yset = set.from_list([1.0, 2.0])
|
|
let expected_result =
|
|
set.from_list([#(1.0, 1.0), #(1.0, 2.0), #(10.0, 1.0), #(10.0, 2.0)])
|
|
xset
|
|
|> maths.cartesian_product(yset)
|
|
|> should.equal(expected_result)
|
|
|
|
// Cartesian product of sets with different sizes
|
|
let xset = set.from_list([1.0, 10.0, 100.0])
|
|
let yset = set.from_list([1.0, 2.0])
|
|
let expected_result =
|
|
set.from_list([
|
|
#(1.0, 1.0),
|
|
#(1.0, 2.0),
|
|
#(10.0, 1.0),
|
|
#(10.0, 2.0),
|
|
#(100.0, 1.0),
|
|
#(100.0, 2.0),
|
|
])
|
|
xset
|
|
|> maths.cartesian_product(yset)
|
|
|> should.equal(expected_result)
|
|
|
|
// Cartesian product with different types (strings)
|
|
let xset = set.from_list(["a", "y", "z"])
|
|
let yset = set.from_list(["a", "x"])
|
|
let expected_result =
|
|
set.from_list([
|
|
#("a", "a"),
|
|
#("a", "x"),
|
|
#("y", "a"),
|
|
#("y", "x"),
|
|
#("z", "a"),
|
|
#("z", "x"),
|
|
])
|
|
xset
|
|
|> maths.cartesian_product(yset)
|
|
|> should.equal(expected_result)
|
|
}
|
|
|
|
pub fn cartesian_product_mixed_types_test() {
|
|
// Cartesian product of two empty sets
|
|
set.from_list([])
|
|
|> maths.cartesian_product(set.from_list([]))
|
|
|> should.equal(set.from_list([]))
|
|
|
|
// Cartesian product of two sets with numeric values
|
|
set.from_list([1.0, 10.0])
|
|
|> maths.cartesian_product(set.from_list([1.0, 2.0]))
|
|
|> should.equal(
|
|
set.from_list([#(1.0, 1.0), #(1.0, 2.0), #(10.0, 1.0), #(10.0, 2.0)]),
|
|
)
|
|
|
|
// Cartesian product of two sets with different types
|
|
set.from_list(["1", "10"])
|
|
|> maths.cartesian_product(set.from_list([1.0, 2.0]))
|
|
|> should.equal(
|
|
set.from_list([#("1", 1.0), #("1", 2.0), #("10", 1.0), #("10", 2.0)]),
|
|
)
|
|
}
|
|
|
|
pub fn list_permutation_with_repetitions_test() {
|
|
// Invalid input: k < 0 should return an error for an empty list
|
|
[]
|
|
|> maths.list_permutation_with_repetitions(-1)
|
|
|> should.be_error()
|
|
|
|
// Valid input: An empty list returns a single empty permutation
|
|
let assert Ok(permutations) =
|
|
[]
|
|
|> maths.list_permutation_with_repetitions(0)
|
|
permutations
|
|
|> yielder.to_list()
|
|
|> should.equal([[]])
|
|
|
|
let assert Ok(permutations) =
|
|
["a"]
|
|
|> maths.list_permutation_with_repetitions(1)
|
|
permutations
|
|
|> yielder.to_list()
|
|
|> should.equal([["a"]])
|
|
|
|
// 4-permutations of a single element repeats it 4 times
|
|
let assert Ok(permutations) =
|
|
["a"]
|
|
|> maths.list_permutation_with_repetitions(4)
|
|
permutations
|
|
|> yielder.to_list()
|
|
|> should.equal([["a", "a", "a", "a"]])
|
|
|
|
// 2-permutations of [1, 2] with repetition
|
|
let assert Ok(permutations) =
|
|
[1, 2]
|
|
|> maths.list_permutation_with_repetitions(2)
|
|
permutations
|
|
|> yielder.to_list()
|
|
|> set.from_list()
|
|
|> should.equal(set.from_list([[1, 1], [1, 2], [2, 2], [2, 1]]))
|
|
|
|
// 3-permutations of [1, 2, 3] with repetition
|
|
let assert Ok(permutations) =
|
|
[1, 2, 3]
|
|
|> maths.list_permutation_with_repetitions(3)
|
|
permutations
|
|
|> yielder.to_list()
|
|
|> should.equal([
|
|
[1, 1, 1],
|
|
[1, 1, 2],
|
|
[1, 1, 3],
|
|
[1, 2, 1],
|
|
[1, 2, 2],
|
|
[1, 2, 3],
|
|
[1, 3, 1],
|
|
[1, 3, 2],
|
|
[1, 3, 3],
|
|
[2, 1, 1],
|
|
[2, 1, 2],
|
|
[2, 1, 3],
|
|
[2, 2, 1],
|
|
[2, 2, 2],
|
|
[2, 2, 3],
|
|
[2, 3, 1],
|
|
[2, 3, 2],
|
|
[2, 3, 3],
|
|
[3, 1, 1],
|
|
[3, 1, 2],
|
|
[3, 1, 3],
|
|
[3, 2, 1],
|
|
[3, 2, 2],
|
|
[3, 2, 3],
|
|
[3, 3, 1],
|
|
[3, 3, 2],
|
|
[3, 3, 3],
|
|
])
|
|
|
|
// Repeated elements allow more possibilities when repetition is allowed
|
|
let assert Ok(permutations) =
|
|
[1.0, 1.0]
|
|
|> maths.list_permutation_with_repetitions(2)
|
|
permutations
|
|
|> yielder.to_list()
|
|
|> should.equal([[1.0, 1.0], [1.0, 1.0], [1.0, 1.0], [1.0, 1.0]])
|
|
|
|
let assert Ok(permutations) =
|
|
["a", "b", "c", "d", "e"]
|
|
|> maths.list_permutation_with_repetitions(5)
|
|
permutations
|
|
|> yielder.to_list()
|
|
|> list.length()
|
|
|> should.equal(3125)
|
|
}
|
|
|
|
pub fn list_permutation_without_repetitions_test() {
|
|
// Invalid input: k > n should return an error without repetition
|
|
[1, 2]
|
|
|> maths.list_permutation(3)
|
|
|> should.be_error()
|
|
|
|
// Singleton list returns a single permutation regardless of repetition settings
|
|
let assert Ok(permutations) =
|
|
["a"]
|
|
|> maths.list_permutation(1)
|
|
permutations
|
|
|> yielder.to_list()
|
|
|> should.equal([["a"]])
|
|
|
|
// 2-permutations of [1, 2] without repetition
|
|
let assert Ok(permutations) =
|
|
[1, 2]
|
|
|> maths.list_permutation(2)
|
|
permutations
|
|
|> yielder.to_list()
|
|
|> should.equal([[1, 2], [2, 1]])
|
|
|
|
// 2-permutations without repetition
|
|
let assert Ok(result) =
|
|
[1, 2, 3]
|
|
|> maths.list_permutation(2)
|
|
result
|
|
|> yielder.to_list()
|
|
|> should.equal([[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]])
|
|
|
|
// 3-permutations of [1, 2, 3] without repetition
|
|
let assert Ok(permutations) =
|
|
[1, 2, 3]
|
|
|> maths.list_permutation(3)
|
|
permutations
|
|
|> yielder.to_list()
|
|
|> should.equal([
|
|
[1, 2, 3],
|
|
[1, 3, 2],
|
|
[2, 1, 3],
|
|
[2, 3, 1],
|
|
[3, 1, 2],
|
|
[3, 2, 1],
|
|
])
|
|
|
|
// 3-permutations of [1, 2, 3, 4] without repetition
|
|
let assert Ok(permutations) =
|
|
[1, 2, 3, 4]
|
|
|> maths.list_permutation(3)
|
|
permutations
|
|
|> yielder.to_list()
|
|
|> should.equal([
|
|
[1, 2, 3],
|
|
[1, 2, 4],
|
|
[1, 3, 2],
|
|
[1, 3, 4],
|
|
[1, 4, 2],
|
|
[1, 4, 3],
|
|
[2, 1, 3],
|
|
[2, 1, 4],
|
|
[2, 3, 1],
|
|
[2, 3, 4],
|
|
[2, 4, 1],
|
|
[2, 4, 3],
|
|
[3, 1, 2],
|
|
[3, 1, 4],
|
|
[3, 2, 1],
|
|
[3, 2, 4],
|
|
[3, 4, 1],
|
|
[3, 4, 2],
|
|
[4, 1, 2],
|
|
[4, 1, 3],
|
|
[4, 2, 1],
|
|
[4, 2, 3],
|
|
[4, 3, 1],
|
|
[4, 3, 2],
|
|
])
|
|
|
|
// Repeated elements are treated as distinct in permutations without repetition
|
|
let assert Ok(permutations) =
|
|
[1.0, 1.0]
|
|
|> maths.list_permutation(2)
|
|
permutations
|
|
|> yielder.to_list()
|
|
|> should.equal([[1.0, 1.0], [1.0, 1.0]])
|
|
|
|
// Large inputs: Ensure the correct number of permutations is generated
|
|
let assert Ok(permutations) =
|
|
["a", "b", "c", "d", "e"]
|
|
|> maths.list_permutation(5)
|
|
permutations
|
|
|> yielder.to_list()
|
|
|> list.length()
|
|
|> should.equal(120)
|
|
}
|
|
|
|
pub fn permutation_alignment_test() {
|
|
// Test: Number of generated permutations should match the expected count
|
|
// Without repetitions
|
|
let arr = ["a", "b", "c", "d", "e", "f"]
|
|
let length = list.length(arr)
|
|
|
|
let assert Ok(number_of_permutations) = maths.permutation(length, length)
|
|
let assert Ok(permutations) =
|
|
arr
|
|
|> maths.list_permutation(length)
|
|
permutations
|
|
|> yielder.to_list()
|
|
|> list.length()
|
|
|> should.equal(number_of_permutations)
|
|
|
|
// With repetitions
|
|
let arr = ["a", "b", "c", "d", "e", "f"]
|
|
let length = list.length(arr)
|
|
|
|
let assert Ok(number_of_permutations) =
|
|
maths.permutation_with_repetitions(length, length)
|
|
let assert Ok(permutations) =
|
|
arr
|
|
|> maths.list_permutation_with_repetitions(length)
|
|
permutations
|
|
|> yielder.to_list()
|
|
|> list.length()
|
|
|> should.equal(number_of_permutations)
|
|
}
|
|
|
|
pub fn list_combination_with_repetitions_test() {
|
|
// Invalid input: k < 0 should return an error for an empty list
|
|
[]
|
|
|> maths.list_combination_with_repetitions(-1)
|
|
|> should.be_error()
|
|
|
|
// Valid input: k > n with repetition allowed
|
|
let assert Ok(combinations) =
|
|
[1, 2]
|
|
|> maths.list_combination_with_repetitions(3)
|
|
combinations
|
|
|> yielder.to_list()
|
|
|> should.equal([[1, 1, 1], [1, 1, 2], [1, 2, 2], [2, 2, 2]])
|
|
|
|
let assert Ok(combinations) =
|
|
[]
|
|
|> maths.list_combination_with_repetitions(0)
|
|
combinations
|
|
|> yielder.to_list()
|
|
|> should.equal([[]])
|
|
|
|
let assert Ok(combinations) =
|
|
[1, 2]
|
|
|> maths.list_combination_with_repetitions(1)
|
|
combinations
|
|
|> yielder.to_list()
|
|
|> should.equal([[1], [2]])
|
|
|
|
let assert Ok(combinations) =
|
|
[1, 2]
|
|
|> maths.list_combination_with_repetitions(2)
|
|
combinations
|
|
|> yielder.to_list()
|
|
|> should.equal([[1, 1], [1, 2], [2, 2]])
|
|
|
|
let assert Ok(combinations) =
|
|
[1, 2, 3, 4]
|
|
|> maths.list_combination_with_repetitions(2)
|
|
combinations
|
|
|> yielder.to_list()
|
|
|> should.equal([
|
|
[1, 1],
|
|
[1, 2],
|
|
[1, 3],
|
|
[1, 4],
|
|
[2, 2],
|
|
[2, 3],
|
|
[2, 4],
|
|
[3, 3],
|
|
[3, 4],
|
|
[4, 4],
|
|
])
|
|
|
|
// 3-combination of [1, 2, 3] with repetition
|
|
let assert Ok(combinations) =
|
|
[1, 2, 3]
|
|
|> maths.list_combination_with_repetitions(3)
|
|
combinations
|
|
|> yielder.to_list()
|
|
|> should.equal([
|
|
[1, 1, 1],
|
|
[1, 1, 2],
|
|
[1, 1, 3],
|
|
[1, 2, 2],
|
|
[1, 2, 3],
|
|
[1, 3, 3],
|
|
[2, 2, 2],
|
|
[2, 2, 3],
|
|
[2, 3, 3],
|
|
[3, 3, 3],
|
|
])
|
|
|
|
// 3-permutations of [1, 2, 3, 4] with repetition
|
|
let assert Ok(permutations) =
|
|
maths.list_combination_with_repetitions([1, 2, 3, 4], 3)
|
|
|
|
permutations
|
|
|> yielder.to_list()
|
|
|> should.equal([
|
|
[1, 1, 1],
|
|
[1, 1, 2],
|
|
[1, 1, 3],
|
|
[1, 1, 4],
|
|
[1, 2, 2],
|
|
[1, 2, 3],
|
|
[1, 2, 4],
|
|
[1, 3, 3],
|
|
[1, 3, 4],
|
|
[1, 4, 4],
|
|
[2, 2, 2],
|
|
[2, 2, 3],
|
|
[2, 2, 4],
|
|
[2, 3, 3],
|
|
[2, 3, 4],
|
|
[2, 4, 4],
|
|
[3, 3, 3],
|
|
[3, 3, 4],
|
|
[3, 4, 4],
|
|
[4, 4, 4],
|
|
])
|
|
|
|
// Repetition creates more possibilities even with identical elements
|
|
let assert Ok(combinations) =
|
|
[1.0, 1.0]
|
|
|> maths.list_combination_with_repetitions(2)
|
|
combinations
|
|
|> yielder.to_list()
|
|
|> should.equal([[1.0, 1.0], [1.0, 1.0], [1.0, 1.0]])
|
|
|
|
let assert Ok(combinations) =
|
|
["a", "b", "c", "d", "e"]
|
|
|> maths.list_combination_with_repetitions(5)
|
|
combinations
|
|
|> yielder.to_list()
|
|
|> list.length()
|
|
|> should.equal(126)
|
|
}
|
|
|
|
pub fn list_combination_without_repetitions_test() {
|
|
// Invalid input: k > n should return an error without repetition
|
|
[1, 2]
|
|
|> maths.list_combination(3)
|
|
|> should.be_error()
|
|
|
|
// Valid input: Empty list should return a single empty combination
|
|
let assert Ok(combinations) =
|
|
[]
|
|
|> maths.list_combination(0)
|
|
combinations
|
|
|> yielder.to_list()
|
|
|> should.equal([[]])
|
|
|
|
// 1-combination of [1, 2] without and with repetition
|
|
let assert Ok(combinations) =
|
|
[1, 2]
|
|
|> maths.list_combination(1)
|
|
combinations
|
|
|> yielder.to_list()
|
|
|> should.equal([[1], [2]])
|
|
|
|
// 2-combination of [1, 2] without and with repetition
|
|
let assert Ok(combinations) =
|
|
[1, 2]
|
|
|> maths.list_combination(2)
|
|
combinations
|
|
|> yielder.to_list()
|
|
|> should.equal([[1, 2]])
|
|
|
|
// 2-combination of [1, 2, 3, 4] without and with repetition
|
|
let assert Ok(combinations) =
|
|
[1, 2, 3, 4]
|
|
|> maths.list_combination(2)
|
|
combinations
|
|
|> yielder.to_list()
|
|
|> should.equal([[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]])
|
|
|
|
// 3-combination of [1, 2, 3, 4] without repetition
|
|
let assert Ok(combinations) =
|
|
[1, 2, 3, 4]
|
|
|> maths.list_combination(3)
|
|
combinations
|
|
|> yielder.to_list()
|
|
|> should.equal([[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]])
|
|
|
|
// Combinations treat repeated elements as distinct in certain scenarios
|
|
let assert Ok(combinations) =
|
|
[1.0, 1.0]
|
|
|> maths.list_combination(2)
|
|
combinations
|
|
|> yielder.to_list()
|
|
|> should.equal([[1.0, 1.0]])
|
|
|
|
// Large input: Ensure correct number of combinations is generated
|
|
let assert Ok(combinations) =
|
|
["a", "b", "c", "d", "e"]
|
|
|> maths.list_combination(5)
|
|
combinations
|
|
|> yielder.to_list()
|
|
|> list.length()
|
|
|> should.equal(1)
|
|
}
|
|
|
|
pub fn combination_alignment_test() {
|
|
// Test: Number of generated combinations should match the expected count
|
|
// Without repetitions
|
|
let arr = ["a", "b", "c", "d", "e", "f"]
|
|
let length = list.length(arr)
|
|
|
|
let assert Ok(number_of_combinations) = maths.combination(length, length)
|
|
let assert Ok(combinations) =
|
|
arr
|
|
|> maths.list_combination(length)
|
|
combinations
|
|
|> yielder.to_list()
|
|
|> list.length()
|
|
|> should.equal(number_of_combinations)
|
|
|
|
// With repetitions
|
|
let arr = ["a", "b", "c", "d", "e", "f"]
|
|
let length = list.length(arr)
|
|
|
|
let assert Ok(number_of_combinations) =
|
|
maths.combination_with_repetitions(length, length)
|
|
let assert Ok(combinations) =
|
|
arr
|
|
|> maths.list_combination_with_repetitions(length)
|
|
combinations
|
|
|> yielder.to_list()
|
|
|> list.length()
|
|
|> should.equal(number_of_combinations)
|
|
}
|