public void Apply_When11thIs110And21thIs120_MonthAverageIs115()
{
// Arrange
var ts = new Timeseries
{
new Tvq(
new DateTime(2015, 03, 11, 0, 0, 0, 0),
110,
Quality.Ok),
new Tvq(
new DateTime(2015, 03, 21, 0, 0, 0, 0),
120,
Quality.Ok)
};
// Act
var t0 = new DateTime(2015, 03, 01, 0, 0, 0, 0);
var t1 = new DateTime(2015, 03, 30, 23, 59, 59, 999);
var result = new Average().Apply(t0, t1, ts);
// Assert
var area1 = 110 * (ts[0].Time - t0).TotalSeconds;
var area2 = 115 * (ts[1].Time - ts[0].Time).TotalSeconds;
var area3 = 120 * (t1 - ts[1].Time).TotalSeconds;
var expected = (area1 + area2 + area3) / (t1 - t0).TotalSeconds;
Assert.Equal(expected, result.V, 4);
}
public void Apply_WhenFirstValueIsInsidePeriod_AssumesStepwise()
{
// Arrange
var tvq1 = new Tvq(
new DateTime(2015, 01, 10, 0, 0, 0, 0),
110,
Quality.Ok);
var tvq2 = new Tvq(
new DateTime(2015, 01, 20, 0, 0, 0, 0),
120,
Quality.Ok);
var ts = new Timeseries {
tvq1, tvq2
};
// Act
var t0 = new DateTime(2015, 01, 01, 0, 0, 0, 0);
var t1 = new DateTime(2015, 01, 31, 23, 59, 59, 999);
var result = new Average().Apply(t0, t1, ts);
// Assert
var area1 = tvq1.V * (tvq1.Time - t0).TotalSeconds;
var area2 = (tvq2.Time - tvq1.Time).TotalSeconds * (tvq1.V + tvq2.V) / 2;
var area3 = (t1 - tvq2.Time).TotalSeconds * tvq2.V;
var expected = (area1 + area2 + area3) / (t1 - t0).TotalSeconds;
Assert.Equal(expected, result.V);
}
public void MonthlyAverage_WhenWholeMonthDiminishingConsumption_ConsumptionIsCorrect()
{
// Arrange
const double v0 = 0;
var t0 = new DateTime(2015, 09, 01, 0, 0, 0);
var t1 = new DateTime(2015, 09, 16, 0, 0, 0);
var t2 = new DateTime(2015, 10, 01, 0, 0, 0);
double[] consumptionPerDay = { 2d, 1d };
var v1 = v0 + consumptionPerDay[0] * (t1 - t0).TotalDays;
var v2 = v1 + consumptionPerDay[1] * (t2 - t1).TotalDays;
var ts = new Timeseries
{
new Tvq(t0, v0, Quality.Ok),
new Tvq(t1, v1, Quality.Ok),
new Tvq(t2, v2, Quality.Ok)
};
// Act
var averages = m_Periodizer.MonthlyAverage(ts);
//Assert
var x = averages[0];
var expectedValue =
(t1 - t0).TotalDays * consumptionPerDay[0]
+ (t2 - t1).TotalDays * consumptionPerDay[1];
Assert.Equal(expectedValue, x.V, 7);
}
public static Timeseries GetMonthlyAverages(string identityName)
{
var repo = new RegistryEntryRepoFactory().GetRegistryEntryRepo(identityName);
var sortedTvqs = repo.GetRegistryEntries().OrderBy(x => x.Time);
var tsWithRegisterEntries = new Timeseries();
tsWithRegisterEntries.AddRange(sortedTvqs.ToList());
var periodizer = new Periodizer();
var monthlyAverages = periodizer.MonthlyAverage(tsWithRegisterEntries);
//const int minMonths = 2;
//var tooFewEntries = monthlyRegisterEntries.Count < minMonths;
//var areTooFewEntries = tooFewEntries;
//if (areTooFewEntries)
//{
// throw new TooFewEntriesException(minMonths);
//}
//var deltaOperator = new DeltaTsOperator();
//var monthlyAverages = deltaOperator.Apply(monthlyRegisterEntries);
return(monthlyAverages);
}
/// <summary>
/// Splits a timeseries into possibly several with one timeseries per year.
/// </summary>
/// <param name="timeseries"></param>
/// <returns></returns>
public IList<Timeseries> SplitPerYear(Timeseries timeseries)
{
if (! timeseries.Any())
{
return new List<Timeseries>();
}
var result = new List<Timeseries>();
Tvq previous = null;
Timeseries currentTs = null;
foreach (var tvq in timeseries)
{
if (previous == null)
{
currentTs = new Timeseries {tvq};
result.Add(currentTs);
}
else
{
if (previous.Time.Year != tvq.Time.Year)
{
currentTs = new Timeseries();
result.Add(currentTs);
}
currentTs.Add(tvq);
}
previous = tvq;
}
return result;
}
/// <summary>
/// Simple Moving average
/// </summary>
/// <param name="period"></param>
/// <returns>This variable after transformation.</returns>
public Variable Sma(int period)
{
// TODO Direct buffer speed optimization (in-place change).
Timeseries ts = mVarParent.Sma(period);
return(mVarParent.mParent[mVarParent.Name] = ts.Default);
}
public void Apply_WhenFirstValueIsInsidePeriod_AssumesStepwise()
{
// Arrange
var tvq1 = new Tvq(
new DateTime(2015, 01, 10, 0, 0, 0, 0),
110,
Quality.Ok);
var tvq2 = new Tvq(
new DateTime(2015, 01, 20, 0, 0, 0, 0),
120,
Quality.Ok);
var ts = new Timeseries { tvq1, tvq2 };
// Act
var t0 = new DateTime(2015, 01, 01, 0, 0, 0, 0);
var t1 = new DateTime(2015, 01, 31, 23, 59, 59, 999);
var result = new Average().Apply(t0, t1, ts);
// Assert
var area1 = tvq1.V*(tvq1.Time - t0).TotalSeconds;
var area2 = (tvq2.Time - tvq1.Time).TotalSeconds*(tvq1.V + tvq2.V)/2;
var area3 = (t1 - tvq2.Time).TotalSeconds*tvq2.V;
var expected = (area1 + area2 + area3) / (t1 - t0).TotalSeconds;
Assert.Equal(expected, result.V);
}
/// <summary>
/// Applies the delta function to each pair of consecutive values.
/// </summary>
/// <param name="ts">A time series</param>
/// <returns></returns>
public Timeseries Apply(Timeseries ts)
{
const string paramNameTs = "ts";
if (ts == null)
{
throw new ArgumentException("Must be non-null", paramNameTs);
}
//if (ts.Count < 2) throw new ArgumentException("ts must contain at least two elements", paramNameTs);
var result = new Timeseries();
using (var enumerator = ts.GetEnumerator())
{
if (!enumerator.MoveNext())
{
throw new ArgumentException("ts must contain at least two elements", paramNameTs);
}
var previous = enumerator.Current;
result.Add(new Tvq(previous.Time, 0, Quality.Ok)); // trying to indicate that the consumption starts at 0, but that may not work well if algorithms extrapolate backwards
while (enumerator.MoveNext())
{
var current = enumerator.Current;
var delta = CalculateDelta(current, previous);
result.Add(delta);
previous = current;
}
}
return(result);
}
public void InsertPoints_WhenFrom2015To2016_TimesAreCorrect()
{
// Arrange
// Act
var ts = new Timeseries
{
new Tvq(m_Tvqs.Tvq20150601.Time, 4, Quality.Ok),
new Tvq(m_Tvqs.Tvq20160601.Time, 4, Quality.Ok)
};
var averages = m_Periodizer.InsertPoints(ts, Interval.Month);
//Assert
var i = 0;
Assert.Equal(new DateTime(2015, 06, 01, 0, 0, 0), averages[i++].Time);
Assert.Equal(new DateTime(2015, 06, 30, 23, 59, 59), averages[i++].Time);
Assert.Equal(new DateTime(2015, 07, 01, 0, 0, 0), averages[i++].Time);
Assert.Equal(new DateTime(2015, 07, 31, 23, 59, 59), averages[i++].Time);
Assert.Equal(new DateTime(2015, 08, 01, 0, 0, 0), averages[i++].Time);
Assert.Equal(new DateTime(2015, 08, 31, 23, 59, 59), averages[i++].Time);
Assert.Equal(new DateTime(2015, 09, 01, 0, 0, 0), averages[i++].Time);
Assert.Equal(new DateTime(2015, 09, 30, 23, 59, 59), averages[i++].Time);
Assert.Equal(new DateTime(2015, 10, 01, 0, 0, 0), averages[i++].Time);
Assert.Equal(new DateTime(2015, 10, 31, 23, 59, 59), averages[i++].Time);
Assert.Equal(new DateTime(2015, 11, 01, 0, 0, 0), averages[i++].Time);
Assert.Equal(new DateTime(2015, 11, 30, 23, 59, 59), averages[i++].Time);
Assert.Equal(new DateTime(2015, 12, 01, 0, 0, 0), averages[i++].Time);
Assert.Equal(new DateTime(2015, 12, 31, 23, 59, 59), averages[i++].Time);
Assert.Equal(new DateTime(2016, 01, 01, 0, 0, 0), averages[i++].Time);
Assert.Equal(new DateTime(2016, 06, 30, 23, 59, 59), averages.Last().Time);
}
public void InsertPoints_WhenTwoPointsSameMonth_InsertsExtrapolatedEndValue()
{
// Arrange
var tvq1 = m_Tvqs.Tvq20150601;
var tvq2 = m_Tvqs.Tvq20150622;
var ts = new Timeseries {
tvq1, tvq2
};
// Act
var result = m_Periodizer.InsertPoints(ts, Interval.Month);
// Assert
Assert.Equal(3, result.Count);
var dt = result[1].Time - result[0].Time;
// y = k*x + m
var k = (tvq2.V - tvq1.V) / dt.TotalSeconds;
var t1 = m_Tvqs.Tvq20150630.Time;
var x = (t1 - tvq1.Time).TotalSeconds;
var y = k * x + tvq1.V;
var tvq = result.Last();
Assert.Equal(t1, tvq.Time);
Assert.Equal(y, tvq.V);
Assert.Equal(Quality.Interpolated, tvq.Q);
}
public void MonthlyAverage_When2ValuesInMiddleOfJan_ReturnsAsAverageAtFirstSecond()
{
// Arrange
const double v0 = 0;
const double v1 = 500;
var ts = new Timeseries
{
new Tvq(m_Tvqs.Tvq20150105.Time, v0, Quality.Ok),
new Tvq(m_Tvqs.Tvq20150110.Time, v1, Quality.Ok)
};
// Act
var averages = m_Periodizer.MonthlyAverage(ts);
//Assert
var x = averages[0];
Assert.Equal(m_Tvqs.Tvq20150101.Time, x.Time);
var totalDays = (ts[1].Time - ts[0].Time).Days;
var consumptionPerDay = (v1 - v0) / totalDays;
var nDaysExtrapolated = 1 + 31 - ts[1].Time.Day;
var extrapolatedConsumption = consumptionPerDay * nDaysExtrapolated;
var valueAtEnd = v1 + extrapolatedConsumption;
var expectedValue = valueAtEnd - v0;
Assert.Equal(expectedValue, x.V, 4);
}
public void MonthlyAverage_When1ValueAtStartOfJanAnd1InFeb_InterpolatesMonthEndValue()
{
// Arrange
const double v0 = 0;
const int nDaysJan = 31;
var t1 = new DateTime(2015, 2, 23, 0, 0, 0);
var totalDays = nDaysJan + t1.Day - 1;
const double consumptionPerDay = 2;
var v1 = v0 + consumptionPerDay * totalDays;
var ts = new Timeseries
{
new Tvq(m_Tvqs.Tvq20150101.Time, v0, Quality.Ok),
new Tvq(t1, v1, Quality.Ok)
};
// Act
var averages = m_Periodizer.MonthlyAverage(ts);
//Assert
var x = averages[0];
Assert.Equal(m_Tvqs.Tvq20150101.Time, x.Time);
const double expectedValue = consumptionPerDay * nDaysJan;
Assert.Equal(expectedValue, x.V, 7);
}
public void MonthlyAverage_When1ValueAtStartOfJanAnd1InFebAndFirstIs1000_InterpolatesJanEndValue()
{
// Arrange
const double v0 = 1000;
const double v1 = v0 + 600d;
var ts = new Timeseries
{
new Tvq(m_Tvqs.Tvq20150101.Time, v0, Quality.Ok),
new Tvq(new DateTime(2015, 2, 23, 0, 0, 0), v1, Quality.Ok)
};
// Act
var averages = m_Periodizer.MonthlyAverage(ts);
//Assert
var x = averages[0];
Assert.Equal(m_Tvqs.Tvq20150101.Time, x.Time);
const int nDaysJan = 31;
const double totalDays = nDaysJan + 22;
const double consumptionPerDay = (v1 - v0) / totalDays;
const double expectedValue = consumptionPerDay * nDaysJan;
Assert.Equal(expectedValue, x.V, 7);
}
public MonthlyValueTextRendererTest()
{
m_Renderer = new MonthlyValueTextRenderer(new CultureInfo("SV"));
m_Writer = new StringWriter();
m_Tvqs = new Tvqs();
m_FebToDec = Create(m_Tvqs.Tvq20160201.Time, 11, 200, 100);
}
public List <AnomalyReport> detect(Timeseries ts)
{
List <AnomalyReport> vector = new List <AnomalyReport>();
int i = 0;
foreach (correlatedFeatures var in cf)
{
for (int j = 0; j < ts.table.First().Value.Count(); ++j)
{ // Loop through the map.
int iter = -1;
// Loop through the cf vector.
iter++;
float floatA = ts.table[var.feature1][j];
float floatB = ts.table[var.feature2][j];
dynamic p = new Point(floatA, floatB); // A point represent the two current features.
//float correlation = dev(*p, i->lin_reg);
// Case the correlation is bigger then the threshold determined by the current correlation deviation.
if (isAnomalous(var, p))
{
string description = var.feature1 + "-" + var.feature2;
long timeStep = j + 1; // For time step to start with 1 instead of 0.
AnomalyReport ar = new AnomalyReport(description, timeStep); // Build a anomaly report with those features.
vector.Add(ar);
}
}
i++;
}
return(vector);
}
/// <summary>
/// Splits a timeseries into possibly several with one timeseries per year.
/// </summary>
/// <param name="timeseries"></param>
/// <returns></returns>
public IList <Timeseries> SplitPerYear(Timeseries timeseries)
{
if (!timeseries.Any())
{
return(new List <Timeseries>());
}
var result = new List <Timeseries>();
Tvq previous = null;
Timeseries currentTs = null;
foreach (var tvq in timeseries)
{
if (previous == null)
{
currentTs = new Timeseries {
tvq
};
result.Add(currentTs);
}
else
{
if (previous.Time.Year != tvq.Time.Year)
{
currentTs = new Timeseries();
result.Add(currentTs);
}
currentTs.Add(tvq);
}
previous = tvq;
}
return(result);
}
public static void GetMatchingDatapoints___Should_return_single_matching_datapoint___When_reportingPeriodComparison_is_set_to_Contains()
{
// Arrange
var datapointReportingPeriods = new[]
{
new ReportingPeriod(new CalendarUnbounded(), new CalendarYear(2018)),
new CalendarYear(2020).ToReportingPeriod(),
new CalendarYear(2021).ToReportingPeriod(),
new CalendarYear(2023).ToReportingPeriod(),
new ReportingPeriod(new CalendarYear(2024), new CalendarUnbounded()),
};
var datapoints = datapointReportingPeriods.Select(_ => new Datapoint <Version>(_, A.Dummy <Version>())).ToList();
var timeseries = new Timeseries <Version>(datapoints);
var reportingPeriods = new[]
{
new ReportingPeriod(new CalendarYear(2016), new CalendarYear(2018)),
new ReportingPeriod(new CalendarYear(2020), new CalendarYear(2020)),
new ReportingPeriod(new CalendarQuarter(2021, QuarterNumber.Q2), new CalendarQuarter(2021, QuarterNumber.Q3)),
new ReportingPeriod(new CalendarQuarter(2023, QuarterNumber.Q1), new CalendarQuarter(2023, QuarterNumber.Q4)),
new ReportingPeriod(new CalendarYear(2025), new CalendarYear(2028)),
};
var mostGranularDatapointReportingPeriods = reportingPeriods.Select(_ => _.ToMostGranular());
// Act
var actual1 = reportingPeriods.Select(_ => timeseries.GetMatchingDatapoints(_.DeepClone(), ReportingPeriodComparison.Contains).Single()).ToList();
var actual2 = mostGranularDatapointReportingPeriods.Select(_ => timeseries.GetMatchingDatapoints(_.DeepClone(), ReportingPeriodComparison.Contains).Single()).ToList();
// Assert
actual1.AsTest().Must().BeEqualTo(datapoints);
actual2.AsTest().Must().BeEqualTo(datapoints);
}
public static void GetMatchingDatapoints___Should_return_empty_collection___When_there_are_no_matching_datapoints_regardless_of_reportingPeriodComparison()
{
// Arrange
var datapointReportingPeriods = new[]
{
new ReportingPeriod(new CalendarUnbounded(), new CalendarYear(2018)),
new CalendarYear(2020).ToReportingPeriod(),
new CalendarYear(2021).ToReportingPeriod(),
new CalendarYear(2023).ToReportingPeriod(),
new ReportingPeriod(new CalendarYear(2024), new CalendarUnbounded()),
};
var datapoints = datapointReportingPeriods.Select(_ => new Datapoint <Version>(_, A.Dummy <Version>())).ToList();
var timeseries = new Timeseries <Version>(datapoints);
var reportingPeriods = new[]
{
new FiscalYear(2020).ToReportingPeriod(),
new CalendarYear(2019).ToReportingPeriod(),
new CalendarYear(2022).ToReportingPeriod(),
};
// Act
var actual1 = reportingPeriods.Select(_ => timeseries.GetMatchingDatapoints(_, ReportingPeriodComparison.Contains));
var actual2 = reportingPeriods.Select(_ => timeseries.GetMatchingDatapoints(_, ReportingPeriodComparison.IsEqualToIgnoringGranularity));
// Assert
actual1.AsTest().Must().Each().BeEmptyEnumerable();
actual2.AsTest().Must().Each().BeEmptyEnumerable();
}
public MonthlyValueTextRendererTest()
{
m_Renderer = new MonthlyValueTextRenderer(new CultureInfo("SV"));
m_Writer = new StringWriter();
m_Tvqs = new Tvqs();
m_FebToDec = Create(m_Tvqs.Tvq20160201.Time, 11, 200, 100);
}
public static void GetMatchingDatapoints___Should_return_empty_collection___When_reportingPeriodComparison_is_set_to_Contains_but_only_contained_or_overlapping_datapoints_exist()
{
// Arrange
var datapointReportingPeriods = new[]
{
new ReportingPeriod(new CalendarUnbounded(), new CalendarYear(2018)),
new CalendarYear(2020).ToReportingPeriod(),
new CalendarYear(2021).ToReportingPeriod(),
new CalendarYear(2023).ToReportingPeriod(),
new ReportingPeriod(new CalendarYear(2024), new CalendarUnbounded()),
};
var datapoints = datapointReportingPeriods.Select(_ => new Datapoint <Version>(_, A.Dummy <Version>())).ToList();
var timeseries = new Timeseries <Version>(datapoints);
var reportingPeriods = new[]
{
new ReportingPeriod(new CalendarYear(2018), new CalendarYear(2019)),
new ReportingPeriod(new CalendarYear(2020), new CalendarYear(2021)),
new ReportingPeriod(new CalendarYear(2021), new CalendarYear(2022)),
new ReportingPeriod(new CalendarYear(2023), new CalendarYear(2025)),
};
// Act
var actual = reportingPeriods.Select(_ => timeseries.GetMatchingDatapoints(_, ReportingPeriodComparison.Contains));
// Assert
actual.AsTest().Must().Each().BeEmptyEnumerable();
}
public static void R25()
{
// Create a timeseries to work with.
Timeseries ts1 = Timeseries.RandomTimeseries(1);
ts1.Rename("Test1");
if (ts1.Length != 1)
{
throw new Exception("Unexpected number of variable.");
}
// The only timeseries should now be named "Test1"
Variable v = ts1["Test1"];
if (ts1["Test1"].Name != "Test1")
{
throw new Exception("Unexpected name.");
}
// Add a new variable. Should not affect the existing variable.
// Verify that indexor still return the right object.
ts1["Test"] = ts1["Test1"].Sma(12);
if (ts1.Length != 2)
{
throw new Exception("Unexpected number of variable.");
}
if (v.Equals(ts1["Test1"]) == false)
{
throw new Exception("Wrong object returned.");
}
}
public void MonthlyAverage_When1ValueInMiddleOfJanAnd1InFeb_ExtrapolatesFebEndValue()
{
// Arrange
const double v0 = 0;
const double v1 = v0 + 700d;
const double v2 = v1 + 200d;
var ts = new Timeseries
{
new Tvq(m_Tvqs.Tvq20150110.Time, v0, Quality.Ok),
new Tvq(new DateTime(2015, 2, 13, 0, 0, 0), v1, Quality.Ok),
new Tvq(new DateTime(2015, 2, 24, 0, 0, 0), v2, Quality.Ok)
};
// Act
var averages = m_Periodizer.MonthlyAverage(ts);
//Assert
var x = averages[0];
var totalDays = (ts[1].Time - ts[0].Time).Days;
var consumptionPerDay = (v1 - v0) / totalDays;
var nDaysConsumptionJan = 1 + 31 - ts[0].Time.Day;
var expectedValue = v0 + nDaysConsumptionJan * consumptionPerDay;
Assert.Equal(expectedValue, x.V, 3);
}
public void InsertPoints_WhenOnePointAtStart_InsertsEndpointAtLastSecond()
{
var ts = new Timeseries {m_Tvqs.Tvq20150101};
var result = m_Periodizer.InsertPoints(ts, Interval.Year);
var tvq = result.Last();
Assert.Equal(new DateTime(2015, 12, 31, 23, 59, 59), tvq.Time);
}
public void InsertPoints_WhenOnePointAtEnd_DoesNotInsertEndpoint()
{
var ts = new Timeseries { m_Tvqs.Tvq20151231 };
var result = m_Periodizer.InsertPoints(ts, Interval.Year);
Assert.Equal(2, result.Count);
var tvq = result.Last();
Assert.Same(m_Tvqs.Tvq20151231, tvq);
}
public void SplitPerYear_WhenOnly20150101_ReturnsOneEnumerableWithTheValue()
{
var ts = new Timeseries();
var source = ts.Add(m_Tvqs.Tvq20150101);
var result = m_Periodizer.SplitPerYear(source).ToList();
Assert.Equal(1, result.Count);
}
public void SplitPerYear_WhenOnly20150101_ReturnsOneEnumerableWithTheValue()
{
var ts = new Timeseries();
var source = ts.Add(m_Tvqs.Tvq20150101);
var result = m_Periodizer.SplitPerYear(source).ToList();
Assert.Single(result);
}
public void Apply_When5And7_DeltaIs2()
{
var ts = new Timeseries {
m_Tvq5, m_Tvq7,
};
var result = m_Delta.Apply(ts);
Assert.Equal(2, result[1].V);
}
public virtual bool isAnomaly(Timeseries ts, correlatedFeatures cf, int timeStep)
{
List <float> Column1 = ts.GetColumn(cf.feature1);
List <float> Column2 = ts.GetColumn(cf.feature2);
Point currPoint = new Point(Column1[timeStep], Column2[timeStep]);
float currDev = Anomaly_Detection_Util.dev(currPoint, cf.lin_reg);
return(currDev > cf.threshold * 1.1);
}
public void Apply_When5And7_FirstValueId0AtFirstTime()
{
var ts = new Timeseries {
m_Tvq5, m_Tvq7,
};
var result = m_Delta.Apply(ts);
Assert.Equal(0d, result[0].V);
Assert.Equal(m_Tvq5.Time, result[0].Time);
}
public void Apply_WhenTsHasOneValue_Returns0()
{
var ts = new Timeseries {
new Tvq(m_t0, 0, Quality.Ok)
};
var result = m_Delta.Apply(ts);
Assert.Equal(0, result[0].V);
Assert.Equal(m_t0, result[0].Time);
}
private Timeseries Create(DateTime tvq20160201, int nValues, int v0, int delta)
{
var ts = new Timeseries();
for (int i = 0; i < nValues; i++)
{
ts.Add(new Tvq(tvq20160201.AddMonths(i), v0 + i * delta, Quality.Ok));
}
return(ts);
}
/// <summary>
/// Execute the function on a timeseries.
/// </summary>
public Timeseries <double> Exec(Timeseries <double> input)
{
Pre();
foreach (Index idx in input)
{
Iter();
}
Post();
return((Timeseries <double>)input.Clone());
}
public void InsertPoints_WhenMonthOnePoint_InsertsStartpointAtFirstSecond()
{
var ts = new Timeseries {
m_Tvqs.Tvq20150622
};
var result = m_Periodizer.InsertPoints(ts, Interval.Month);
var tvq = result.First();
Assert.Equal(new DateTime(2015, 06, 01, 0, 0, 0), tvq.Time);
}
public void InsertPoints_WhenMonthOnePointAtStart_InsertsEndpointAtLastSecond()
{
var ts = new Timeseries {
m_Tvqs.Tvq20150101
};
var result = m_Periodizer.InsertPoints(ts, Interval.Month);
var tvq = result.Last();
Assert.Equal(new DateTime(2015, 01, 31, 23, 59, 59), tvq.Time);
}
private void loadAllCorrelatedFeatures()
{
string newPath = addHeader(this.trainCSVPath, this.xmlDict);
this.ts = new Timeseries(newPath);
this.ad = new SimpleAnomalyDetector((float)0.5);
this.ad.learnNormal(this.ts);
this.cf = ad.getNormalModel();
}
public void InsertPoints_WhenOnePointAtStart_InsertsEndpointWithSameValueAsInterpolated()
{
var ts = new Timeseries {
m_Tvqs.Tvq20150101
};
var result = m_Periodizer.InsertPoints(ts, Interval.Year);
var tvq = result.Last();
Assert.Equal(ts[0].V, tvq.V);
Assert.Equal(Quality.Interpolated, tvq.Q);
}
public ActionResult ListEntriesView()
{
var repo = GetRegistryEntryRepo();
var entries = repo.GetRegistryEntries();
var sortedTvqs = entries.OrderBy(x => x.Time);
var tsWithRegisterEntries = new Timeseries();
tsWithRegisterEntries.AddRange(sortedTvqs.ToList());
return View(tsWithRegisterEntries);
}
public void SplitPerYear_WhenOnlyOneYear_ReturnsOneEnumerableWithAllValues()
{
var ts = new Timeseries();
var source = ts.Add(m_Tvqs.Tvq20150101).Add(m_Tvqs.Tvq20150601);
var result = m_Periodizer.SplitPerYear(source).ToList();
Assert.Equal(1, result.Count);
Assert.Equal(2, result[0].Count);
Assert.Equal(m_Tvqs.Tvq20150101, result[0][0]);
Assert.Equal(m_Tvqs.Tvq20150601, result[0][1]);
}
public void Apply_WhenThreeValues_ResultHasTwoCurrectValues()
{
var ts = new Timeseries { m_Tvq5, m_Tvq7, m_Tvq11, };
var result = m_Delta.Apply(ts);
Assert.Equal(2, result.Count);
Assert.Equal(m_t1, result[0].Time);
Assert.Equal(m_t2, result[1].Time);
Assert.Equal(2, result[0].V);
Assert.Equal(4, result[1].V);
Assert.Equal(Quality.Ok, result[0].Q);
Assert.Equal(Quality.Ok, result[1].Q);
}
public void Render_WhenFirstValueIsInFebruary_RendersJanuarysValueIsEmpty()
{
// Arrange
var ts = new Timeseries { m_Tvqs.Tvq20160201 };
// Act
m_Renderer.Render(new[] { m_FebToDec }, m_Writer);
// Assert
var tokensWithoutNewlines = GetTokensAfterHeader(m_Writer);
Assert.Equal("1", tokensWithoutNewlines[0]);
Assert.Equal(String.Empty, tokensWithoutNewlines[1]);
}
public void SplitPerYear_WhenOneEachYear_ReturnsTwoEnumerablesWithEachOneValue()
{
var ts = new Timeseries();
var source = ts.Add(m_Tvqs.Tvq20150101).Add(m_Tvqs.Tvq20160101);
var result = m_Periodizer.SplitPerYear(source).ToList();
Assert.Equal(2, result.Count);
Assert.Equal(1, result[0].Count);
Assert.Equal(1, result[1].Count);
Assert.Equal(m_Tvqs.Tvq20150101, result[0].First());
Assert.Equal(m_Tvqs.Tvq20160101, result[1].First());
}
public void Render_WhenOneValueInJanuary_RendersTheValue()
{
// Arrange
var ts = new Timeseries {m_Tvqs.Tvq20160101};
// Act
m_Renderer.Render(new [] { ts }, m_Writer);
// Assert
var tokensWithoutNewlines = GetTokensAfterHeader(m_Writer);
Assert.Equal("1", tokensWithoutNewlines[0]);
Assert.Equal(m_Tvqs.Tvq20160101.V.ToString(CultureInfo.InvariantCulture), tokensWithoutNewlines[1]);
}
public Timeseries Apply(IUnaryAggregateOperator op, Timeseries ts)
{
if (ts == null || ! ts.Any()) return new Timeseries();
var result = new Timeseries();
// Default to monthly
var t = ts.First().Time;
do
{
var t0 = new DateTime(t.Year, t.Month, 1, 0, 0, 0);
var t1 = new DateTime(t.Year, t.Month, DateTime.DaysInMonth(t.Year, t.Month), 23, 59, 59);
result.Add(op.Apply(t0, t1, ts));
t = t0.AddMonths(1);
} while (t <= ts.Last().Time);
return result;
}
public static Timeseries ParseTimeseries(string tabSeparatedTimeseries)
{
var reader = new StringReader(tabSeparatedTimeseries);
var result = new Timeseries();
var line = reader.ReadLine();
while (line != null)
{
var trimmedLine = line.Trim();
if (!string.IsNullOrEmpty(trimmedLine))
{
var tvq = ParseLine(trimmedLine);
result.Add(tvq);
}
line = reader.ReadLine();
}
return result;
}
public ActionResult ListEntriesView()
{
try
{
var repo = new RegistryEntryRepoFactory().GetRegistryEntryRepo();
var entries = repo.GetRegistryEntries(Thread.CurrentPrincipal);
var sortedTvqs = entries.OrderBy(x => x.Time);
var tsWithRegisterEntries = new Timeseries();
tsWithRegisterEntries.AddRange(sortedTvqs.ToList());
return View(tsWithRegisterEntries);
}
catch (Exception e)
{
_logger.TrackException(e);
return View("Error");
}
}
public static Timeseries GetMonthlyAverages(string registerId)
{
var storageAccount = CloudStorageAccount.Parse(
CloudConfigurationManager.GetSetting("StorageConnectionString"));
var repo = new RegistryEntryRepo(storageAccount);
var sortedTvqs = repo.GetRegistryEntries().OrderBy(x => x.Time);
var tsWithRegisterEntries = new Timeseries();
tsWithRegisterEntries.AddRange(sortedTvqs.ToList());
var periodizer = new Periodizer();
var monthlyRegisterEntries = periodizer.MonthlyAverage(tsWithRegisterEntries);
var deltaOperator = new DeltaTsOperator();
var monthlyAverages = deltaOperator.Apply(monthlyRegisterEntries);
return monthlyAverages;
}
public void InsertPoints_When3PointsSameYear_InsertsExtrapolatedEndValue()
{
// Arrange
var ts = new Timeseries { m_Tvqs.Tvq20150101, m_Tvqs.Tvq20150601, m_Tvqs.Tvq20150701 };
// Act
var result = m_Periodizer.InsertPoints(ts, Interval.Year);
// Assert
Assert.Equal(4, result.Count);
var dt = result[2].Time - result[1].Time;
// y = k*x + m
var k = (m_Tvqs.Tvq20150701.V - m_Tvqs.Tvq20150601.V) / dt.TotalSeconds;
var t1 = new DateTime(2015, 12, 31, 23, 59, 59);
var x = (t1 - m_Tvqs.Tvq20150701.Time).TotalSeconds;
var y = k * x + m_Tvqs.Tvq20150701.V;
var tvq = result.Last();
Assert.Equal(t1, tvq.Time);
Assert.Equal(y, tvq.V);
Assert.Equal(Quality.Interpolated, tvq.Q);
}
/// <summary>
/// Applies the delta function to each pair of consecutive values.
/// </summary>
/// <param name="ts">A time series</param>
/// <returns></returns>
public Timeseries Apply(Timeseries ts)
{
const string paramNameTs = "ts";
if (ts == null) throw new ArgumentException("Must be non-null", paramNameTs);
if (ts.Count < 2) throw new ArgumentException("ts must contain at least two elements", paramNameTs);
var result = new Timeseries();
var enumerator = ts.GetEnumerator();
enumerator.MoveNext();
var previous = enumerator.Current;
while (enumerator.MoveNext())
{
var current = enumerator.Current;
var delta = CalculateDelta(current, previous);
result.Add(delta);
previous = current;
}
return result;
}
public static Timeseries GetMonthlyAverages()
{
var repo = new RegistryEntryRepoFactory().GetRegistryEntryRepo();
var sortedTvqs = repo.GetRegistryEntries(Thread.CurrentPrincipal).OrderBy(x => x.Time);
var tsWithRegisterEntries = new Timeseries();
tsWithRegisterEntries.AddRange(sortedTvqs.ToList());
var periodizer = new Periodizer();
var monthlyRegisterEntries = periodizer.MonthlyAverage(tsWithRegisterEntries);
const int minMonths = 2;
var tooFewEntries = monthlyRegisterEntries.Count < minMonths;
var areTooFewEntries = tooFewEntries;
if (areTooFewEntries)
{
throw new TooFewEntriesException(minMonths);
}
var deltaOperator = new DeltaTsOperator();
var monthlyAverages = deltaOperator.Apply(monthlyRegisterEntries);
return monthlyAverages;
}
public void MonthlyAverage_When1ValueInMiddleOfJanAnd1InFeb_InterpolatesEndValue()
{
// Arrange
// Act
const double v = 600;
var ts = new Timeseries
{
new Tvq(m_Tvqs.Tvq20150110.Time, v, Quality.Ok),
new Tvq(new DateTime(2015, 2, 23, 0, 0, 0), 0, Quality.Ok)
};
var averages = m_Periodizer.MonthlyAverage(ts);
//Assert
var x = averages[0];
Assert.Equal(m_Tvqs.Tvq20150101.Time, x.Time);
var area1 = 9 * v;
const int nDays = 31 - 10 + 1;
var area2 = (v + 300d) / 2d * nDays;
var expectedValue = (area1 + area2) / 31d;
Assert.Equal(expectedValue, x.V, 3);
}
public void MonthlyAverage_When2ValuesInMiddleOfJan_ReturnsAsAverageAtFirstSecond()
{
// Arrange
// Act
const double v = 500;
var ts = new Timeseries
{
new Tvq(m_Tvqs.Tvq20150105.Time, v, Quality.Ok),
new Tvq(m_Tvqs.Tvq20150110.Time, 0, Quality.Ok)
};
var averages = m_Periodizer.MonthlyAverage(ts);
//Assert
var x = averages[0];
Assert.Equal(m_Tvqs.Tvq20150101.Time, x.Time);
var area1 = 4 * v;
var area2 = 5 * v / 2;
var expectedValue = (area1 + area2) / 31;
Assert.Equal(expectedValue, x.V, 4);
}
public void MonthlyAverage_WhenConstantValueInJanAndFeb_ReturnsIt()
{
// Arrange
// Act
const double v = 1000;
var ts = new Timeseries
{
new Tvq(m_Tvqs.Tvq20150101.Time, v, Quality.Ok),
new Tvq(m_Tvqs.Tvq20150110.Time, v, Quality.Ok),
new Tvq(new DateTime(2015, 2, 21, 0, 0, 0), v, Quality.Ok)
};
var averages = m_Periodizer.MonthlyAverage(ts);
//Assert
Assert.Equal(v, averages[0].V, 4);
}
public void MonthlyAverage_WhenFrom2015To2017_June2016IsAverage()
{
// Arrange
// Act
var ts = new Timeseries
{
new Tvq(m_Tvqs.Tvq20150601.Time, 200, Quality.Ok),
new Tvq(new DateTime(2017, 07, 01, 0, 0, 0), 400, Quality.Ok)
};
var averages = m_Periodizer.MonthlyAverage(ts);
//Assert
var average = averages.First(a => a.Time == m_Tvqs.Tvq20160601.Time);
Assert.Equal(300d, average.V, 0);
}
public void MonthlyAverage_WhenFrom2015To2017_LastMonthIsCorrect()
{
// Arrange
// Act
const double v = 1000;
var ts = new Timeseries
{
new Tvq(m_Tvqs.Tvq20150601.Time, v, Quality.Ok),
new Tvq(m_Tvqs.Tvq20170601.Time, v, Quality.Ok)
};
var averages = m_Periodizer.MonthlyAverage(ts);
//Assert
var last = averages.Last();
Assert.Equal(new DateTime(2017, 06, 01, 0, 0, 0), last.Time);
Assert.Equal(v, last.V);
}
public void InsertPoints_WhenOnePointAtStart_InsertsEndpointWithSameValueAsInterpolated()
{
var ts = new Timeseries { m_Tvqs.Tvq20150101 };
var result = m_Periodizer.InsertPoints(ts, Interval.Year);
var tvq = result.Last();
Assert.Equal(ts[0].V, tvq.V);
Assert.Equal(Quality.Interpolated, tvq.Q);
}
public void Apply_When5And7_DeltaIs2()
{
var ts = new Timeseries { m_Tvq5, m_Tvq7, };
var result = m_Delta.Apply(ts);
Assert.Equal(2, result[0].V);
}
private Timeseries Create(DateTime tvq20160201, int nValues, int v0, int delta)
{
var ts = new Timeseries();
for (int i = 0; i < nValues; i++)
{
ts.Add(new Tvq(tvq20160201.AddMonths(i), v0 + i*delta, Quality.Ok));
}
return ts;
}
public void MonthlyAverage_WhenFrom2015To2016_TimesAreCorrect()
{
// Arrange
// Act
const double v = 1000;
var ts = new Timeseries
{
new Tvq(m_Tvqs.Tvq20150601.Time, v, Quality.Ok),
new Tvq(m_Tvqs.Tvq20160601.Time, v, Quality.Ok)
};
var averages = m_Periodizer.MonthlyAverage(ts);
//Assert
Assert.Equal(new DateTime(2015, 06, 01, 0, 0, 0), averages[0].Time);
Assert.Equal(new DateTime(2015, 07, 01, 0, 0, 0), averages[1].Time);
Assert.Equal(new DateTime(2015, 12, 01, 0, 0, 0), averages[6].Time);
Assert.Equal(new DateTime(2016, 01, 01, 0, 0, 0), averages[7].Time);
Assert.Equal(new DateTime(2016, 06, 01, 0, 0, 0), averages[12].Time);
}
public void MonthlyAverage_WhenConstantValueInJanAndJune_FebThroughMayAreCorrect()
{
// Arrange
// Act
const double v = 1000;
var ts = new Timeseries
{
new Tvq(m_Tvqs.Tvq20150101.Time, v, Quality.Ok),
new Tvq(m_Tvqs.Tvq20150601.Time, v, Quality.Ok)
};
var averages = m_Periodizer.MonthlyAverage(ts);
//Assert
Assert.Equal(v, averages[1].V, 4);
Assert.Equal(v, averages[2].V, 4);
Assert.Equal(v, averages[3].V, 4);
Assert.Equal(v, averages[4].V, 4);
}
public void Apply_WhenTsHasOneValue_ThrowsArgumentException()
{
var ts = new Timeseries {new Tvq(m_t0, 0, Quality.Ok)};
Assert.Throws<ArgumentException>(() => m_Delta.Apply(ts));
}
