Mercurial > hg > may

changeset 484:9f87e8eb1e7e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge from branch opaque_type_references
author Chris Cannam
date Fri, 01 Nov 2013 22:12:37 +0000
parents b70acc1d84d9 (current diff) b510661536a6 (diff)
children 7bd05cfef750
files src/may/complex/type.yeti src/may/matrix/complex.yeti src/may/matrix/complextype.yeti src/may/matrix/test/test_complexmatrix.yeti src/may/matrix/type.yeti src/may/vector/type.yeti
diffstat 19 files changed, 202 insertions(+), 269 deletions(-) [+]
line wrap: on
line diff
--- a/src/may/complex.yeti	Fri Nov 01 17:05:31 2013 +0000
+++ b/src/may/complex.yeti	Fri Nov 01 22:12:37 2013 +0000
@@ -1,9 +1,6 @@
 
 module may.complex;
 
-load may.vector.type;
-load may.complex.type;
-
 vec = load may.vector;
 
 import java.lang: ClassCastException;
@@ -78,21 +75,23 @@
 zeros n is number -> array<~Cplx> =
     array (map \(complex 0 0) [1..n]);
 
-reals cc is list?<~Cplx> -> vector =
+reals cc is list?<~Cplx> -> 'a =
     vec.fromList (map real cc);
 
-imaginaries cc is list?<~Cplx> -> vector =
+imaginaries cc is list?<~Cplx> -> 'a =
     vec.fromList (map imaginary cc);
 
-magnitudes cc is list?<~Cplx> -> vector =
+magnitudes cc is list?<~Cplx> -> 'a =
     vec.fromList (map magnitude cc);
 
-angles cc is list?<~Cplx> -> vector =
+angles cc is list?<~Cplx> -> 'a =
     vec.fromList (map angle cc);
 
 complexArray reals imags =
     array (map2 complex (vec.list reals) (vec.list imags));
 
+typedef opaque complex_t = ~may.Cplx;
+
 {
    real,
    imaginary,
@@ -111,21 +110,21 @@
    angles,
    complexArray
 } as {
-   real is cplx -> number,
-   imaginary is cplx -> number,
-   complex is number -> number -> cplx,
-   magnitude is cplx -> number,
-   angle is cplx -> number,
-   sum is list?<cplx> -> cplx,
-   add is cplx -> cplx -> cplx,
-   multiply is cplx -> cplx -> cplx,
-   scale is number -> cplx -> cplx,
-   zero is cplx,
-   zeros is number -> array<cplx>,
-   reals is list?<cplx> -> vector,
-   imaginaries is list?<cplx> -> vector,
-   magnitudes is list?<cplx> -> vector,
-   angles is list?<cplx> -> vector,
-   complexArray is vector -> vector -> array<cplx>
+   real is complex_t -> number,
+   imaginary is complex_t -> number,
+   complex is number -> number -> complex_t,
+   magnitude is complex_t -> number,
+   angle is complex_t -> number,
+   sum is list?<complex_t> -> complex_t,
+   add is complex_t -> complex_t -> complex_t,
+   multiply is complex_t -> complex_t -> complex_t,
+   scale is number -> complex_t -> complex_t,
+   zero is complex_t,
+   zeros is number -> array<complex_t>,
+   reals is list?<complex_t> -> vec.vector_t,
+   imaginaries is list?<complex_t> -> vec.vector_t,
+   magnitudes is list?<complex_t> -> vec.vector_t,
+   angles is list?<complex_t> -> vec.vector_t,
+   complexArray is vec.vector_t -> vec.vector_t -> array<complex_t>
 }
 
--- a/src/may/complex/type.yeti	Fri Nov 01 17:05:31 2013 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,7 +0,0 @@
-
-module may.complex.type;
-
-typedef opaque cplx = ~may.Cplx;
-
-();
-
--- a/src/may/matrix.yeti	Fri Nov 01 17:05:31 2013 +0000
+++ b/src/may/matrix.yeti	Fri Nov 01 22:12:37 2013 +0000
@@ -44,8 +44,23 @@
 vec = load may.vector;
 bf = load may.vector.blockfuncs;
 
