Chris@5: module floatrix;
Chris@5: 
Chris@5: zeros n = new double[n];
Chris@5: ones  n = (a = zeros n; for [0..n-1] do i: a[i] := 1.0 done; a);
Chris@5: 
Chris@8: vector l is list?<number> -> ~double[] =
Chris@8:    (arr = array(l);
Chris@8:     len = length arr;
Chris@8:     v = new double[len];
Chris@8:     for [0..len-1] do i: n = arr[i]; v[i] := n done;
Chris@8:     v);
Chris@8: 
Chris@5: zeroMatrix rows cols = array (map \(zeros cols) [1..rows]);
Chris@5: 
Chris@5: generateMatrix f rows cols =
Chris@5:    (m = zeroMatrix rows cols;
Chris@5:     for [0..rows-1] do row:
Chris@5:         for [0..cols-1] do col:
Chris@5:             n = f row col;
Chris@5:             m[row][col] := n;
Chris@5:         done;
Chris@5:     done;
Chris@5:     m);
Chris@5: 
Chris@5: constMatrix n = generateMatrix do row col: n done;
Chris@5: 
Chris@5: randomMatrix = generateMatrix do row col: Math#random() done;
Chris@5: 
Chris@5: identityMatrix = constMatrix 1;
Chris@5: 
Chris@5: arrayWrap a is ~double[] -> array<number> = array(a);
Chris@5: 
Chris@5: width m = if length m > 0 then length (arrayWrap m[0]) else 0 fi;
Chris@5: 
Chris@6: cols = width;
Chris@6: 
Chris@5: height m = length m;
Chris@5: 
Chris@6: rows = height;
Chris@6: 
Chris@5: dimensions m = { cols = width m, rows = height m };
Chris@5: 
Chris@6: transposed m is array<~double[]> -> array<~double[]> = 
Chris@6:     generateMatrix do row col: m[col][row] done (cols m) (rows m);
Chris@6:         
Chris@7: interleaved m = 
Chris@7:    ({ cols, rows } = dimensions m;
Chris@7:     v = zeros (cols * rows);
Chris@7:     for [0..rows-1] do row:
Chris@7:         for [0..cols-1] do col:
Chris@7:             v[col * rows + row] := m[row][col];
Chris@7:         done;
Chris@7:     done;
Chris@7:     v);
Chris@6: 
Chris@8: deinterleaved rows v is number -> ~double[] -> array<~double[]> =
Chris@5:     generateMatrix do row col:
Chris@5:         v[rows * col + row]
Chris@7:     done rows (length (arrayWrap v) / rows);
Chris@5: 
Chris@8:     //!!! too inefficient!
Chris@8: mixedDown rows v is number -> ~double[] -> ~double[] =
Chris@8:    (cols = (length (arrayWrap v) / rows);
Chris@8:     mv = new double[cols];
Chris@8:     for [0..cols-1] do col:
Chris@8:         val = sum (map do row: v[col * rows + row] done [0..rows-1]) / rows;
Chris@8:         mv[col] := val;
Chris@8:     done;
Chris@8:     mv);
Chris@8: 
Chris@5: {
Chris@8: zeros, ones, vector,
Chris@5: generateMatrix, constMatrix, randomMatrix, zeroMatrix, identityMatrix,
Chris@6: width, cols, height, rows, dimensions,
Chris@7: transposed, interleaved, deinterleaved,
Chris@8: mixedDown,
Chris@5: }
Chris@5: