Mercurial > hg > may

--- a/src/may/matrix.yeti	Fri Nov 01 11:24:07 2013 +0000
+++ b/src/may/matrix.yeti	Fri Nov 01 18:16:02 2013 +0000
@@ -848,54 +848,54 @@
 {
 //!!! check whether these are right to be .selector rather than just selector

-    size is matrix -> { .rows is number, .columns is number },
-    width is matrix -> number,
-    height is matrix -> number,
-    density is matrix -> number,
-    nonZeroValues is matrix -> number,
-    at is matrix -> number -> number -> number,
-    getColumn is number -> matrix -> vector,
-    getRow is number -> matrix -> vector,
-    getDiagonal is number -> matrix -> vector,
-    isRowMajor? is matrix -> boolean,
-    isSparse? is matrix -> boolean,
-    generate is (number -> number -> number) -> { .rows is number, .columns is number } -> matrix,
-    constMatrix is number -> { .rows is number, .columns is number } -> matrix,
-    randomMatrix is { .rows is number, .columns is number } -> matrix,
-    zeroMatrix is { .rows is number, .columns is number } -> matrix,
-    identityMatrix is { .rows is number, .columns is number } -> matrix,
-    zeroSizeMatrix is () -> matrix,
-    empty? is matrix -> boolean,
-    equal is matrix -> matrix -> boolean,
-    equalUnder is (number -> number -> boolean) -> matrix -> matrix -> boolean,
-    transposed is matrix -> matrix,
-    flipped is matrix -> matrix,
-    toRowMajor is matrix -> matrix,
-    toColumnMajor is matrix -> matrix,
-    toSparse is matrix -> matrix,
-    toDense is matrix -> matrix,
-    scaled is number -> matrix -> matrix,
-    resizedTo is { .rows is number, .columns is number } -> matrix -> matrix,
-    minValue is matrix -> number,
-    maxValue is matrix -> number,
-    asRows is matrix -> list<vector>,
-    asColumns is matrix -> list<vector>,
-    sum is matrix -> matrix -> matrix,
-    difference is matrix -> matrix -> matrix,
-    abs is matrix -> matrix,
-    negative is matrix -> matrix,
-    filter is (number -> boolean) -> matrix -> matrix,
-    all is (number -> boolean) -> matrix -> boolean,
-    any is (number -> boolean) -> matrix -> boolean,
-    product is matrix -> matrix -> matrix,
-    entryWiseProduct is matrix -> matrix -> matrix,
-    concat is (Horizontal () | Vertical ()) -> list<matrix> -> matrix,
-    rowSlice is matrix -> number -> number -> matrix,
-    columnSlice is matrix -> number -> number -> matrix,
-    newMatrix is (ColumnMajor () | RowMajor ()) -> list<vector> -> matrix,
-    newRowVector is vector -> matrix,
-    newColumnVector is vector -> matrix,
-    newSparseMatrix is (ColumnMajor () | RowMajor ()) -> { .rows is number, .columns is number } -> list<{ .i is number, .j is number, .v is number }> -> matrix,
-    enumerate is matrix -> list<{ .i is number, .j is number, .v is number }>
+    size is matrix_t -> { .rows is number, .columns is number },
+    width is matrix_t -> number,
+    height is matrix_t -> number,
+    density is matrix_t -> number,
+    nonZeroValues is matrix_t -> number,
+    at is matrix_t -> number -> number -> number,
+    getColumn is number -> matrix_t -> vec.vector_t,
+    getRow is number -> matrix_t -> vec.vector_t,
+    getDiagonal is number -> matrix_t -> vec.vector_t,
+    isRowMajor? is matrix_t -> boolean,
+    isSparse? is matrix_t -> boolean,
+    generate is (number -> number -> number) -> { .rows is number, .columns is number } -> matrix_t,
+    constMatrix is number -> { .rows is number, .columns is number } -> matrix_t,
+    randomMatrix is { .rows is number, .columns is number } -> matrix_t,
+    zeroMatrix is { .rows is number, .columns is number } -> matrix_t,
+    identityMatrix is { .rows is number, .columns is number } -> matrix_t,
+    zeroSizeMatrix is () -> matrix_t,
+    empty? is matrix_t -> boolean,
+    equal is matrix_t -> matrix_t -> boolean,
+    equalUnder is (number -> number -> boolean) -> matrix_t -> matrix_t -> boolean,
+    transposed is matrix_t -> matrix_t,
+    flipped is matrix_t -> matrix_t,
+    toRowMajor is matrix_t -> matrix_t,
+    toColumnMajor is matrix_t -> matrix_t,
+    toSparse is matrix_t -> matrix_t,
+    toDense is matrix_t -> matrix_t,
+    scaled is number -> matrix_t -> matrix_t,
+    resizedTo is { .rows is number, .columns is number } -> matrix_t -> matrix_t,
+    minValue is matrix_t -> number,
+    maxValue is matrix_t -> number,
+    asRows is matrix_t -> list<vec.vector_t>,
+    asColumns is matrix_t -> list<vec.vector_t>,
+    sum is matrix_t -> matrix_t -> matrix_t,
+    difference is matrix_t -> matrix_t -> matrix_t,
+    abs is matrix_t -> matrix_t,
+    negative is matrix_t -> matrix_t,
+    filter is (number -> boolean) -> matrix_t -> matrix_t,
+    all is (number -> boolean) -> matrix_t -> boolean,
+    any is (number -> boolean) -> matrix_t -> boolean,
+    product is matrix_t -> matrix_t -> matrix_t,
+    entryWiseProduct is matrix_t -> matrix_t -> matrix_t,
+    concat is (Horizontal () | Vertical ()) -> list<matrix_t> -> matrix_t,
+    rowSlice is matrix_t -> number -> number -> matrix_t,
+    columnSlice is matrix_t -> number -> number -> matrix_t,
+    newMatrix is (ColumnMajor () | RowMajor ()) -> list<vec.vector_t> -> matrix_t,
+    newRowVector is vec.vector_t -> matrix_t,
+    newColumnVector is vec.vector_t -> matrix_t,
+    newSparseMatrix is (ColumnMajor () | RowMajor ()) -> { .rows is number, .columns is number } -> list<{ .i is number, .j is number, .v is number }> -> matrix_t,
+    enumerate is matrix_t -> list<{ .i is number, .j is number, .v is number }>
 }