-load may.vector.type;
-load may.matrix.type;
+typedef opaque matrix_t =
+    DenseRows. array<vec.vector_t> | // array of rows
+    DenseCols. array<vec.vector_t> | // array of columns
+    SparseCSR. {
+        .values is vec.vector_t,
+        .indices is array<number>, // column index of each value
+        .pointers is array<number>, // offset of first value in each row
+        .extent is number // max possible index + 1, i.e. number of columns
+        } |
+    SparseCSC. {
+        .values is vec.vector_t,
+        .indices is array<number>, // row index of each value
+        .pointers is array<number>, // offset of first value in each column
+        .extent is number // max pointers index + 1, i.e. number of rows
+        };
+
+();
 
 width m = 
     case m of
@@ -833,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 17:05:31 2013 +0000
+++ b/src/may/matrix/complex.yeti	Fri Nov 01 22:12:37 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;
@@ -67,11 +69,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 = 
@@ -323,14 +325,14 @@
     height is complexmatrix -> number,
     density is complexmatrix -> number,
     nonZeroValues 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,
@@ -341,21 +343,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 17:05:31 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/matrix/test/test_complexmatrix.yeti	Fri Nov 01 17:05:31 2013 +0000
+++ b/src/may/matrix/test/test_complexmatrix.yeti	Fri Nov 01 22:12:37 2013 +0000
@@ -6,10 +6,6 @@
 cm = load may.matrix.complex;
 complex = load may.complex;
 
-load may.vector.type;
-load may.matrix.type;
-load may.matrix.complextype;
-
 { compare, compareUsing } = load may.test.test;
 
 aTestMatrix () =
--- a/src/may/matrix/test/test_matrix.yeti	Fri Nov 01 17:05:31 2013 +0000
+++ b/src/may/matrix/test/test_matrix.yeti	Fri Nov 01 22:12:37 2013 +0000
@@ -4,9 +4,6 @@
 mat = load may.matrix;
 vec = load may.vector;
 
-load may.vector.type;
-load may.matrix.type;
-
 import yeti.lang: FailureException;
 
 { compare, compareUsing } = load may.test.test;
--- a/src/may/matrix/type.yeti	Fri Nov 01 17:05:31 2013 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,23 +0,0 @@
-
-module may.matrix.type;
-
-load may.vector.type;
-
-typedef opaque matrix =
-    DenseRows. array<vector> | // array of rows
-    DenseCols. array<vector> | // array of columns
-    SparseCSR. {
-        .values is vector,
-        .indices is array<number>, // column index of each value
-        .pointers is array<number>, // offset of first value in each row
-        .extent is number // max possible index + 1, i.e. number of columns
-        } |
-    SparseCSC. {
-        .values is vector,
-        .indices is array<number>, // row index of each value
-        .pointers is array<number>, // offset of first value in each column
-        .extent is number // max pointers index + 1, i.e. number of rows
-        };
-
-();
-
--- a/src/may/stream/channels.yeti	Fri Nov 01 17:05:31 2013 +0000
+++ b/src/may/stream/channels.yeti	Fri Nov 01 22:12:37 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/convolve.yeti	Fri Nov 01 17:05:31 2013 +0000
+++ b/src/may/stream/convolve.yeti	Fri Nov 01 22:12:37 2013 +0000
@@ -10,8 +10,6 @@
 cplx = load may.complex;
 
 load may.stream.type;
-load may.vector.type;
-load may.matrix.type;
 
 //!!! todo: synchronized for everything with state assignment
 
@@ -149,6 +147,6 @@
     esac);
 
 {
-    convolvedWith is list<Fast boolean | Framesize number> -> matrix -> stream -> stream,
+    convolvedWith is list<Fast boolean | Framesize number> -> mat.matrix_t -> stream -> stream,
 }
 
--- a/src/may/stream/framer.yeti	Fri Nov 01 17:05:31 2013 +0000
+++ b/src/may/stream/framer.yeti	Fri Nov 01 22:12:37 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/manipulate.yeti	Fri Nov 01 17:05:31 2013 +0000
+++ b/src/may/stream/manipulate.yeti	Fri Nov 01 22:12:37 2013 +0000
@@ -7,8 +7,6 @@
 maths = load may.mathmisc;
 
 load may.stream.type;
