upgrade mir-algorithm version (#400)

9il · web-flow · commit f54c721fa097 · 2018-10-26T00:30:04.000+07:00
diff --git a/.gitignore b/.gitignore
@@ -52,3 +52,4 @@ examples/lda_hoffman_sparse
 benchmarks/ndslice/binarization
 benchmarks/ndslice/convolution
 benchmarks/ndslice/euclidean_distance
+mir-test-unittest.exe
diff --git a/circle.yml b/circle.yml
@@ -17,16 +17,11 @@ dependencies:
     - ldmd2 --version
     - curl -fsSL --retry 3 http://code.dlang.org/files/dub-${DUB}-linux-x86_64.tar.gz | tar -C ~/ldc2-$LDC-linux-x86_64/bin -zxf -
     - dub --version
-    # - wget -q -O dscanner "http://releases.dlang.io/dscanner/0.3.0-git/dscanner"
-    # - chmod +x dscanner
-    # - wget "https://raw.githubusercontent.com/dlang/dmd/master/src/checkwhitespace.d"
 test:
   override:
-    # - dscanResult=$(./dscanner --config .dscanner.ini --styleCheck source 2> /dev/null ) ; if [ -z "${dscanResult}" ] ; then echo "No warnings found" ; else echo $dscanResult && $(exit 1); fi
-    - grep -nE "(for|foreach|foreach_reverse|if|while)\(" $(find source -name '*.d'); test $? -eq 1
-    # - ldmd2 -O -release -run ./checkwhitespace.d $(find source -name '*.d')
     - dub test --compiler=ldmd2
     - dub test --compiler=ldmd2 --build=unittest-release
+    - git clone https://github.com/libmir/mir-core
     - git clone https://github.com/libmir/mir-random
     - git clone https://github.com/libmir/mir-algorithm
     - make -f doc/Makefile html
diff --git a/doc/Makefile b/doc/Makefile
@@ -16,7 +16,8 @@ DOC_SOURCE_DIR=doc
 GENERATED=.generated
 MIR_DIR=source
 RANDOM_DIR=mir-random/source
-ALOGORITHM_DIR=mir-algorithm/source
+ALGORITHM_DIR=mir-algorithm/source
+CORE_DIR=mir-core/source
 DLANGORG_DIR=$(DOC_SOURCE_DIR)/dlang.org
 ARTWORK_DIR=$(DOC_SOURCE_DIR)/artwork
 
@@ -83,7 +84,7 @@ ADDSOURCE=$(if $(subst index.d,,$1),$(MIR_DIR)/$1,$1)
 # ../web/phobos/std_conv.html : std/conv.d $(STDDOC) ; ...
 $(foreach p,$(SRC_DOCUMENTABLES),$(eval \
 $(DOC_OUTPUT_DIR)/$(call D2HTML,$p) : $(call ADDSOURCE,$p) $(STDDOC) ;\
-  $(DDOC) $(STDDOC) -I$(MIR_DIR) -I$(RANDOM_DIR) -I$(ALOGORITHM_DIR) -Df$$@ $$<))
+  $(DDOC) $(STDDOC) -I$(MIR_DIR) -I$(RANDOM_DIR) -I$(CORE_DIR) -I$(ALGORITHM_DIR) -Df$$@ $$<))
 
 ###########################################################
 # Setup all other resources needed by dlang.org
diff --git a/dub.json b/dub.json
@@ -13,23 +13,22 @@
     "configurations": [
         {
             "name": "source",
-            "targetType": "sourceLibrary",
+            "targetType": "sourceLibrary"
         },
         {
             "name": "static",
-            "targetType": "staticLibrary",
+            "targetType": "staticLibrary"
         },
         {
             "name": "dynamic",
-            "targetType": "dynamicLibrary",
+            "targetType": "dynamicLibrary"
         },
         {
             "name": "unittest",
-            "versions": ["to_be_filled"],
+            "versions": ["to_be_filled"]
         }
     ],
     "dependencies": {
-        "mir-random": ">=1.0.0 <2.0.0",
-        "mir-algorithm": ">=2.0.1 <2.5.0"
+        "mir-random": "~>2.0.0"
     }
 }
