Add new feature: rolling (#2)

Signed-off-by: Aravinda VK <vkaravinda7@gmail.com>

Author: aravindavk

README.md

@@ -299,3 +299,45 @@ To convert a DataFrame to JSON,
 ```d
 auto jsonData = df.toJSON;
 ```
+
+## Rolling
+Use this to apply aggregation function over a moving window. For example, to calculate the Simple moving average for the Price data.
+
+```d
+//                           FUNC  RETTYPE WINDOW
+df.sma21 = df.close.rolling!(mean, double)(21);
+```
+
+To use the cusom function with rolling. Example Exponential Moving Average:
+
+```d
+double[] ema(T)(T arr, int period)
+{
+    double prevEMA;
+    auto multiplier = 2.0 / (period + 1);
+
+    double emaFunc(int[] data)
+    {
+        if (isNaN(prevEMA))
+        {
+            prevEMA = mean(data);
+            return prevEMA;
+        }
+
+        auto lastValue = data[$-1];
+
+        prevEMA = lastValue * multiplier + prevEMA * (1 - multiplier);
+        return prevEMA;
+    }
+
+    return arr.rolling!(emaFunc, double)(period);
+}
+
+void main()
+{
+    auto window = 2;
+    auto arr = [10, 20, 30, 40, 50, 60, 70, 82, 91, 100];
+    writeln("SMA: ", arr.rolling!(mean, double)(window));
+    writeln("EMA: ", arr.ema(window));
+}
+```

source/dataframes/columns.d

@@ -47,6 +47,16 @@ struct Column(T)
         values ~= rhs;
     }
 
+    size_t opDollar(size_t pos)()
+    {
+        return values.length;
+    }
+
+    auto opSlice()(size_t start, size_t end)
+    {
+        return values[start .. end];
+    }
+
     T opIndex(size_t idx)
     {
         return values[idx];

source/dataframes/helpers.d

@@ -1,5 +1,6 @@
 module dataframes.helpers;
 
+import std.range.primitives : hasLength, hasSlicing;
 
 class DataFrameException : Exception
 {
@@ -9,3 +10,24 @@ class DataFrameException : Exception
     }
 }
 
+// Generic function for Rolling
+// [10, 20, 30, 40].rolling!(mean, double)(2)
+U[] rolling(alias func, U, T)(T data, int window)
+    if (hasLength!T)
+    {
+        U[] output;
+        if (data.length < window)
+        {
+            output.length = data.length;
+            return output;
+        }
+
+        // Start filling after window. Fill with output
+        // datatype default. Ex: nan for double
+        output.length = window - 1;
+
+        foreach(idx; 0..(data.length - window + 1))
+            output ~= func(data[idx .. idx + window]);
+
+        return output;
+    }

source/dataframes/package.d

@@ -75,6 +75,16 @@ class DataFrame(T)
 
     mixin("this(" ~ initializerArgs ~ "){" ~ initializerContent ~ "}");
 
+    size_t opDollar(size_t pos)()
+    {
+        return length;
+    }
+
+    auto opSlice()(size_t start, size_t end)
+    {
+        return iota(start, end).map!(idx => row(idx)).array;
+    }
+
     /**
      * Access the DataFrame column by label
      */
@@ -563,4 +573,32 @@ unittest
                         {"count":0,"name":"B","name2":"B3","value1":5.0,"value2":120.0},
                         {"count":0,"name":"C","name2":"C1","value1":6.0,"value2":60.0}]`;
     assert(df5.toJSON == parseJSON(jsonOutput));
+
+    struct Sample2
+    {
+        string name;
+        double value;
+        double avg;
+    }
+
+    auto dfSample2 = new DataFrame!Sample2(
+        name: ["A", "A", "B", "B", "B", "C"],
+        value: [1, 2, 3, 4, 5, 6]
+    );
+
+    import std.math : isNaN;
+
+    dfSample2.avg = dfSample2.value.rolling!(mean, double)(2);
+    assert(dfSample2.avg[0].isNaN);
+    assert(dfSample2.avg.values[1..$] == [1.5, 2.5, 3.5, 4.5, 5.5]);
+
+    double smaFunc(Row!Sample2[] data)
+    {
+        // Get the mean of the field "value"
+        return data.map!(a => a.value).mean;
+    }
+
+    dfSample2.avg = dfSample2.rolling!(smaFunc, double)(2);
+    assert(dfSample2.avg[0].isNaN);
+    assert(dfSample2.avg.values[1..$] == [1.5, 2.5, 3.5, 4.5, 5.5]);
 }