Implemented resample method

Author: dtymakhov

ManagedCode.TimeSeries.Tests/TimeSeriesTests.cs

@@ -69,7 +69,7 @@ public async Task AccumulatorLimit()
             series.AddNewData(i);
         }
 
-        series.SamplesCount.Should().Be(10);
+        series.Samples.Count.Should().Be(10);
     }
 
     [Fact]
@@ -119,12 +119,12 @@ public async Task AccumulatorMerge()
 
         await Task.WhenAll(seriesA, seriesB);
 
-        seriesA.Result.SamplesCount.Should().Be(10);
-        seriesB.Result.SamplesCount.Should().Be(10);
+        seriesA.Result.Samples.Count.Should().Be(10);
+        seriesB.Result.Samples.Count.Should().Be(10);
 
         seriesA.Result.Merge(seriesB.Result);
 
-        seriesA.Result.SamplesCount.Should().Be(10);
+        seriesA.Result.Samples.Count.Should().Be(10);
 
         var seriesList = new List<IntTimeSeriesAccumulator>();
         seriesList.Add(await FillFunc());
@@ -145,7 +145,7 @@ public async Task AccumulatorMerge()
             }
         }
 
-        onlineExpertsPerHourTimeSeries.SamplesCount.Should().Be(10);
+        onlineExpertsPerHourTimeSeries.Samples.Count.Should().Be(10);
     }
 
     [Fact]
@@ -247,6 +247,38 @@ public async Task SummerMerge()
         seriesA.Result.Samples.Select(s => s.Value).Sum().Should().Be(200);
     }
 