--- a/src/may/matrix/complex.yeti	Fri Nov 01 11:24:07 2013 +0000
+++ b/src/may/matrix/complex.yeti	Fri Nov 01 18:16:02 2013 +0000
@@ -5,9 +5,11 @@
 vec = load may.vector;
 cpx = load may.complex;

-load may.matrix.type;
-load may.matrix.complextype;
-load may.complex.type;
+typedef opaque complexmatrix = {
+    .size is { .rows is number, .columns is number },
+    .real is Some mat.matrix_t | None (),
+    .imaginary is Some mat.matrix_t | None ()
+};

 complex real imaginary = //!!! or complex { .real, .imaginary } ?
    (size = mat.size real;
@@ -47,11 +49,11 @@
     esac;

 getRow n cm =
-   (pget = maybe' \(vec.zeros cm.size.columns) (mat.getRow n);
+   (pget = maybe' \(vec.list (vec.zeros cm.size.columns)) (vec.list . (mat.getRow n));
     array (map2 cpx.complex (pget cm.real) (pget cm.imaginary)));

 getColumn n cm =
-   (pget = maybe' \(vec.zeros cm.size.rows) (mat.getColumn n);
+   (pget = maybe' \(vec.list (vec.zeros cm.size.rows)) (vec.list . (mat.getColumn n));
     array (map2 cpx.complex (pget cm.real) (pget cm.imaginary)));

 getDiagonal k cm =
@@ -328,14 +330,14 @@
     width is complexmatrix -> number,
     height is complexmatrix -> number,
     density is complexmatrix -> number,
-    at is complexmatrix -> number -> number -> cplx,
-    getColumn is number -> complexmatrix -> array<cplx>,
-    getRow is number -> complexmatrix -> array<cplx>,
-    getDiagonal is number -> complexmatrix -> array<cplx>,
-    asRows is complexmatrix -> list<array<cplx>>,
-    asColumns is complexmatrix -> list<array<cplx>>,
-    generate is (number -> number -> cplx) -> { .rows is number, .columns is number } -> complexmatrix,
-    constMatrix is cplx -> { .rows is number, .columns is number } -> complexmatrix,
+    at is complexmatrix -> number -> number -> cpx.complex_t,
+    getColumn is number -> complexmatrix -> array<cpx.complex_t>,
+    getRow is number -> complexmatrix -> array<cpx.complex_t>,
+    getDiagonal is number -> complexmatrix -> array<cpx.complex_t>,
+    asRows is complexmatrix -> list<array<cpx.complex_t>>,
+    asColumns is complexmatrix -> list<array<cpx.complex_t>>,
+    generate is (number -> number -> cpx.complex_t) -> { .rows is number, .columns is number } -> complexmatrix,
+    constMatrix is cpx.complex_t -> { .rows is number, .columns is number } -> complexmatrix,
     zeroMatrix is { .rows is number, .columns is number } -> complexmatrix,
     equal is complexmatrix -> complexmatrix -> boolean,
     conjugateTransposed is complexmatrix -> complexmatrix,
@@ -346,21 +348,21 @@
     scaled is number -> complexmatrix -> complexmatrix,
     sum is complexmatrix -> complexmatrix -> complexmatrix,
     difference is complexmatrix -> complexmatrix -> complexmatrix,
-    abs is complexmatrix -> matrix,
+    abs is complexmatrix -> mat.matrix_t,
     product is complexmatrix -> complexmatrix -> complexmatrix,
     entryWiseProduct is complexmatrix -> complexmatrix -> complexmatrix,
-    complex is matrix -> matrix -> complexmatrix,
-    fromReal is matrix -> complexmatrix,
-    fromImaginary is matrix -> complexmatrix,
-    real is complexmatrix -> matrix,
-    imaginary is complexmatrix -> matrix,
-    magnitudes is complexmatrix -> matrix,
-    angles is complexmatrix -> matrix,
+    complex is mat.matrix_t -> mat.matrix_t -> complexmatrix,
+    fromReal is mat.matrix_t -> complexmatrix,
+    fromImaginary is mat.matrix_t -> complexmatrix,
+    real is complexmatrix -> mat.matrix_t,
+    imaginary is complexmatrix -> mat.matrix_t,
+    magnitudes is complexmatrix -> mat.matrix_t,
+    angles is complexmatrix -> mat.matrix_t,
     rowSlice is complexmatrix -> number -> number -> complexmatrix,
     columnSlice is complexmatrix -> number -> number -> complexmatrix,
-    newComplexMatrix is (ColumnMajor () | RowMajor ()) -> list?<list?<cplx>> -> complexmatrix,
-    newComplexRowVector is list?<cplx> -> complexmatrix,
-    newComplexColumnVector is list?<cplx> -> complexmatrix,
-    enumerate is complexmatrix -> list<{ .i is number, .j is number, .v is cplx }>,
+    newComplexMatrix is (ColumnMajor () | RowMajor ()) -> list?<list?<cpx.complex_t>> -> complexmatrix,
+    newComplexRowVector is list?<cpx.complex_t> -> complexmatrix,
+    newComplexColumnVector is list?<cpx.complex_t> -> complexmatrix,
+    enumerate is complexmatrix -> list<{ .i is number, .j is number, .v is cpx.complex_t }>,
 }
--- a/src/may/matrix/complextype.yeti	Fri Nov 01 11:24:07 2013 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,13 +0,0 @@
-
-module may.matrix.complextype;
-
-load may.matrix.type;
-
-typedef opaque complexmatrix = {
-    .size is { .rows is number, .columns is number },
-    .real is Some matrix | None (),
-    .imaginary is Some matrix | None ()
-};
-
-();
-
--- a/src/may/stream/channels.yeti	Fri Nov 01 11:24:07 2013 +0000
+++ b/src/may/stream/channels.yeti	Fri Nov 01 18:16:02 2013 +0000
@@ -5,15 +5,6 @@
 mat = load may.matrix;
 bf = load may.vector.blockfuncs;

-load may.vector.type;
-
-//!!! "internal" vector function to retrieve data for read-only
-// purposes without copying
-//!!! need to have this in some internal-use module
-raw =
-   (raw' v is ~double[] -> ~double[] = v;
-    raw' as vector -> ~double[]);
-
 interleaved m =
     bf.zipped (mat.asRows m);

@@ -35,7 +26,7 @@
         b;
     else
         columns = ((vec.length b) / channels);
-        v = raw b;
+        v = vec.raw b;
         v' = new double[columns];
         for [0..channels-1] do row:
             for [0..columns-1] do col:
@@ -52,7 +43,7 @@
         mixedDownFromInterleaved channels b;
     else
         columns = ((vec.length b) / channels);
-        v = raw b;
+        v = vec.raw b;
         v' = new double[columns * targetChannels];
         for [0..targetChannels-1] do target:
             for [0..columns-1] do col:
--- a/src/may/stream/framer.yeti	Fri Nov 01 11:24:07 2013 +0000
+++ b/src/may/stream/framer.yeti	Fri Nov 01 18:16:02 2013 +0000
@@ -13,11 +13,9 @@
 fft = load may.transform.fft;
 mat = load may.matrix;
 ch = load may.stream.channels;
+complex = load may.complex;

 load may.stream.type;
-load may.matrix.type;
-load may.vector.type;
-load may.complex.type;

 //!!! todo: synchronized for everything with state assignment

@@ -186,13 +184,13 @@
     map f (windowedFrames parameters stream));

 typedef params = { .framesize is number, .hop is number };
-typedef winparams = { .framesize is number, .hop is number, .window is number -> vector };
+typedef winparams = { .framesize is number, .hop is number, .window is number -> vec.vector_t };

 {
-    frames is params -> stream -> list<matrix>,
-    monoFrames is params -> stream -> list<vector>,
-    windowedFrames is winparams -> stream -> list<vector>,
-    frequencyDomainFrames is winparams -> stream -> list<array<cplx> >,
+    frames is params -> stream -> list<mat.matrix_t>,
+    monoFrames is params -> stream -> list<vec.vector_t>,
+    windowedFrames is winparams -> stream -> list<vec.vector_t>,
+    frequencyDomainFrames is winparams -> stream -> list<array<complex.complex_t> >,

     framesOfFile parameters filename =
         frames parameters (af.open filename),
@@ -206,9 +204,9 @@
     frequencyDomainFramesOfFile parameters filename =
         frequencyDomainFrames parameters (af.open filename),

-    overlapAdd is number -> list<matrix> -> matrix,
+    overlapAdd is number -> list<mat.matrix_t> -> mat.matrix_t,

-    streamed is number -> params -> list<matrix> -> stream,
-    streamOverlapping is number -> winparams -> list<matrix> -> stream,
+    streamed is number -> params -> list<mat.matrix_t> -> stream,
+    streamOverlapping is number -> winparams -> list<mat.matrix_t> -> stream,
 }
--- a/src/may/stream/type.yeti	Fri Nov 01 11:24:07 2013 +0000
+++ b/src/may/stream/type.yeti	Fri Nov 01 18:16:02 2013 +0000
@@ -1,7 +1,7 @@

 module may.stream.type;

-load may.matrix.type;
+mat = load may.matrix;

 typedef stream =
     {
@@ -10,7 +10,7 @@
         sampleRate is number,
         available is Known number | Unknown () | Infinite (),
         finished? is boolean,
-        read is number -> matrix,
+        read is number -> mat.matrix_t,
         close is () -> (),
     };
--- a/src/may/transform/fft.yeti	Fri Nov 01 11:24:07 2013 +0000
+++ b/src/may/transform/fft.yeti	Fri Nov 01 18:16:02 2013 +0000
@@ -7,9 +7,7 @@
 complex = load may.complex;
 bf = load may.vector.blockfuncs;

-load may.complex.type;
-
-packedToComplex len p is number -> ~double[] -> array<cplx> =
+packedToComplex len p is number -> ~double[] -> array<complex.complex_t> =
    (n = len / 2;
     array
        (map do i:
@@ -18,7 +16,7 @@
             complex.complex re im;
         done [0..n]));

-complexToPacked arr =
+complexToPacked arr is array<complex.complex_t> -> ~double[] =
    (n = length arr;
     v = new double[n*2-2];
     for [0..(n-1)*2-1] do i:
@@ -33,11 +31,11 @@
     v[1] := complex.real arr[n-1];
     v);

-unpackedToComplex len unp is number -> ~double[] -> array<cplx> =
+unpackedToComplex len unp is number -> vec.vector_t -> array<complex.complex_t> =
    (vv = bf.unzipped 2 unp;
     array (map2 complex.complex (vec.list vv[0]) (vec.list vv[1])));

-complexToUnpacked cc is array<cplx> -> ~double[] =
+complexToUnpacked cc is array<complex.complex_t> -> vec.vector_t =
     bf.zipped [ vec.fromList (map complex.real cc),
                 vec.fromList (map complex.imaginary cc) ];

@@ -45,18 +43,18 @@
 forward n =
    (d = new DoubleFFT_1D(n);
     do cc:
-        arr = vec.resizedTo (n*2) (complexToUnpacked cc);
+        arr = vec.primitive (vec.resizedTo (n*2) (complexToUnpacked cc));
         d#complexForward(arr);
-        unpackedToComplex n arr;
+        unpackedToComplex n (vec.vector arr);
     done);

 //!!! doc: n separately as below
 inverse n =
    (d = new DoubleFFT_1D(n);
     do cc:
-        arr = vec.resizedTo (n*2) (complexToUnpacked cc);
+        arr = vec.primitive (vec.resizedTo (n*2) (complexToUnpacked cc));
         d#complexInverse(arr, true);
-        unpackedToComplex n arr;
+        unpackedToComplex n (vec.vector arr);
     done);

 //!!! doc: n is supplied separately from the input vector to support partial evaluation
@@ -65,9 +63,9 @@
 realForward n =
    (d = new DoubleFFT_1D(n);
     do bl:
-        v = vec.resizedTo n bl;
-        d#realForward(v);
-        packedToComplex n v;
+        arr = vec.primitive (vec.resizedTo n bl);
+        d#realForward(arr);
+        packedToComplex n arr;
     done);

 //!!! doc: n separately as above
@@ -79,9 +77,9 @@
 realInverse n =
    (d = new DoubleFFT_1D(n);
     do cplx:
-        v = complexToPacked (array cplx);
-        d#realInverse(v, true);
-        vec.vector v;
+        arr = complexToPacked (array cplx);
+        d#realInverse(arr, true);
+        vec.vector arr;
     done);

 {
--- a/src/may/vector.yeti	Fri Nov 01 11:24:07 2013 +0000
+++ b/src/may/vector.yeti	Fri Nov 01 18:16:02 2013 +0000
@@ -175,6 +175,7 @@
     reverse,
     repeated,
     concat,
+    raw = id,
 } as {
     zeros is number -> vector_t,
     consts is number -> number -> vector_t,
@@ -196,6 +197,7 @@
     reverse is vector_t -> vector_t,
     repeated is vector_t -> number -> vector_t,
     concat is list?<vector_t> -> vector_t,
+    raw is vector_t -> ~double[],
 }
--- a/src/may/vector/blockfuncs.yeti	Fri Nov 01 11:24:07 2013 +0000
+++ b/src/may/vector/blockfuncs.yeti	Fri Nov 01 18:16:02 2013 +0000
@@ -3,22 +3,14 @@

 vec = load may.vector;

-load may.vector.type;
-
 { ceil } = load may.mathmisc;

 import may.bits: VectorBits;

-// "internal" vector function to retrieve data for read-only
-// purposes without copying
-raw =
-   (raw' v is ~double[] -> ~double[] = v;
-    raw' as vector -> ~double[]);
-
-sum' v = VectorBits#sum(raw v);
+sum' v = VectorBits#sum(vec.raw v);

 max' v =
-   (dat = raw v;
+   (dat = vec.raw v;
     var mx = 0;
     for [0..length dat - 1] do i:
         if i == 0 or dat[i] > mx then
@@ -28,7 +20,7 @@
     mx);

 maxindex v =
-   (dat = raw v;
+   (dat = vec.raw v;
     var mx = 0;
     var mi = -1;
     for [0..length dat - 1] do i:
@@ -40,7 +32,7 @@
     mi);

 min' v =
-   (dat = raw v;
+   (dat = vec.raw v;
     var mn = 0;
     for [0..length dat - 1] do i:
         if i == 0 or dat[i] < mn then
@@ -50,7 +42,7 @@
     mn);

 minindex v =
-   (dat = raw v;
+   (dat = vec.raw v;
     var mn = 0;
     var mi = -1;
     for [0..length dat - 1] do i:
@@ -69,7 +61,7 @@

 add bb =
    (len = head (sort (map vec.length bb));
-    vv = map raw bb;
+    vv = map vec.raw bb;
     out = new double[len];
     for vv do v:
         VectorBits#addTo(out, v, len);
@@ -77,8 +69,8 @@
     vec.vector out);

 subtract b1 b2 =
-   (v1 = raw b1;
-    v2 = raw b2;
+   (v1 = vec.raw b1;
+    v2 = vec.raw b2;
     len = if length v1 < length v2 then length v1 else length v2 fi;
     out = new double[len];
     for [0..len-1] do i:
@@ -86,11 +78,12 @@
     done;
     vec.vector out);

-multiply b1 b2 = VectorBits#multiply(raw b1, raw b2);
+multiply b1 b2 =
+    vec.vector VectorBits#multiply(vec.raw b1, vec.raw b2);

 scaled n v =
     if n == 1 then v
-    else VectorBits#scaled(raw v, n);
+    else vec.vector VectorBits#scaled(vec.raw v, n);
     fi;

 divideBy n v =
@@ -163,27 +156,27 @@
     fi;

 {
-sum is vector -> number = sum',
-mean is vector -> number,
-add is list?<vector> -> vector,
-subtract is vector -> vector -> vector,
-multiply is vector -> vector -> vector,
-divideBy is number -> vector -> vector,
-scaled is number -> vector -> vector,
-abs is vector -> vector = abs',
-negative is vector -> vector,
-sqr is vector -> vector,
-sqrt is vector -> vector = sqrt',
-rms is vector -> number,
-max is vector -> number = max',
-min is vector -> number = min',
-maxindex is vector -> number,
-minindex is vector -> number,
-unityNormalised is vector -> vector,
-fftshift is vector -> vector,
-ifftshift is vector -> vector,
-zipped is list?<vector> -> vector,
-unzipped is number -> vector -> array<vector>,
+sum is vec.vector_t -> number = sum',
+mean is vec.vector_t -> number,
+add is list?<vec.vector_t> -> vec.vector_t,
+subtract is vec.vector_t -> vec.vector_t -> vec.vector_t,
+multiply is vec.vector_t -> vec.vector_t -> vec.vector_t,
+divideBy is number -> vec.vector_t -> vec.vector_t,
+scaled is number -> vec.vector_t -> vec.vector_t,
+abs is vec.vector_t -> vec.vector_t = abs',
+negative is vec.vector_t -> vec.vector_t,
+sqr is vec.vector_t -> vec.vector_t,
+sqrt is vec.vector_t -> vec.vector_t = sqrt',
+rms is vec.vector_t -> number,
+max is vec.vector_t -> number = max',
+min is vec.vector_t -> number = min',
+maxindex is vec.vector_t -> number,
+minindex is vec.vector_t -> number,
+unityNormalised is vec.vector_t -> vec.vector_t,
+fftshift is vec.vector_t -> vec.vector_t,
+ifftshift is vec.vector_t -> vec.vector_t,
+zipped is list?<vec.vector_t> -> vec.vector_t,
+unzipped is number -> vec.vector_t -> array<vec.vector_t>,
 }