changeset 18:12c6f103ba8e

More experiments with tagged types; I don't feel this is going in the right direction though

--- a/block.yeti	Mon Dec 17 12:47:08 2012 +0000
+++ b/block.yeti	Mon Dec 17 14:45:55 2012 +0000
@@ -5,37 +5,38 @@
 zeros n = 
     Block new double[n];
 
-deblock b is (Block ~double[]) -> ~double[] =
+unblock b is (Block ~double[]) -> ~double[] =
     case b of Block a: a esac;
 
 ones n = 
-   (v = deblock (zeros n);
+   (v = unblock (zeros n);
     for [0..n-1] do i: v[i] := 1.0 done;
     Block v);
 
 block l is list?<number> -> (Block ~double[]) =
    (arr = array(l);
     len = length arr;
-    v = deblock (zeros len);
+    v = unblock (zeros len);
     for [0..len-1] do i: v[i] := arr[i] done;
     Block v);
 
-arrayWrap b is (Block ~double[]) -> array<number> =
-    array(deblock b);
+norec list b is (Block ~double[]) -> list<number> =
+    list (unblock b);
 
-blockLength b = 
-    length (arrayWrap b);
+norec length b = 
+    length (list b);
 
-copyOfBlock b is (Block ~double[]) -> (Block ~double[]) = 
-   (v = deblock b;
-    Block Arrays#copyOf(v, length(arrayWrap b)));
+copyOf b is (Block ~double[]) -> (Block ~double[]) = 
+   (v = unblock b;
+    Block Arrays#copyOf(v, length b));
 
-subBlock b start len is (Block ~double[]) -> number -> number -> (Block ~double[]) = 
-    Block Arrays#copyOfRange(deblock b, start, start + len);
+subset b start len is (Block ~double[]) -> number -> number -> (Block ~double[]) = 
+    Block Arrays#copyOfRange(unblock b, start, start + len);
 
 {
-zeros, ones, block,
-blockLength,
-copyOfBlock, subBlock,
+zeros, ones,
+block, unblock,
+length,
+copyOf, subset,
 }
 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/blockmatrix.yeti	Mon Dec 17 14:45:55 2012 +0000
@@ -0,0 +1,47 @@
+module blockmatrix;
+
+// Basic matrices using a Block for each row. I don't like this one,
+// it's clumsy
+
+block = load block;
+
+zeroMatrix rows cols = array (map \(block.zeros cols) [1..rows]);
+
+generateMatrix f rows cols =
+   (m = zeroMatrix rows cols;
+    for [0..rows-1] do row:
+       (rb = block.unblock m[row];
+        for [0..cols-1] do col:
+            rb[col] := f row col;
+        done);
+    done;
+    m);
+
+constMatrix n = generateMatrix do row col: n done;
+randomMatrix = generateMatrix do row col: Math#random() done;
+identityMatrix = constMatrix 1;
+
+width m = if length m > 0 then block.length m[0] else 0 fi;
+cols = width;
+
+height m = length m;
+rows = height;
+
+dimensions m = { cols = width m, rows = height m };
+
+copyOfMatrix m = array (map block.copyOf m);
+
+cell m row col = 
+   (rb = block.unblock m[col];
+    rb[row]);
+
+transposed m is array<Block ~double[]> -> array<Block ~double[]> = 
+    generateMatrix do row col: cell m row col done (cols m) (rows m);
+
+{
+generateMatrix, constMatrix, randomMatrix, zeroMatrix, identityMatrix,
+width, cols, height, rows, dimensions,
+copyOfMatrix,
+transposed,
+}
+

--- a/fmatrix.yeti	Mon Dec 17 12:47:08 2012 +0000
+++ b/fmatrix.yeti	Mon Dec 17 14:45:55 2012 +0000
@@ -1,5 +1,7 @@
 module fmatrix;
 
+// Basic matrices using primitive array of double as each row
+
 vec = load fvector;
 
 zeroMatrix rows cols = array (map \(vec.zeros cols) [1..rows]);

--- a/matrix.yeti	Mon Dec 17 12:47:08 2012 +0000
+++ b/matrix.yeti	Mon Dec 17 14:45:55 2012 +0000
@@ -1,5 +1,7 @@
 module matrix;
 
+// Basic matrices using number type (rather than primitive arrays)
+
 zeros n = array(map \0 [1..n]);
 ones  n = array(map \1 [1..n]);