update authors and docs

Author: 9il

dub.sdl

@@ -1,7 +1,7 @@
 name "mir-algorithm"
 description "Dlang Core Library"
 
-authors "Ilya Yaroshenko" "Sebastian Wilzbach" "Andrei Alexandrescu and Phobos Team (original Phobos code)" "John Michael Hall"
+authors "Ilya Yaroshenko" "John Michael Hall" "Shigeki Karita" "Sebastian Wilzbach" "Andrei Alexandrescu and Phobos Team (original Phobos code)"
 copyright "Copyright © 2016 - 2019, Ilya Yaroshenko; see also information per file."
 license "BSL-1.0"
 

source/mir/math/stat.d

@@ -7,7 +7,7 @@ at expense of precision, one can use $(REF_ALTTEXT $(TT Summation.fast), Summati
 
 License: $(LINK2 http://boost.org/LICENSE_1_0.txt, Boost License 1.0).
 
-Authors: Ilya Yaroshenko, John Michael Hall
+Authors: Shigeki Karita (original numir code), Ilya Yaroshenko, John Michael Hall
 
 Copyright: 2019 Symmetry Investments Group and Kaleidic Associates Advisory Limited.
 
@@ -129,13 +129,13 @@ template mean(Summation summation = Summation.appropriate)
     }
 }
 
-///ditto
+/// ditto
 template mean(F, string summation)
 {
     mixin("alias mean = .mean!(F, Summation." ~ summation ~ ");");
 }
 
-///ditto
+/// ditto
 template mean(string summation)
 {
     mixin("alias mean = .mean!(Summation." ~ summation ~ ");");
@@ -155,6 +155,143 @@ version(mir_test)
     assert(is(typeof(mean!float([1, 2, 3])) == float));
 }
 
