diff yetilab/vector/vector.yeti @ 222:77c6a81c577f matrix_opaque_immutable

Move block directory -> vector

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/yetilab/vector/vector.yeti	Sat May 11 15:58:36 2013 +0100
@@ -0,0 +1,124 @@
+
+module yetilab.vector.vector;
+
+load yetilab.vector.vectortype;
+
+import java.util: Arrays;
+
+//!!! This is supposed to be 100% immutable and without copying when duplicating for read only
+
+zeros n =
+    new double[n];
+
+consts m n =
+   (a = zeros n;
+    for [0..n-1] do i:
+        a[i] := m;
+    done;
+    a);
+
+ones = consts 1.0;
+
+fromList l is list?<number> -> ~double[] =
+   (arr = array(l);
+    len = length arr;
+    v = zeros len;
+    for [0..len-1] do i:
+        v[i] := arr[i];
+    done;
+    v);
+
+list' a is ~double[] -> list<number> =
+    list a;
+
+array' a is ~double[] -> array<number> =
+    array a;
+
+length' =
+    length . list';
+
+empty?' =
+    empty? . list';
+
+at' n v is number -> ~double[] -> number =
+    v[n];
+
+floats a is ~double[] -> ~float[] =
+   (len = length' a;
+    f = new float[len];
+    for [0..len-1] do i:
+        f[i] := a[i];
+    done;
+    f);
+
+fromFloats ff is ~float[] -> ~double[] =
+   (len = length (list ff);
+    a = new double[len];
+    for [0..len-1] do i:
+        a[i] := ff[i];
+    done;
+    a);
+
+equal v1 v2 =
+    list' v1 == list' v2;
+
+copyOf v is ~double[] -> ~double[] =
+    Arrays#copyOf(v, list' v |> length);
+
+rangeOf start len v is number -> number -> ~double[] -> ~double[] =
+    Arrays#copyOfRange(v, start, start + len);
+
+resizedTo n v is number -> ~double[] -> ~double[] =
+    Arrays#copyOf(v, n);
+
+concat vv is list?<~double[]> -> ~double[] =
+   (len = sum (map length' vv);
+    vout = zeros len;
+    var base = 0;
+    for vv do v: 
+        vlen = length' v;
+        for [0..vlen-1] do i: vout[base + i] := v[i] done;
+        base := base + vlen;
+    done;
+    vout);
+
+{
+    zeros,
+    consts,
+    ones,
+    vector v = v,
+    primitive = copyOf,
+    floats,
+    fromFloats,
+    fromList,
+    list = list',
+    array = array',
+    length = length',
+    empty? = empty?',
+    at = at',
+    equal,
+    rangeOf,
+    resizedTo,
+    concat,
+} as {
+    zeros is number -> vector,
+    consts is number -> number -> vector,
+    ones is number -> vector,
+    vector is ~double[] -> vector,
+    primitive is vector -> ~double[],
+    floats is vector -> ~float[],
+    fromFloats is ~float[] -> vector,
+    fromList is list?<number> -> vector,
+    list is vector -> list<number>,
+    array is vector -> array<number>,
+    length is vector -> number,
+    empty? is vector -> boolean,
+    at is number -> vector -> number,
+    equal is vector -> vector -> boolean,
+    rangeOf is number -> number -> vector -> vector, //!!! not well-named now vector arg is at the end
+    resizedTo is number -> vector -> vector,
+    concat is list?<vector> -> vector,
+}
+
+
+