+    [Fact]
+    public async Task Resample()
+    {
+        var seriesFeature = new IntTimeSeriesAccumulator(TimeSpan.FromMilliseconds(2), 100);
+
+        for (var i = 0; i < 100; i++)
+        {
+            seriesFeature.AddNewData(i);
+
+            await Task.Delay(1);
+        }
+
+        seriesFeature.Resample(TimeSpan.FromMilliseconds(4), 100);
+        var sad = seriesFeature;
+    }
+
+    [Fact]
+    public async Task ResampleSummer()
+    {
+        var seriesFeature = new IntTimeSeriesSummer(TimeSpan.FromMilliseconds(2), 100);
+
+        for (var i = 0; i < 100; i++)
+        {
+            seriesFeature.AddNewData(i);
+
+            await Task.Delay(1);
+        }
+
+        seriesFeature.Resample(TimeSpan.FromMilliseconds(4), 100);
+    }
+
+
     [Fact]
     public void MarkupAllSamples()
     {

ManagedCode.TimeSeries/Abstractions/BaseTimeSeries.cs

@@ -6,39 +6,39 @@ namespace ManagedCode.TimeSeries.Abstractions;
 public abstract class BaseTimeSeries<T, TSample, TSelf> : ITimeSeries<T, TSample, TSelf> where TSelf : ITimeSeries<T, TSample, TSelf>
 {
     private const int DefaultSampleCount = 100;
-    private readonly int _samplesCount;
     protected object _sync = new();
 
-    protected BaseTimeSeries(TimeSpan sampleInterval, int samplesCount)
+    protected BaseTimeSeries(TimeSpan sampleInterval, int maxSamplesCount)
     {
-        _samplesCount = samplesCount;
+        MaxSamplesCount = maxSamplesCount;
         SampleInterval = sampleInterval;
         Start = DateTimeOffset.UtcNow.Round(SampleInterval);
         End = Start;
     }
 
-    protected BaseTimeSeries(TimeSpan sampleInterval, int samplesCount, DateTimeOffset start, DateTimeOffset end, DateTimeOffset lastDate)
+    protected BaseTimeSeries(TimeSpan sampleInterval, int maxSamplesCount, DateTimeOffset start, DateTimeOffset end, DateTimeOffset lastDate)
     {
-        _samplesCount = samplesCount;
+        MaxSamplesCount = maxSamplesCount;
         SampleInterval = sampleInterval;
         Start = start.Round(SampleInterval);
         End = end.Round(SampleInterval);
         LastDate = lastDate;
     }
 
-    public Dictionary<DateTimeOffset, TSample> Samples { get; } = new();
+    public Dictionary<DateTimeOffset, TSample> Samples { get; protected set; } = new();
     public DateTimeOffset Start { get; }
     public DateTimeOffset End { get; protected set; }
-    public TimeSpan SampleInterval { get; }
+
+    public TimeSpan SampleInterval { get; protected set; }
+    public int MaxSamplesCount { get; protected set; }
 
     public DateTimeOffset LastDate { get; protected set; }
 
-    public int SamplesCount => Samples.Count;
     public ulong DataCount { get; protected set; }
 
-    public bool IsFull => Samples.Count >= _samplesCount;
+    public bool IsFull => Samples.Count >= MaxSamplesCount;
     public bool IsEmpty => Samples.Count == 0;
-    public bool IsOverflow => Samples.Count > _samplesCount;
+    public bool IsOverflow => Samples.Count > MaxSamplesCount;
 
     public void AddNewData(T data)
     {
@@ -67,7 +67,7 @@ protected void CheckSamplesSize()
     {
         lock (_sync)
         {
-            if (_samplesCount <= 0)
+            if (MaxSamplesCount <= 0)
             {
                 return;
             }
@@ -81,7 +81,7 @@ protected void CheckSamplesSize()
 
     public void MarkupAllSamples(MarkupDirection direction = MarkupDirection.Past)
     {
-        var samples = _samplesCount > 0 ? _samplesCount : DefaultSampleCount;
+        var samples = MaxSamplesCount > 0 ? MaxSamplesCount : DefaultSampleCount;
 
         if (direction is MarkupDirection.Past or MarkupDirection.Feature)
         {
@@ -126,7 +126,7 @@ public void MarkupAllSamples(MarkupDirection direction = MarkupDirection.Past)
     public void DeleteOverdueSamples()
     {
         var dateTime = DateTimeOffset.UtcNow.Round(SampleInterval);
-        for (int i = 0; i < _samplesCount; i++)
+        for (int i = 0; i < MaxSamplesCount; i++)
         {
             dateTime = dateTime.Subtract(SampleInterval);
         }
@@ -145,8 +145,7 @@ public void DeleteOverdueSamples()
 
     public TSelf PureMerge(IEnumerable<TSelf> accumulators)
     {
-        var empty = Activator.CreateInstance<TSelf>();
-        empty.Resample(SampleInterval, SamplesCount);
+        var empty = (TSelf) Activator.CreateInstance(typeof(TSelf), SampleInterval, MaxSamplesCount)!;
 
         foreach (var accumulator in accumulators)
         {
@@ -166,8 +165,7 @@ public void Merge(IEnumerable<TSelf> accumulators)
 
     public TSelf PureMerge(TSelf accumulator)
     {
-        var empty = Activator.CreateInstance<TSelf>();
-        empty.Resample(SampleInterval, SamplesCount);
+        var empty = (TSelf) Activator.CreateInstance(typeof(TSelf), SampleInterval, MaxSamplesCount)!;
         empty.Merge(accumulator);
 
         return empty;
@@ -180,10 +178,4 @@ public TSelf PureMerge(TSelf accumulator)
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public abstract void Merge(TSelf accumulator);
-
-
-    public virtual void Dispose()
-    {
-        //skip
-    }
 }

ManagedCode.TimeSeries/Abstractions/BaseTimeSeriesAccumulator.cs

@@ -1,13 +1,16 @@
+using ManagedCode.TimeSeries.Extensions;
+
 namespace ManagedCode.TimeSeries.Abstractions;
 
 public abstract class BaseTimeSeriesAccumulator<T, TSelf> : BaseTimeSeries<T, Queue<T>, TSelf> where TSelf : ITimeSeries<T, Queue<T>, TSelf>
 {
-    protected BaseTimeSeriesAccumulator(TimeSpan sampleInterval, int samplesCount) : base(sampleInterval, samplesCount)
+    protected BaseTimeSeriesAccumulator(TimeSpan sampleInterval, int maxSamplesCount) : base(sampleInterval, maxSamplesCount)
     {
     }
 
-    protected BaseTimeSeriesAccumulator(TimeSpan sampleInterval, int samplesCount, DateTimeOffset start, DateTimeOffset end, DateTimeOffset lastDate)
-        : base(sampleInterval, samplesCount, start, end, lastDate)
+    protected BaseTimeSeriesAccumulator(TimeSpan sampleInterval, int maxSamplesCount, DateTimeOffset start, DateTimeOffset end,
+        DateTimeOffset lastDate)
+        : base(sampleInterval, maxSamplesCount, start, end, lastDate)
     {
     }
 
@@ -77,6 +80,24 @@ public override void Merge(TSelf accumulator)
 
     public override void Resample(TimeSpan sampleInterval, int samplesCount)
     {
-        // throw new NotImplementedException();
+        if (sampleInterval <= SampleInterval)
+        {
+            throw new InvalidOperationException();
+        }
+
+        SampleInterval = sampleInterval;
+        MaxSamplesCount = samplesCount;
+
+        var samples = Samples;
+
+        Samples = new Dictionary<DateTimeOffset, Queue<T>>();
+
+        foreach (var (key, value) in samples)
+        {
+            foreach (var v in value)
+            {
+                AddNewData(key, v);
+            }
+        }
     }
 }

ManagedCode.TimeSeries/Abstractions/BaseTimeSeriesSummer.cs

@@ -16,7 +16,7 @@ public abstract class BaseTimeSeriesSummer<TNumber, TSelf> : BaseTimeSeries<TNum
 {
     private readonly Strategy _strategy;
 
-    protected BaseTimeSeriesSummer(TimeSpan sampleInterval, int samplesCount, Strategy strategy) : base(sampleInterval, samplesCount)
+    protected BaseTimeSeriesSummer(TimeSpan sampleInterval, int maxSamplesCount, Strategy strategy) : base(sampleInterval, maxSamplesCount)
     {
         _strategy = strategy;
     }
@@ -51,7 +51,22 @@ public override void Merge(TSelf accumulator)
 
     public override void Resample(TimeSpan sampleInterval, int samplesCount)
     {
-        // throw new NotImplementedException();
+        if (sampleInterval <= SampleInterval)
+        {
+            throw new InvalidOperationException();
+        }
+
+        SampleInterval = sampleInterval;
+        MaxSamplesCount = samplesCount;
+
+        var samples = Samples;
+
+        Samples = new Dictionary<DateTimeOffset, TNumber>();
+
+        foreach (var (key, value) in samples)
+        {
+            AddNewData(key, value);
+        }
     }
 
     private TNumber Update(TNumber left, TNumber right)

ManagedCode.TimeSeries/Abstractions/ITimeSeries.cs

@@ -6,7 +6,7 @@ public interface ITimeSeries<in T, TSample, TSelf> : ITimeSeries<TSample>
     where TSelf : ITimeSeries<T, TSample, TSelf>
 {
     void Resample(TimeSpan sampleInterval, int samplesCount);
-    
+
     void AddNewData(T data);
 
     void Merge(TSelf accumulator);
@@ -18,40 +18,16 @@ public interface ITimeSeries<in T, TSample, TSelf> : ITimeSeries<TSample>
 
     [Pure]
     TSelf PureMerge(TSelf accumulator);
-
-
-    [Pure]
-    static virtual TSelf operator +(TSelf series, TSelf right)
-    {
-        return series.PureMerge(right);
-    }
-
-    static virtual TSelf operator checked +(TSelf series, TSelf right)
-    {
-        return series + right;
-    }
-
-    // static virtual ITimeSeries<T, TSample> operator +(ITimeSeries<T, TSample> series, T value)
-    // {
-    //     series.AddNewData(value);
-    //
-    //     return series;
-    // }
-
-    // static virtual ITimeSeries<T, TSample> operator checked +(ITimeSeries<T, TSample> series, T value)
-    // {
-    //     return series + value;
-    // }
 }
 
-public interface ITimeSeries<TSample> : IDisposable
+public interface ITimeSeries<TSample>
 {
     public Dictionary<DateTimeOffset, TSample> Samples { get; }
     public DateTimeOffset Start { get; }
     public DateTimeOffset End { get; }
     public DateTimeOffset LastDate { get; }
     public TimeSpan SampleInterval { get; }
-    public int SamplesCount { get; }
+    public int MaxSamplesCount { get; }
     public ulong DataCount { get; }
     public bool IsFull { get; }
     public bool IsEmpty { get; }

ManagedCode.TimeSeries/Accumulators/DoubleTimeSeriesAccumulator.cs

@@ -4,7 +4,7 @@ namespace ManagedCode.TimeSeries.Accumulators;
 
 public class DoubleTimeSeriesAccumulator : BaseTimeSeriesAccumulator<double, DoubleTimeSeriesAccumulator>
 {
-    public DoubleTimeSeriesAccumulator(TimeSpan sampleInterval, int samplesCount = 0) : base(sampleInterval, samplesCount)
+    public DoubleTimeSeriesAccumulator(TimeSpan sampleInterval, int maxSamplesCount = 0) : base(sampleInterval, maxSamplesCount)
     {
     }
 }

ManagedCode.TimeSeries/Accumulators/FloatTimeSeriesAccumulator.cs

@@ -4,7 +4,7 @@ namespace ManagedCode.TimeSeries.Accumulators;
 
 public class FloatTimeSeriesAccumulator : BaseTimeSeriesAccumulator<float, FloatTimeSeriesAccumulator>
 {
-    public FloatTimeSeriesAccumulator(TimeSpan sampleInterval, int samplesCount = 0) : base(sampleInterval, samplesCount)
+    public FloatTimeSeriesAccumulator(TimeSpan sampleInterval, int maxSamplesCount = 0) : base(sampleInterval, maxSamplesCount)
     {
     }
 }

ManagedCode.TimeSeries/Accumulators/IntTimeSeriesAccumulator.cs

@@ -4,7 +4,7 @@ namespace ManagedCode.TimeSeries.Accumulators;
 
 public class IntTimeSeriesAccumulator : BaseTimeSeriesAccumulator<int, IntTimeSeriesAccumulator>
 {
-    public IntTimeSeriesAccumulator(TimeSpan sampleInterval, int samplesCount = 0) : base(sampleInterval, samplesCount)
+    public IntTimeSeriesAccumulator(TimeSpan sampleInterval, int maxSamplesCount = 0) : base(sampleInterval, maxSamplesCount)
     {
     }
 }

ManagedCode.TimeSeries/Summers/DoubleTimeSeriesSummer.cs

@@ -4,11 +4,11 @@ namespace ManagedCode.TimeSeries.Summers;
 
 public class DoubleTimeSeriesSummer : BaseTimeSeriesSummer<double, DoubleTimeSeriesSummer>
 {
-    public DoubleTimeSeriesSummer(TimeSpan sampleInterval, int samplesCount, Strategy strategy) : base(sampleInterval, samplesCount, strategy)
+    public DoubleTimeSeriesSummer(TimeSpan sampleInterval, int maxSamplesCount, Strategy strategy) : base(sampleInterval, maxSamplesCount, strategy)
     {
     }
 
-    public DoubleTimeSeriesSummer(TimeSpan sampleInterval, int samplesCount) : base(sampleInterval, samplesCount, Strategy.Sum)
+    public DoubleTimeSeriesSummer(TimeSpan sampleInterval, int maxSamplesCount) : base(sampleInterval, maxSamplesCount, Strategy.Sum)
     {
     }
 

ManagedCode.TimeSeries/Summers/FloatTimeSeriesSummer.cs

@@ -4,11 +4,11 @@ namespace ManagedCode.TimeSeries.Summers;
 
 public class FloatTimeSeriesSummer : BaseTimeSeriesSummer<float, FloatTimeSeriesSummer>
 {
-    public FloatTimeSeriesSummer(TimeSpan sampleInterval, int samplesCount, Strategy strategy) : base(sampleInterval, samplesCount, strategy)
+    public FloatTimeSeriesSummer(TimeSpan sampleInterval, int maxSamplesCount, Strategy strategy) : base(sampleInterval, maxSamplesCount, strategy)
     {
     }
 
-    public FloatTimeSeriesSummer(TimeSpan sampleInterval, int samplesCount) : base(sampleInterval, samplesCount, Strategy.Sum)
+    public FloatTimeSeriesSummer(TimeSpan sampleInterval, int maxSamplesCount) : base(sampleInterval, maxSamplesCount, Strategy.Sum)
     {
     }