+/// Mean of vector
+version(mir_test)
+@safe @nogc pure nothrow
+unittest
+{
+    import mir.ndslice.slice : sliced;
+
+    static immutable x = [0.0, 1.0, 1.5, 2.0, 3.5, 4.25,
+                          2.0, 7.5, 5.0, 1.0, 1.5, 0.0];
+    assert(x.sliced.mean == 29.25 / 12);
+}
+
+/// Mean of matrix
+version(mir_test)
+@safe @nogc pure nothrow
+unittest
+{
+    import mir.ndslice.slice : sliced;
+
+    static immutable x = [0.0, 1.0, 1.5, 2.0, 3.5, 4.25,
+                          2.0, 7.5, 5.0, 1.0, 1.5, 0.0];
+    assert(x.sliced(2, 6).mean == 29.25 / 12);
+}
+
+/// Column mean of matrix
+version(mir_test)
+@safe @nogc pure nothrow
+unittest
+{
+    import mir.ndslice.slice : sliced;
+    import mir.ndslice.topology : alongDim, byDim, map;
+
+    static immutable x = [0.0, 1.0, 1.5, 2.0, 3.5, 4.25,
+                          2.0, 7.5, 5.0, 1.0, 1.5, 0.0];
+    static immutable result = [1, 4.25, 3.25, 1.5, 2.5, 2.125];
+
+    // Use byDim or alongDim with map to compute mean of row/column.
+    assert(x.sliced(2, 6).byDim!1.map!mean == result);
+    assert(x.sliced(2, 6).alongDim!0.map!mean == result);
+
+    // FIXME
+    // Without using map, computes the mean of the whole slice
+    // assert(x.sliced(2, 6).byDim!1.mean == x.sliced.mean);
+    // assert(x.sliced(2, 6).alongDim!0.mean == x.sliced.mean);
+}
+
+/// Can also set algorithm or output type
+version(mir_test)
+@safe @nogc pure nothrow
+unittest
+{
+    import mir.ndslice.slice: sliced;
+    import mir.ndslice.topology: map, repeat;
+
+    //Set sum algorithm or output type
+
+    static immutable a = [1, 1e100, 1, -1e100];
+
+    auto x = a.sliced * 10_000;
+    assert(x.mean!"kbn" == 20_000 / 4);
+    assert(x.mean!"kb2" == 20_000 / 4);
+    assert(x.mean!"precise" == 20_000 / 4);
+    assert(x.mean!(double, "precise") == 20_000.0 / 4);
+
+    auto y = uint.max.repeat(3);
+    assert(y.mean!ulong == 12884901885 / 3);
+}
+
+/++
+For integral slices, pass output type as template parameter to ensure output
+type is correct
++/
+version(mir_test)
+@safe @nogc pure nothrow
+unittest
+{
+    import mir.ndslice.slice : sliced;
+    import std.math : approxEqual;
+
+    static immutable x = [0, 1, 1, 2, 4, 4,
+                          2, 7, 5, 1, 2, 0];
+    assert(approxEqual(x.sliced.mean!double, 29.0 / 12, 1.0e-10));
+}
+
+/// Mean works for complex numbers (and other user-defined types)
+version(mir_test)
+@safe @nogc pure nothrow
+unittest
+{
+    import mir.ndslice.slice : sliced;
+
+    static immutable cdouble[] x = [1.0 + 2i, 2 + 3i, 3 + 4i, 4 + 5i];
+    static immutable cdouble result = 2.5 + 3.5i;
+    assert(x.sliced.mean == result);
+}
+
+/// Compute mean tensors along specified dimention of tensors
+version(mir_test)
+@safe @nogc pure nothrow
+unittest
+{
+    import mir.ndslice : alongDim, iota, as, map;
+    /*
+      [[0,1,2],
+       [3,4,5]]
+     */
+    auto x = iota(2, 3).as!double;
+    assert(x.mean == (5.0 / 2.0));
+
+    static immutable m0 = [(0.0+3.0)/2.0, (1.0+4.0)/2.0, (2.0+5.0)/2.0];
+    assert(x.alongDim!0.map!mean == m0);
+    assert(x.alongDim!(-2).map!mean == m0);
+
+    static immutable m1 = [(0.0+1.0+2.0)/3.0, (3.0+4.0+5.0)/3.0];
+    assert(x.alongDim!1.map!mean == m1);
+    assert(x.alongDim!(-1).map!mean == m1);
+
+    assert(iota(2, 3, 4, 5).as!double.alongDim!0.map!mean == iota([3, 4, 5], 3 * 4 * 5 / 2));
+}
+
+///
+version(mir_test)
+@safe @nogc pure nothrow
+unittest
+{
+    import mir.ndslice.slice : sliced;
+    import mir.ndslice.topology : alongDim, byDim, map;
+
+    static immutable x      = [0.0, 1.00, 1.50, 2.0, 3.5, 4.250,
+                               2.0, 7.50, 5.00, 1.0, 1.5, 0.000];
+    static immutable result = [1.0, 4.25, 3.25, 1.5, 2.5, 2.125];
+
+    // Use byDim or alongDim with map to compute mean of row/column.
+    assert(x.sliced(2, 6).byDim!1.map!mean == result);
+    assert(x.sliced(2, 6).alongDim!0.map!mean == result);
+}
+
 version(mir_test)
 @safe pure nothrow unittest
 {

source/mir/ndslice/fuse.d

@@ -93,7 +93,6 @@ alias rcfuse(Dimensions...) = fuseImpl!(true, void, Dimensions);
     static assert(is(typeof(matrix) == Slice!(int*, 2)));
 }
 
-
 /// 3D
 @safe pure version(mir_test) unittest
 {

source/mir/ndslice/topology.d

@@ -97,7 +97,7 @@ $(SUBREF slice, Slice.shape), and $(SUBREF slice, Slice.elementCount).
 
 License:   $(HTTP boost.org/LICENSE_1_0.txt, Boost License 1.0).
 Copyright: Copyright © 2016-, Ilya Yaroshenko
-Authors:   Ilya Yaroshenko, Shigeki Karita (original numir code)
+Authors:   Ilya Yaroshenko, John Michael Hall, Shigeki Karita (original numir code)
 
 Sponsors: Part of this work has been sponsored by $(LINK2 http://symmetryinvestments.com, Symmetry Investments) and Kaleidic Associates.