mumu 0.11.1

Lava Mumu is a language for those in the now and that know
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

extend("test")
extend("matrix")

describe("native matrix multiplication tests", () => {

  it("should multiply 2x2 int2d_arrays correctly", () => {
    result = [[1,2],[3,4]] * [[5,6],[7,8]]
    expect_equal(type(result), "int2d_array")
    expect_equal(result, [[19,22],[43,50]])
  })

  it("should multiply 2x2 float2d_arrays correctly", () => {
    result = [[1.1,2.1],[3.5,4.5]] * [[5.2,6.2],[7.1,8.9]]
    expect_equal(type(result), "float2d_array")
    expect_equal(result, [[20.630000000000003, 25.51], [50.15, 61.75]])
  })
})

describe("matrix:add usage", () => {

  it("adds two 2×2 int2d arrays", () => {
    A = [[1,2],[3,4]]
    B = [[5,6],[7,8]]
    sum = matrix:add(A, B)
    # => [[6,8],[10,12]]
    expect_equal(sum, [[6,8],[10,12]])
  })

  it("supports partial usage => known A, then B", () => {
    A = [[1,2],[3,4]]
    partialAdd = matrix:add(A)
    result = partialAdd([[5,6],[7,8]])
    # => [[6,8],[10,12]]
    expect_equal(result, [[6,8],[10,12]])
  })
})

describe("matrix:subtract usage", () => {

  it("subtracts two 2×2 int2d arrays", () => {
    A = [[1,2],[3,4]]
    B = [[5,6],[7,8]]
    diff = matrix:subtract(A, B)
    # => [[-4,-4],[-4,-4]]
    expect_equal(diff, [[-4,-4],[-4,-4]])
  })

  it("supports placeholder usage => known B, missing A", () => {
    A = [[1,2],[3,4]]
    B = [[5,6],[7,8]]
    partialSub = matrix:subtract(_, B)
    out = partialSub(A)
    # => [[-4,-4],[-4,-4]]
    expect_equal(out, [[-4,-4],[-4,-4]])
  })
})

describe("matrix:multiply usage", () => {

  it("multiplies two 2×2 int2d arrays", () => {
    A = [[1,2],[3,4]]
    B = [[5,6],[7,8]]
    product = matrix:multiply(A, B)
    # => [[19,22],[43,50]]
    expect_equal(product, [[19,22],[43,50]])
  })

  it("handles float2d => 2×2 matrix multiplication", () => {
    F1 = [[1.1, 2.1],[3.5, 4.5]]
    F2 = [[5.2, 6.2],[7.1, 8.9]]
    floatProd = matrix:multiply(F1, F2)
    # => [[20.630000000000003, 25.51],[50.15, 61.75]]
    expect_equal(floatProd, [[20.630000000000003, 25.51],[50.15, 61.75]])
  })

  it("raises an error for dimension mismatch", () => {
    # Attempt 2×3 multiplied by 2×2 => mismatch => expect error
    test:expect_error(() => {
      matrix:multiply([[1,2,3],[4,5,6]], [[7,8],[9,10]])
    },
    "dimension mismatch: left=2x3, right=2x2"
    )
  })
})

describe("matrix:transpose usage", () => {

  it("transposes a 2×2 int2d array", () => {
    A = [[1,2],[3,4]]
    out = matrix:transpose(A)
    # => [[1,3],[2,4]]
    expect_equal(out, [[1,3],[2,4]])
  })

  it("transposes a 2×2 float2d array", () => {
    F = [[1.1, 2.2],[3.3, 4.4]]
    transF = matrix:transpose(F)
    # => [[1.1,3.3],[2.2,4.4]]
    expect_equal(transF, [[1.1,3.3],[2.2,4.4]])
  })
})