diff --git a/examples/means_of_columns.d b/examples/means_of_columns.d
@@ -29,8 +29,8 @@
 */
 
 import std.datetime.stopwatch;
-import std.conv : to;
 import std.stdio;
+import mir.conv : to;
 import mir.ndslice;
 
 enum testCount = 10_000;
@@ -41,7 +41,6 @@ void main() {
     sl = iota!int(100, 1000).slice;
     auto r = benchmark!({
     	means = sl
-        .universal
         .transposed
         .pack!1
         .map!(col => reduce!"a + b"(0L, col) / double(col.length))
diff --git a/source/mir/model/lda/hoffman.d b/source/mir/model/lda/hoffman.d
@@ -135,14 +135,15 @@ struct LdaHoffman(F)
 
     Params:
         n = mini-batch, a collection of compressed documents.
-        maxIterations = maximal number of iterations for single document in a batch for E-step.
+        maxIterations = maximal number of iterations for s    This implementation is optimized for sparse documents,
+ingle document in a batch for E-step.
     +/
-    size_t putBatch(SliceKind kind, C, I, J)(Slice!(FieldIterator!(CompressedField!(C, I, J)), 1, kind) n, size_t maxIterations)
+    size_t putBatch(SliceKind kind, C, I, J)(Slice!(ChopIterator!(J*, Series!(I*, C*)), 1, kind) n, size_t maxIterations)
     {
         return putBatchImpl(n.recompress!F, maxIterations);
     }
 
-    private size_t putBatchImpl(CompressedTensor!(F, 2) n, size_t maxIterations)
+    private size_t putBatchImpl(Slice!(ChopIterator!(size_t*, Series!(uint*, F*))) n, size_t maxIterations)
     {
         import std.math: isFinite;
         import mir.sparse.blas.dot;
@@ -191,7 +192,7 @@ struct LdaHoffman(F)
                 }
                 if (c < maxIterations && sum > eps * K)
                 {
-                    nd.values[] = nsave[d].values;
+                    nd.value[] = nsave[d].value;
                     continue;
                 }
                 import core.atomic;
@@ -212,16 +213,13 @@ struct LdaHoffman(F)
         return ret;
     }
 
-    private auto saveN(CompressedTensor!(F, 2) n)
+    private auto saveN(Slice!(ChopIterator!(size_t*, Series!(uint*, F*))) n)
     {
-        import mir.ndslice.topology: universal;
-        return
-            CompressedField!(F)(
-                n.iterator._field.compressedLength,
-                n.iterator._field.values.dup,
-                n.iterator._field.indexes,
-                n.iterator._field.pointers)
-            .slicedField(n.length).universal;
+        import mir.series: series;
+        import mir.ndslice.topology: chopped, universal;
+        return n.iterator._sliceable.index
+            .series(n.iterator._sliceable.value.dup)
+            .chopped(n.iterator._iterator.sliced(n.length + 1));
     }
 
     private static void unparameterize(Vector param, Vector posterior)
diff --git a/source/mir/sparse/blas/axpy.d b/source/mir/sparse/blas/axpy.d
@@ -8,6 +8,7 @@ module mir.sparse.blas.axpy;
 import std.traits;
 import mir.ndslice.slice;
 import mir.sparse;
+import mir.series;
 
 /++
 Constant times a vector plus a vector.
@@ -21,47 +22,46 @@ Returns:
 +/
 void axpy(
     CR,
-    V1 : CompressedArray!(T1, I1),
-    T1, I1, V2)
+    V1 : Series!(I1, T1),
+    I1, T1, V2)
 (in CR alpha, V1 x, V2 y)
     if (isDynamicArray!V2 || isSlice!V2)
 in
 {
-    if (x.indexes.length)
-        assert(x.indexes[$-1] < y.length);
+    if (x.index.length)
+        assert(x.index[$-1] < y.length);
 }
 body
 {
     import mir.internal.utility;
 
-    foreach (size_t i; 0 .. x.indexes.length)
+    foreach (size_t i; 0 .. x.index.length)
     {
-        auto j = x.indexes[i];
-        y[j] = alpha * x.values[i] + y[j];
+        auto j = x.index[i];
+        y[j] = alpha * x.value[i] + y[j];
     }
 }
 
 ///
 unittest
 {
-    auto x = CompressedArray!(double, uint)([1.0, 3, 4, 9, 13], [0, 3, 5, 9, 10]);
+    auto x = series([0, 3, 5, 9, 10], [1.0, 3, 4, 9, 13]);
     auto y = [0.0, 1.0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
     axpy(2.0, x, y);
     assert(y == [2.0, 1.0, 2, 9, 4, 13, 6, 7, 8, 27, 36, 11, 12]);
 }
 
 unittest
 {
-    auto x = CompressedArray!(double, uint)([1.0, 3, 4, 9, 13], [0, 3, 5, 9, 10]);
+    auto x = series([0, 3, 5, 9, 10], [1.0, 3, 4, 9, 13]);
     auto y = [0.0, 1.0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
     axpy(2.0, x, y.sliced);
     assert(y == [2.0, 1.0, 2, 9, 4, 13, 6, 7, 8, 27, 36, 11, 12]);
 }
 
 unittest
 {
-    import std.typecons: No;
-    auto x = CompressedArray!(double, uint)([1.0, 3, 4, 9, 13], [0, 3, 5, 9, 10]);
+    auto x = series([0, 3, 5, 9, 10], [1.0, 3, 4, 9, 13]);
     auto y = [0.0, 1.0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
     axpy(2.0, x, y.slicedField);
     assert(y == [2.0, 1.0, 2, 9, 4, 13, 6, 7, 8, 27, 36, 11, 12]);
diff --git a/source/mir/sparse/blas/dot.d b/source/mir/sparse/blas/dot.d
@@ -8,6 +8,7 @@ module mir.sparse.blas.dot;
 import std.traits;
 import mir.ndslice.slice;
 import mir.sparse;
+import mir.series;
 
 /++
 Dot product of two vectors
@@ -19,8 +20,8 @@ Returns:
     scalar `xᵀ × y`
 +/
 Unqual!(CommonType!(T1, T2)) dot(
-    V1 : CompressedArray!(T1, I1),
-    V2 : CompressedArray!(T2, I2),
+    V1 : Series!(I1*, T1*),
+    V2 : Series!(I2*, T2*),
     T1, T2, I1, I2)
 (V1 x, V2 y)
 {
@@ -30,8 +31,8 @@ Unqual!(CommonType!(T1, T2)) dot(
 /// ditto
 D dot(
     D,
-    V1 : CompressedArray!(T1, I1),
-    V2 : CompressedArray!(T2, I2),
+    V1 : Series!(I1*, T1*),
+    V2 : Series!(I2*, T2*),
     T1, T2, I1, I2)
 (V1 x, V2 y)
 {
@@ -42,40 +43,38 @@ D dot(
     Unqual!I1 ai0 = void;
     Unqual!I2 bi0 = void;
 
-    if (x.indexes.length && y.indexes.length) for (;;)
+    if (x.length && y.length) for (;;)
     {
-        bi0 = y.indexes[0];
-        if (x.indexes[0] < bi0)
+        bi0 = y.index[0];
+        if (x.index[0] < bi0)
         {
             do
             {
-                x.values = x.values[1 .. $];
-                x.indexes = x.indexes[1 .. $];
-                if (x.indexes.length == 0)
+                x.popFront;
+                if (x.length == 0)
                 {
                     break;
                 }
             }
-            while (x.indexes[0] < bi0);
+            while (x.index[0] < bi0);
             done = 2;
         }
         if (--done == 0)
         {
             goto L;
         }
-        ai0 = x.indexes[0];
-        if (y.indexes[0] < ai0)
+        ai0 = x.index[0];
+        if (y.index[0] < ai0)
         {
             do
             {
-                y.values = y.values[1 .. $];
-                y.indexes = y.indexes[1 .. $];
-                if (y.indexes.length == 0)
+                y.popFront;
+                if (y.length == 0)
                 {
                     break;
                 }
             }
-            while (y.indexes[0] < ai0);
+            while (y.index[0] < ai0);
             done = 2;
         }
         if (--done == 0)
@@ -84,19 +83,17 @@ D dot(
         }
         continue;
         L:
-        s = x.values[0] * y.values[0] + s;
-        x.indexes = x.indexes[1 .. $];
-        if (x.indexes.length == 0)
+        s = x.value[0] * y.value[0] + s;
+        x.popFront;
+        if (x.length == 0)
         {
             break;
         }
-        y.indexes = y.indexes[1 .. $];
-        if (y.indexes.length == 0)
+        y.popFront;
+        if (y.length == 0)
         {
             break;
         }
-        x.values = x.values[1 .. $];
-        y.values = y.values[1 .. $];
     }
 
     return s;
@@ -105,8 +102,8 @@ D dot(
 ///
 unittest
 {
-    auto x = CompressedArray!(int, uint)([1, 3, 4, 9, 10], [0, 3, 5, 9, 100]);
-    auto y = CompressedArray!(int, uint)([1, 10, 100, 1000], [1, 3, 4, 9]);
+    auto x = series([0u, 3, 5, 9, 100], [1, 3, 4, 9, 10]);
+    auto y = series([1u, 3, 4, 9], [1, 10, 100, 1000]);
     // x = [1, 0, 0,  3, 0, 4, 0, 0, 0, 9, ... ,10]
     // y = [0, 1, 0, 10, 0, 0, 0, 0, 0, 1000]
     assert(dot(x, y) == 9030);
@@ -122,7 +119,7 @@ Returns:
     scalar `x × y`
 +/
 Unqual!(CommonType!(T1, ForeachType!V2)) dot(
-    V1 : CompressedArray!(T1, I1),
+    V1 : Series!(I1*, T1*),
     T1, I1, V2)
 (V1 x, V2 y)
     if (isDynamicArray!V2 || isSlice!V2)
@@ -133,14 +130,14 @@ Unqual!(CommonType!(T1, ForeachType!V2)) dot(
 ///ditto
 D dot(
     D,
-    V1 : CompressedArray!(T1, I1),
+    V1 : Series!(I1*, T1*),
     T1, I1, V2)
 (V1 x, V2 y)
     if (isDynamicArray!V2 || isSlice!V2)
 in
 {
-    if (x.indexes.length)
-        assert(x.indexes[$-1] < y.length);
+    if (x.length)
+        assert(x.index[$-1] < y.length);
 }
 body
 {
@@ -151,9 +148,9 @@ body
 
     alias F = Unqual!(CommonType!(T1, T2));
     F s = 0;
-    foreach (size_t i; 0 .. x.indexes.length)
+    foreach (size_t i; 0 .. x.index.length)
     {
-        s = y[x.indexes[i]] * x.values[i] + s;
+        s = y[x.index[i]] * x.value[i] + s;
     }
 
     return s;
@@ -163,7 +160,7 @@ body
 unittest
 {
     import std.typecons: No;
-    auto x = CompressedArray!(double, uint)([1.0, 3, 4, 9, 13], [0, 3, 5, 9, 10]);
+    auto x = [0u, 3, 5, 9, 10].series([1.0, 3, 4, 9, 13]);
     auto y = [0.0, 1.0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
     // x: [1, 0, 0, 3, 0, 4, 0, 0, 0, 9, 13,  0,  0,  0]
     // y: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
diff --git a/source/mir/sparse/blas/gemm.d b/source/mir/sparse/blas/gemm.d
diff --git a/source/mir/sparse/blas/gemv.d b/source/mir/sparse/blas/gemv.d
diff --git a/source/mir/sparse/package.d b/source/mir/sparse/package.d

Original file line number	Diff line number	Diff line change
`@@ -13,23 +13,22 @@`
`13`	`13`	`"configurations": [`
`14`	`14`	`{`
`15`	`15`	`"name": "source",`
`16`		`- "targetType": "sourceLibrary",`
	`16`	`+ "targetType": "sourceLibrary"`
`17`	`17`	`},`
`18`	`18`	`{`
`19`	`19`	`"name": "static",`
`20`		`- "targetType": "staticLibrary",`
	`20`	`+ "targetType": "staticLibrary"`
`21`	`21`	`},`
`22`	`22`	`{`
`23`	`23`	`"name": "dynamic",`
`24`		`- "targetType": "dynamicLibrary",`
	`24`	`+ "targetType": "dynamicLibrary"`
`25`	`25`	`},`
`26`	`26`	`{`
`27`	`27`	`"name": "unittest",`
`28`		`- "versions": ["to_be_filled"],`
	`28`	`+ "versions": ["to_be_filled"]`
`29`	`29`	`}`
`30`	`30`	`],`
`31`	`31`	`"dependencies": {`
`32`		`- "mir-random": ">=1.0.0 <2.0.0",`
`33`		`- "mir-algorithm": ">=2.0.1 <2.5.0"`
	`32`	`+ "mir-random": "~>2.0.0"`
`34`	`33`	`}`
`35`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -135,14 +135,15 @@ struct LdaHoffman(F)`
`135`	`135`
`136`	`136`	`Params:`
`137`	`137`	`n = mini-batch, a collection of compressed documents.`
`138`		`- maxIterations = maximal number of iterations for single document in a batch for E-step.`
	`138`	`+ maxIterations = maximal number of iterations for s This implementation is optimized for sparse documents,`
	`139`	`+ingle document in a batch for E-step.`
`139`	`140`	`+/`
`140`		`- size_t putBatch(SliceKind kind, C, I, J)(Slice!(FieldIterator!(CompressedField!(C, I, J)), 1, kind) n, size_t maxIterations)`
	`141`	`+ size_t putBatch(SliceKind kind, C, I, J)(Slice!(ChopIterator!(J, Series!(I, C*)), 1, kind) n, size_t maxIterations)`
`141`	`142`	`{`
`142`	`143`	`return putBatchImpl(n.recompress!F, maxIterations);`
`143`	`144`	`}`
`144`	`145`
`145`		`- private size_t putBatchImpl(CompressedTensor!(F, 2) n, size_t maxIterations)`
	`146`	`+ private size_t putBatchImpl(Slice!(ChopIterator!(size_t, Series!(uint, F*))) n, size_t maxIterations)`
`146`	`147`	`{`
`147`	`148`	`import std.math: isFinite;`
`148`	`149`	`import mir.sparse.blas.dot;`
`@@ -191,7 +192,7 @@ struct LdaHoffman(F)`
`191`	`192`	`}`
`192`	`193`	`if (c < maxIterations && sum > eps * K)`
`193`	`194`	`{`
`194`		`- nd.values[] = nsave[d].values;`
	`195`	`+ nd.value[] = nsave[d].value;`
`195`	`196`	`continue;`
`196`	`197`	`}`
`197`	`198`	`import core.atomic;`
`@@ -212,16 +213,13 @@ struct LdaHoffman(F)`
`212`	`213`	`return ret;`
`213`	`214`	`}`
`214`	`215`
`215`		`- private auto saveN(CompressedTensor!(F, 2) n)`
	`216`	`+ private auto saveN(Slice!(ChopIterator!(size_t, Series!(uint, F*))) n)`
`216`	`217`	`{`
`217`		`- import mir.ndslice.topology: universal;`
`218`		`- return`
`219`		`- CompressedField!(F)(`
`220`		`- n.iterator._field.compressedLength,`
`221`		`- n.iterator._field.values.dup,`
`222`		`- n.iterator._field.indexes,`
`223`		`- n.iterator._field.pointers)`
`224`		`- .slicedField(n.length).universal;`
	`218`	`+ import mir.series: series;`
	`219`	`+ import mir.ndslice.topology: chopped, universal;`
	`220`	`+ return n.iterator._sliceable.index`
	`221`	`+ .series(n.iterator._sliceable.value.dup)`
	`222`	`+ .chopped(n.iterator._iterator.sliced(n.length + 1));`
`225`	`223`	`}`
`226`	`224`
`227`	`225`	`private static void unparameterize(Vector param, Vector posterior)`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@ module mir.sparse.blas.dot;`
`8`	`8`	`import std.traits;`
`9`	`9`	`import mir.ndslice.slice;`
`10`	`10`	`import mir.sparse;`
	`11`	`+import mir.series;`
`11`	`12`
`12`	`13`	`/++`
`13`	`14`	`Dot product of two vectors`
`@@ -19,8 +20,8 @@ Returns:`
`19`	`20`	scalar `xᵀ × y`
`20`	`21`	`+/`
`21`	`22`	`Unqual!(CommonType!(T1, T2)) dot(`
`22`		`- V1 : CompressedArray!(T1, I1),`
`23`		`- V2 : CompressedArray!(T2, I2),`
	`23`	`+ V1 : Series!(I1, T1),`
	`24`	`+ V2 : Series!(I2, T2),`
`24`	`25`	`T1, T2, I1, I2)`
`25`	`26`	`(V1 x, V2 y)`
`26`	`27`	`{`
`@@ -30,8 +31,8 @@ Unqual!(CommonType!(T1, T2)) dot(`
`30`	`31`	`/// ditto`
`31`	`32`	`D dot(`
`32`	`33`	`D,`
`33`		`- V1 : CompressedArray!(T1, I1),`
`34`		`- V2 : CompressedArray!(T2, I2),`
	`34`	`+ V1 : Series!(I1, T1),`
	`35`	`+ V2 : Series!(I2, T2),`
`35`	`36`	`T1, T2, I1, I2)`
`36`	`37`	`(V1 x, V2 y)`
`37`	`38`	`{`
`@@ -42,40 +43,38 @@ D dot(`
`42`	`43`	`Unqual!I1 ai0 = void;`
`43`	`44`	`Unqual!I2 bi0 = void;`
`44`	`45`
`45`		`- if (x.indexes.length && y.indexes.length) for (;;)`
	`46`	`+ if (x.length && y.length) for (;;)`
`46`	`47`	`{`
`47`		`- bi0 = y.indexes[0];`
`48`		`- if (x.indexes[0] < bi0)`
	`48`	`+ bi0 = y.index[0];`
	`49`	`+ if (x.index[0] < bi0)`
`49`	`50`	`{`
`50`	`51`	`do`
`51`	`52`	`{`
`52`		`- x.values = x.values[1 .. $];`
`53`		`- x.indexes = x.indexes[1 .. $];`
`54`		`- if (x.indexes.length == 0)`
	`53`	`+ x.popFront;`
	`54`	`+ if (x.length == 0)`
`55`	`55`	`{`
`56`	`56`	`break;`
`57`	`57`	`}`
`58`	`58`	`}`
`59`		`- while (x.indexes[0] < bi0);`
	`59`	`+ while (x.index[0] < bi0);`
`60`	`60`	`done = 2;`
`61`	`61`	`}`
`62`	`62`	`if (--done == 0)`
`63`	`63`	`{`
`64`	`64`	`goto L;`
`65`	`65`	`}`
`66`		`- ai0 = x.indexes[0];`
`67`		`- if (y.indexes[0] < ai0)`
	`66`	`+ ai0 = x.index[0];`
	`67`	`+ if (y.index[0] < ai0)`
`68`	`68`	`{`
`69`	`69`	`do`
`70`	`70`	`{`
`71`		`- y.values = y.values[1 .. $];`
`72`		`- y.indexes = y.indexes[1 .. $];`
`73`		`- if (y.indexes.length == 0)`
	`71`	`+ y.popFront;`
	`72`	`+ if (y.length == 0)`
`74`	`73`	`{`
`75`	`74`	`break;`
`76`	`75`	`}`
`77`	`76`	`}`
`78`		`- while (y.indexes[0] < ai0);`
	`77`	`+ while (y.index[0] < ai0);`
`79`	`78`	`done = 2;`
`80`	`79`	`}`
`81`	`80`	`if (--done == 0)`
`@@ -84,19 +83,17 @@ D dot(`
`84`	`83`	`}`
`85`	`84`	`continue;`
`86`	`85`	`L:`
`87`		`- s = x.values[0] * y.values[0] + s;`
`88`		`- x.indexes = x.indexes[1 .. $];`
`89`		`- if (x.indexes.length == 0)`
	`86`	`+ s = x.value[0] * y.value[0] + s;`
	`87`	`+ x.popFront;`
	`88`	`+ if (x.length == 0)`
`90`	`89`	`{`
`91`	`90`	`break;`
`92`	`91`	`}`
`93`		`- y.indexes = y.indexes[1 .. $];`
`94`		`- if (y.indexes.length == 0)`
	`92`	`+ y.popFront;`
	`93`	`+ if (y.length == 0)`
`95`	`94`	`{`
`96`	`95`	`break;`
`97`	`96`	`}`
`98`		`- x.values = x.values[1 .. $];`
`99`		`- y.values = y.values[1 .. $];`
`100`	`97`	`}`
`101`	`98`
`102`	`99`	`return s;`
`@@ -105,8 +102,8 @@ D dot(`
`105`	`102`	`///`
`106`	`103`	`unittest`
`107`	`104`	`{`
`108`		`- auto x = CompressedArray!(int, uint)([1, 3, 4, 9, 10], [0, 3, 5, 9, 100]);`
`109`		`- auto y = CompressedArray!(int, uint)([1, 10, 100, 1000], [1, 3, 4, 9]);`
	`105`	`+ auto x = series([0u, 3, 5, 9, 100], [1, 3, 4, 9, 10]);`
	`106`	`+ auto y = series([1u, 3, 4, 9], [1, 10, 100, 1000]);`
`110`	`107`	`// x = [1, 0, 0, 3, 0, 4, 0, 0, 0, 9, ... ,10]`
`111`	`108`	`// y = [0, 1, 0, 10, 0, 0, 0, 0, 0, 1000]`
`112`	`109`	`assert(dot(x, y) == 9030);`
`@@ -122,7 +119,7 @@ Returns:`
`122`	`119`	scalar `x × y`
`123`	`120`	`+/`
`124`	`121`	`Unqual!(CommonType!(T1, ForeachType!V2)) dot(`
`125`		`- V1 : CompressedArray!(T1, I1),`
	`122`	`+ V1 : Series!(I1, T1),`
`126`	`123`	`T1, I1, V2)`
`127`	`124`	`(V1 x, V2 y)`
`128`	`125`	`if (isDynamicArray!V2 \|\| isSlice!V2)`
`@@ -133,14 +130,14 @@ Unqual!(CommonType!(T1, ForeachType!V2)) dot(`
`133`	`130`	`///ditto`
`134`	`131`	`D dot(`
`135`	`132`	`D,`
`136`		`- V1 : CompressedArray!(T1, I1),`
	`133`	`+ V1 : Series!(I1, T1),`
`137`	`134`	`T1, I1, V2)`
`138`	`135`	`(V1 x, V2 y)`
`139`	`136`	`if (isDynamicArray!V2 \|\| isSlice!V2)`
`140`	`137`	`in`
`141`	`138`	`{`
`142`		`- if (x.indexes.length)`
`143`		`- assert(x.indexes[$-1] < y.length);`
	`139`	`+ if (x.length)`
	`140`	`+ assert(x.index[$-1] < y.length);`
`144`	`141`	`}`
`145`	`142`	`body`
`146`	`143`	`{`
`@@ -151,9 +148,9 @@ body`
`151`	`148`
`152`	`149`	`alias F = Unqual!(CommonType!(T1, T2));`
`153`	`150`	`F s = 0;`
`154`		`- foreach (size_t i; 0 .. x.indexes.length)`
	`151`	`+ foreach (size_t i; 0 .. x.index.length)`
`155`	`152`	`{`
`156`		`- s = y[x.indexes[i]] * x.values[i] + s;`
	`153`	`+ s = y[x.index[i]] * x.value[i] + s;`
`157`	`154`	`}`
`158`	`155`
`159`	`156`	`return s;`
`@@ -163,7 +160,7 @@ body`
`163`	`160`	`unittest`
`164`	`161`	`{`
`165`	`162`	`import std.typecons: No;`
`166`		`- auto x = CompressedArray!(double, uint)([1.0, 3, 4, 9, 13], [0, 3, 5, 9, 10]);`
	`163`	`+ auto x = [0u, 3, 5, 9, 10].series([1.0, 3, 4, 9, 13]);`
`167`	`164`	`auto y = [0.0, 1.0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];`
`168`	`165`	`// x: [1, 0, 0, 3, 0, 4, 0, 0, 0, 9, 13, 0, 0, 0]`
`169`	`166`	`// y: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]`