public double Enumerate()
{
IEnumerable <DataPoint> source = this.Source();
using DataPointIterator filtered = source.SwingingDoorCompression(0.1);
return(Consume(filtered));
}
public List <DataPoint> ToList()
{
IEnumerable <DataPoint> source = this.Source();
using DataPointIterator filtered = source.SwingingDoorCompression(0.1);
return(filtered.ToList());
}
public DataPoint[] ToArray()
{
IEnumerable <DataPoint> source = this.Source();
using DataPointIterator filtered = source.DeadBandCompression(0.1);
return(filtered.ToArray());
}
public async ValueTask <double> Enumerate()
{
IAsyncEnumerable <DataPoint> source = this.SourceAsync();
DataPointIterator filtered = source.DeadBandCompressionAsync(0.1);
return(await this.ConsumeAsync(filtered));
}
public async ValueTask <double> Enumerate()
{
IAsyncEnumerable <DataPoint> source = this.SourceAsync();
using DataPointIterator filtered = source.SwingingDoorCompressionAsync(0.1);
return(await ConsumeAsync(filtered));
}
public async ValueTask <DataPoint[]> ToArray()
{
IAsyncEnumerable <DataPoint> source = this.SourceAsync();
DataPointIterator filtered = source.SwingingDoorCompressionAsync(0.1);
return(await filtered.ToArrayAsync());
}
public double Enumerate()
{
IEnumerable <DataPoint> source = this.Source();
DataPointIterator filtered = source.DeadBandCompression(0.1);
return(this.Consume(filtered));
}
public List <DataPoint> ToList()
{
IEnumerable <DataPoint> source = this.Source();
DataPointIterator filtered = source.DeadBandCompression(0.1);
return(filtered.ToList());
}
public async Task MoveNextAsync___false()
{
DataPointIterator sut = DataPointIterator.Empty;
Assert.AreSame(Array.Empty <DataPoint>(), await sut.ToArrayAsync());
Assert.AreEqual(0, (await sut.ToListAsync()).Count);
}
public async Task Cancellation___OK()
{
var sut = new SwingingDoorCompression(1d);
var data = RawDataAsync(RawDataForTrend());
var expected = ExpectedForTrend().Take(2).ToList();
DataPointIterator dataPointIterator = sut.ProcessAsync(data);
var cts = new CancellationTokenSource();
var enumerator = dataPointIterator.GetAsyncEnumerator(cts.Token);
var actual = new List <DataPoint>();
await enumerator.MoveNextAsync();
actual.Add(enumerator.Current);
await enumerator.MoveNextAsync();
actual.Add(enumerator.Current);
cts.Cancel();
List <DataPoint> res = null;
Assert.ThrowsAsync <OperationCanceledException>(async() => res = await dataPointIterator.ToListAsync(cts.Token));
CollectionAssert.AreEqual(expected, actual);
Assert.IsNull(res);
}
public DataPoint[] ToArray()
{
IEnumerable <DataPoint> source = this.Source();
DataPointIterator filtered = source.SwingingDoorCompression(0.1);
return(filtered.ToArray());
}
public async ValueTask <List <DataPoint> > ToList()
{
IAsyncEnumerable <DataPoint> source = this.SourceAsync();
DataPointIterator filtered = source.DeadBandCompressionAsync(0.1);
return(await filtered.ToListAsync());
}
static async Task Main(string[] args)
{
#if CI_BUILD
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(1));
#else
var cts = new CancellationTokenSource();
#endif
IAsyncEnumerable <DataPoint> source = Source(cts.Token);
//DataPointIterator filtered = source.DeadBandCompressionAsync(0.01);
DataPointIterator filtered = source.SwingingDoorCompressionAsync(0.01);
ValueTask <double> sinkTask = Sink(filtered, cts.Token);
#if !CI_BUILD
Console.WriteLine("any key to stop...");
Console.ReadKey();
cts.Cancel();
#endif
double sum = default;
try
{
sum = await sinkTask;
}
catch (OperationCanceledException) { }
Console.WriteLine($"sum: {sum}");
}
public void DataPoints_given___OK()
{
IEnumerable <DataPoint> dataPoints = GetDataPoints();
DataPointIterator actual = dataPoints.DeadBandCompression(0.1);
Assert.IsNotNull(actual);
}
public void DataPoints_given_with_TimeSpan___OK()
{
IEnumerable <DataPoint> dataPoints = GetDataPoints();
DataPointIterator actual = dataPoints.SwingingDoorCompression(0.1, TimeSpan.FromSeconds(1), minTime: null);
Assert.IsNotNull(actual);
}
public void DataPoints_given_with_TimeSpan_async___OK()
{
IAsyncEnumerable <DataPoint> dataPoints = GetDataPointsAsync();
DataPointIterator actual = dataPoints.DeadBandCompressionAsync(0.1, TimeSpan.FromSeconds(1));
Assert.IsNotNull(actual);
}
public void DataPoints_given_async___OK()
{
IAsyncEnumerable <DataPoint> dataPoints = GetDataPointsAsync();
DataPointIterator actual = dataPoints.NoCompressionAsync();
Assert.IsNotNull(actual);
}
public void MoveNext___false()
{
DataPointIterator sut = DataPointIterator.Empty;
Assert.IsFalse(sut.MoveNext());
Assert.AreSame(sut, sut.Clone());
Assert.AreSame(Array.Empty <DataPoint>(), sut.ToArray());
Assert.AreEqual(0, sut.ToList().Count);
}
//---------------------------------------------------------------------
protected async ValueTask <double> ConsumeAsync(DataPointIterator iterator)
{
double sum = 0;
await foreach (DataPoint dataPoint in iterator)
{
sum += dataPoint.Y;
}
return(sum);
}
//---------------------------------------------------------------------
protected double Consume(DataPointIterator iterator)
{
double sum = 0;
foreach (DataPoint dataPoint in iterator)
{
sum += dataPoint.Y;
}
return(sum);
}
//-------------------------------------------------------------------------
private static double Consume(DataPointIterator dataPointIterator)
{
double sum = 0;
foreach (DataPoint dataPoint in dataPointIterator)
{
sum += dataPoint.Y;
}
return(sum);
}
//-------------------------------------------------------------------------
private static async ValueTask <double> ConsumeAsync(DataPointIterator dataPointIterator)
{
double sum = 0;
await foreach (DataPoint dataPoint in dataPointIterator)
{
sum += dataPoint.Y;
}
return(sum);
}
//---------------------------------------------------------------------
static async Task Main()
{
using CancellationTokenSource cts = new CancellationTokenSource();
int counter = 0;
Task t = Task.Run(() =>
{
// A single instance can be re-used over and over again
DeadBandCompression deadBand = new DeadBandCompression(0.1);
SwingingDoorCompression swingingDoor = new SwingingDoorCompression(0.1);
while (!cts.IsCancellationRequested)
{
s_compressed.Clear();
counter++;
// Allocates a new instance of compression each iteration
//DataPointIterator compressed = s_dataPoints//.Select(d => d)
// //.DeadBandCompression(0.05)
// .SwingingDoorCompression(0.1);
//DataPointIterator compressed = compression.Process(s_dataPoints.Select(d => d));
DataPointIterator deadBandCompressed = deadBand.Process(s_dataPoints);
DataPointIterator swingingDoorCompressed = swingingDoor.Process(deadBandCompressed);
foreach (DataPoint item in swingingDoorCompressed)
{
s_compressed.Add(item);
}
Console.Write(".");
}
}, cts.Token);
Console.WriteLine("any key to stop...");
Console.ReadKey();
cts.Cancel();
try
{
await t;
}
catch (OperationCanceledException)
{ }
Console.WriteLine($"\n\nend -- counter: {counter}");
}
public void List_iterated_and_ToArray___OK()
{
var sut = new DeadBandCompression(0.1);
var data = RawDataForTrend().ToList();
var expected = ExpectedForTrend().ToList();
DataPointIterator dataPointIterator = sut.Process(data);
DataPointIterator enumerator = dataPointIterator.GetEnumerator();
enumerator.MoveNext();
enumerator.MoveNext();
var actual = dataPointIterator.ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public async Task IEnumerable_iterated_and_ToList___OK(double compressionDeviation, IAsyncEnumerable <DataPoint> rawData, IEnumerable <DataPoint> expectedData)
{
var sut = new SwingingDoorCompression(compressionDeviation);
var data = rawData;
var expected = expectedData.ToList();
DataPointIterator dataPointIterator = sut.ProcessAsync(data);
var enumerator = dataPointIterator.GetAsyncEnumerator();
await enumerator.MoveNextAsync();
await enumerator.MoveNextAsync();
var actual = await dataPointIterator.ToListAsync();
CollectionAssert.AreEqual(expected, actual);
}
public async Task IEnumerable_iterated_and_ToList___OK()
{
var sut = new DeadBandCompression(0.1);
var data = RawDataForTrendAsync();
var expected = ExpectedForTrend().ToList();
DataPointIterator dataPointIterator = sut.ProcessAsync(data);
var enumerator = dataPointIterator.GetAsyncEnumerator();
await enumerator.MoveNextAsync();
await enumerator.MoveNextAsync();
var actual = await dataPointIterator.ToListAsync();
CollectionAssert.AreEqual(expected, actual);
}
public void List_iterated_and_ToArray___OK(double compressionDeviation, IEnumerable <DataPoint> rawData, IEnumerable <DataPoint> expectedData)
{
var sut = new SwingingDoorCompression(compressionDeviation);
var data = rawData.ToList();
var expected = expectedData.ToList();
DataPointIterator dataPointIterator = sut.Process(data);
DataPointIterator enumerator = dataPointIterator.GetEnumerator();
enumerator.MoveNext();
enumerator.MoveNext();
var actual = dataPointIterator.ToArray();
Print(expected, "expected");
Print(actual, "actual");
CollectionAssert.AreEqual(expected, actual);
}
//---------------------------------------------------------------------
private static async ValueTask <double> Sink(DataPointIterator data, CancellationToken ct = default)
{
double sum = 0;
uint count = 0;
await foreach (DataPoint dp in data.WithCancellation(ct))
{
sum += dp.Y;
if (count % (1 << 15) == 0)
{
Console.WriteLine($"count: {count}, sum: {sum}");
}
count++;
}
return(sum);
}
public async Task IAsyncEnumerable_iterated_and_ToArray___OK()
{
var sut = new NoCompression();
var data = RawDataForTrendAsync();
var expected = RawDataForTrend().ToList();
DataPointIterator dataPointIterator = sut.ProcessAsync(data);
var enumerator = dataPointIterator.GetAsyncEnumerator();
await enumerator.MoveNextAsync();
await enumerator.MoveNextAsync();
var actual = await dataPointIterator.ToArrayAsync();
Print(expected, "expected");
Print(actual, "actual");
CollectionAssert.AreEqual(expected, actual);
}
public void Tow_Iterators_IEnumerable___different_Instances()
{
var sut = new DeadBandCompression(0.1);
var data = RawDataForTrend();
var dummy = new List <DataPoint>();
DataPointIterator actual0 = sut.Process(data.Skip(1));
DataPointIterator actual1 = sut.Process(data.Take(1));
foreach (DataPoint dp in actual0)
{
dummy.Add(dp);
}
foreach (DataPoint dp in actual1)
{
dummy.Add(dp);
}
Assert.AreNotSame(actual0, actual1);
}
