rework sum, appender, and mean (#240)

* rework sum and mean

* fixup

Author: 9il

source/mir/appender.d

@@ -35,9 +35,9 @@ struct ScopedBuffer(T, size_t bytes = 4096)
     private size_t _currentLength;
     private align(T.alignof) ubyte[_bufferLength * T.sizeof] _scopeBufferPayload = void;
 
-    private ref T[_bufferLength] _scopeBuffer() @trusted scope
+    private ref inout(T[_bufferLength]) _scopeBuffer() inout @trusted scope
     {
-        return *cast(T[_bufferLength]*)&_scopeBufferPayload;
+        return *cast(inout(T[_bufferLength])*)&_scopeBufferPayload;
     }
 
     private T[] prepare(size_t n) @trusted scope
@@ -71,15 +71,41 @@ struct ScopedBuffer(T, size_t bytes = 4096)
     else
         private alias R = T;
 
-    ///
+    /// Copy constructor is enabled only if `T` is mutable type without eleborate assign.
+    static if (isMutable!T && !hasElaborateAssign!T)
+    this(this)
+    {
+        import mir.internal.memory: malloc;
+        if (_buffer.ptr)
+        {
+            auto buffer = (cast(T*)malloc(T.sizeof * _buffer.length))[0 .. _buffer.length];
+            buffer[0 .. _currentLength] = _buffer[0 .. _currentLength];
+            _buffer = buffer;
+        }
+    }
+    else
     @disable this(this);
 
     ///
     ~this()
     {
         import mir.internal.memory: free;
         data._mir_destroy;
-        (() @trusted => free(cast(void*)_buffer.ptr))();
+        (() @trusted { if (_buffer.ptr) free(cast(void*)_buffer.ptr); })();
+    }
+
+    ///
+    void shrinkTo(size_t length)
+    {
+        assert(length <= _currentLength);
+        data[length .. _currentLength]._mir_destroy;
+        _currentLength = length;
+    }
+
+    ///
+    size_t length() scope const @property
+    {
+        return _currentLength;
     }
 
     ///
@@ -160,7 +186,7 @@ struct ScopedBuffer(T, size_t bytes = 4096)
     }
 
     ///
-    T[] data() @property @safe scope
+    inout(T)[] data() inout @property @safe scope
     {
         return _buffer.length ? _buffer[0 .. _currentLength] : _scopeBuffer[0 .. _currentLength];
     }

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
+Authors: Ilya Yaroshenko, John Michael Hall
 
 Copyright: 2019 Symmetry Investments Group and Kaleidic Associates Advisory Limited.
 
@@ -23,41 +23,116 @@ import mir.math.common: fmamath;
 import mir.math.sum;
 import mir.primitives;
 import std.range.primitives: isInputRange;
-import std.traits: isArray, isFloatingPoint;
+import std.traits: isArray, isFloatingPoint, isMutable, isIterable;
 
 /++
-Computes the average of `r`, which must be a finite iterable.
-
-Returns:
-    The average of all the elements in the range r.
+Output range for mean.
 +/
-template mean(Summation summation = Summation.appropriate)
+struct MeanAccumulator(T, Summation summation) 
+    if (isMutable!T)
 {
     ///
-    @safe @fmamath sumType!Range
-    mean(Range)(Range r)
-        if (hasLength!Range
-         || summation == Summation.appropriate
-         || summation == Summation.fast
-         || summation == Summation.naive)
+    size_t count;
+    ///
+    Summator!(T, summation) sumAccumulator;
+
+    ///
+    F mean(F = T)() @property
     {
-        static if (hasLength!Range)
+        return cast(F) sumAccumulator.sum / cast(F) count;
+    }
+
+    ///
+    void put(Range)(Range r)
+        if (isIterable!Range)
+    {
+        static if (hasShape!Range)
         {
-            auto n = r.length;
-            return sum!summation(r.move) / cast(sumType!Range) n;
+            count += r.elementCount;
+            sumAccumulator.put(r);
         }
         else
         {
-            auto s = cast(typeof(return)) 0;
-            size_t length;
-            foreach (e; r)
+            foreach(x; r)
             {
-                length++;
-                s += e;
+                count++;
+                sumAccumulator.put(x);
             }
-            return s / cast(sumType!Range) length;
         }
     }
+
+    ///
+    void put()(T x)
+    {
+        count++;
+        sumAccumulator.put(x);
+    }
+}
+
+///
+version(mir_test)
+@safe pure nothrow unittest
+{
+    import mir.ndslice.slice : sliced;
+
+    MeanAccumulator!(double, Summation.pairwise) x;
+    x.put([0.0, 1, 2, 3, 4].sliced);
+    assert(x.mean == 2);
+    x.put(5);
+    assert(x.mean == 2.5);
+}
+
+version(mir_test)
+@safe pure nothrow unittest
+{
+    import mir.ndslice.slice : sliced;
+
+    MeanAccumulator!(float, Summation.pairwise) x;
+    x.put([0, 1, 2, 3, 4].sliced);
+    assert(x.mean == 2);
+    x.put(5);
+    assert(x.mean == 2.5);
+}
+
+/++
+Computes the average of `r`, which must be a finite iterable.
+
+Returns:
+    The average of all the elements in the range r.
++/
+template mean(F, Summation summation = Summation.appropriate)
+{
+    /++
+    Params:
+        r = range
+    +/
+    F mean(Range)(Range r)
+        if (isIterable!Range)
+    {
+        MeanAccumulator!(F, ResolveSummationType!(summation, Range, sumType!Range)) mean;
+        mean.put(r.move);
+        return mean.mean;
+    }
+}
+
+/// ditto
+template mean(Summation summation = Summation.appropriate)
+{
+    /++
+    Params:
+        r = range
+    +/
+    sumType!Range mean(Range)(Range r)
+        if (isIterable!Range)
+    {
+        return .mean!(sumType!Range, summation)(r.move);
+    }
+}
+
+///ditto
+template mean(F, string summation)
+{
+    mixin("alias mean = .mean!(F, Summation." ~ summation ~ ");");
 }
 
 ///ditto
@@ -67,10 +142,23 @@ template mean(string summation)
 }
 
 ///
-version(mir_test) @safe pure nothrow unittest
+version(mir_test)
+@safe pure nothrow unittest
 {
+    import mir.ndslice.slice : sliced;
+
     assert(mean([1.0, 2, 3]) == 2);
     assert(mean([1.0 + 3i, 2, 3]) == 2 + 1i);
+    
+    assert(mean!float([0, 1, 2, 3, 4, 5].sliced(3, 2)) == 2.5);
+    
+    assert(is(typeof(mean!float([1, 2, 3])) == float));
+}
+
+version(mir_test)
+@safe pure nothrow unittest
+{
+    assert([1.0, 2, 3, 4].mean == 2.5);
 }
 
 /++
@@ -157,7 +245,8 @@ template simpleLinearRegression(string summation)
 }
 
 ///
-version(mir_test) @safe pure nothrow @nogc unittest
+version(mir_test)
+@safe pure nothrow @nogc unittest
 {
     import mir.math.common: approxEqual;
     static immutable x = [0, 1, 2, 3];