annotate yetilab/vector/vector.yeti @ 254:5eb57c649de0 sparse

Using hashes is simpler, but turns out to be mostly no faster and sometimes much slower. Not one to merge back.

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';

//!!! this is reversed from std.at, fix
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;

equalUnder comparator v1 v2 =
    length' v1 == length' v2 and
        all id (map2 comparator (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);

slice v start end is ~double[] -> number -> number -> ~double[] =
    rangeOf start (end - start) v;

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,
    equalUnder,
    rangeOf,
    slice,
    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,
    equalUnder is (number -> number -> boolean) -> vector -> vector -> boolean,
    rangeOf is number -> number -> vector -> vector, //!!! not well-named now vector arg is at the end
    slice is vector -> number -> number -> vector, //!!! duplication with rangeOf (std module function on arrays is called slice though)
    resizedTo is number -> vector -> vector,
    concat is list?<vector> -> vector,
}