1  /*
 2  seed = 123456789
 3  min_height = 16
 4  
 5  [case]
 6  program = "test.alpha"
 7  function = "main_1"
 8  input = []
 9  [case]
10  program = "test.alpha"
11  function = "main_2"
12  input = []
13  */
14  
15  program test.alpha {
16      const M_: u32 = 2u32; // Rows in A
17      const K_: u32 = 3u32; // Columns in A / Rows in B
18      const N_: u32 = 2u32; // Columns in B
19  
20      struct Matrix::[M: u32, N: u32] {
21          data: [[i32; N]; M]
22      }
23  
24      transition main_1() -> Matrix::[M_, N_] {
25          // Matrix A: 2x3
26          let A = Matrix::[M_, K_] {
27              data: [
28                  [1i32, 2i32, 3i32],
29                  [4i32, 5i32, 6i32]
30              ]
31          };
32  
33          // Matrix B: 3x2
34          let B = Matrix::[K_, N_] {
35              data: [
36                  [7i32, 8i32],
37                  [9i32, 10i32],
38                  [11i32, 12i32]
39              ]
40          };
41  
42          // Compute matrix product: C = A * B
43          let C = matmul::[M_, K_, N_](A, B);
44  
45          return C;
46      }
47  
48      transition main_2() -> bool {
49          let A = Matrix::[K_, K_] {
50              data: [
51                  [1i32, 2i32, 3i32],
52                  [2i32, 4i32, 5i32],
53                  [3i32, 5i32, 6i32]
54              ]
55          };
56  
57          return is_symmetric::[3](A);
58      }
59  
60      // Multiplies two matrices wrapped in the `Matrix` struct
61      inline matmul::[M: u32, K: u32, N: u32](
62          A: Matrix::[M, K],
63          B: Matrix::[K, N]
64      ) -> Matrix::[M, N] {
65          let C_data: [[i32; N]; M] = [[0i32; N]; M];
66  
67          for i in 0u32..M {
68              for j in 0u32..N {
69                  let sum = 0i32;
70                  for k in 0u32..K {
71                      sum += A.data[i][k] * B.data[k][j];
72                  }
73                  C_data[i][j] = sum;
74              }
75          }
76  
77          return Matrix::[M, N] { data: C_data };
78      }
79  
80      // Checks if a square matrix is symmetric
81      inline is_symmetric::[N: u32](A: Matrix::[N, N]) -> bool {
82          for i in 0u32..N-1 {
83              for j in (i + 1u32)..N { // Only check upper triangle
84                  if A.data[i][j] != A.data[j][i] {
85                      return false;
86                  }
87              }
88          }
89          return true;
90      }
91  
92      @noupgrade
93      async constructor() {}
94  }