-load may.vector.type;
-load may.matrix.type;
 
 //!!! todo: synchronized for everything with state assignment
 
--- a/src/may/stream/resample.yeti	Fri Nov 01 17:05:31 2013 +0000
+++ b/src/may/stream/resample.yeti	Fri Nov 01 22:12:37 2013 +0000
@@ -10,8 +10,6 @@
 maths = load may.mathmisc;
 
 load may.stream.type;
-load may.vector.type;
-load may.matrix.type;
 
 //!!! todo: synchronized for everything with state assignment
 
--- a/src/may/stream/syntheticstream.yeti	Fri Nov 01 17:05:31 2013 +0000
+++ b/src/may/stream/syntheticstream.yeti	Fri Nov 01 22:12:37 2013 +0000
@@ -5,8 +5,6 @@
 vec = load may.vector;
 mat = load may.matrix;
 
-load may.vector.type;
-load may.matrix.type;
 load may.stream.type;
 
 generated sampleRate generator =
@@ -114,9 +112,9 @@
 
 {
     generated is number -> (number -> number) -> stream, 
-    precalculated is number -> matrix -> stream,
-    precalculatedMono is number -> vector -> stream,
-    precalculatedRepeated is number -> matrix -> stream,
+    precalculated is number -> mat.matrix_t -> stream,
+    precalculatedMono is number -> vec.vector_t -> stream,
+    precalculatedRepeated is number -> mat.matrix_t -> stream,
     sinusoid is number -> number -> stream, 
     whiteNoise is number -> stream,
     pulseTrain is number -> number -> stream,
--- a/src/may/stream/type.yeti	Fri Nov 01 17:05:31 2013 +0000
+++ b/src/may/stream/type.yeti	Fri Nov 01 22:12:37 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 17:05:31 2013 +0000
+++ b/src/may/transform/fft.yeti	Fri Nov 01 22:12:37 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 17:05:31 2013 +0000
+++ b/src/may/vector.yeti	Fri Nov 01 22:12:37 2013 +0000
@@ -15,8 +15,6 @@
 
 module may.vector;
 
-load may.vector.type;
-
 import java.util: Arrays;
 
 /// Return a vector of n zeros.
@@ -154,6 +152,8 @@
 repeated v n is ~double[] -> number -> ~double[] =
     concat (map \(v) [1..n]);
 
+typedef opaque vector_t = ~double[];
+
 {
     zeros,
     consts,
@@ -175,27 +175,29 @@
     reverse,
     repeated,
     concat,
+    raw = id,
 } 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 vector -> number -> number,
-    equal is vector -> vector -> boolean,
-    equalUnder is (number -> number -> boolean) -> vector -> vector -> boolean,
-    slice is vector -> number -> number -> vector,
-    resizedTo is number -> vector -> vector,
-    reverse is vector -> vector,
-    repeated is vector -> number -> vector,
-    concat is list?<vector> -> vector,
+    zeros is number -> vector_t,
+    consts is number -> number -> vector_t,
+    ones is number -> vector_t,
+    vector is ~double[] -> vector_t,
+    primitive is vector_t -> ~double[],
+    floats is vector_t -> ~float[],
+    fromFloats is ~float[] -> vector_t,
+    fromList is list?<number> -> vector_t,
+    list is vector_t -> list<number>,
+    array is vector_t -> array<number>,
+    length is vector_t -> number,
+    empty? is vector_t -> boolean,
+    at is vector_t -> number -> number,
+    equal is vector_t -> vector_t -> boolean,
+    equalUnder is (number -> number -> boolean) -> vector_t -> vector_t -> boolean,
+    slice is vector_t -> number -> number -> vector_t,
+    resizedTo is number -> vector_t -> vector_t,
+    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 17:05:31 2013 +0000
+++ b/src/may/vector/blockfuncs.yeti	Fri Nov 01 22:12:37 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>,
 }
 
 
--- a/src/may/vector/type.yeti	Fri Nov 01 17:05:31 2013 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,7 +0,0 @@
-
-module may.vector.type;
-
-typedef opaque vector = ~double[];
-
-();
-