public void ShouldBeEmptyAfterInstanciation()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
Assert.That(timeSeriesData, Is.Not.Null);
Assert.That(timeSeriesData.Count(), Is.EqualTo(0));
}
private static void ReportResponse(string callName, TimeSeriesData response)
{
Console.WriteLine($"Method: {callName}");
Console.WriteLine(response);
Console.WriteLine("Press a key to continue...");
Console.ReadKey();
}
private void loadData()
{
try
{
jr.myData.Clear();
DataTable dt = CSVFileHelper.csv.OpenCSV();
foreach (DataRow dr in dt.Rows)
{
try
{
TimeSeriesData td = new TimeSeriesData();
td.time = GetTime(dr[0].ToString()).ToString("yyyy-MM-dd HH:mm:ss:ffff");
td.sourceTime = dr[0];
td.values = dr[1];
jr.myData.Add(td);
}
catch
{
continue;
}
}
jr.success = true;
WriteResult(this, jr);
}
catch
{
}
}
public void ListWithNoGapWillRemainTheSame()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.AddRange(new[]
{
new AnnualDecimal(10, 10),
new AnnualDecimal(11, 11),
new AnnualDecimal(12, 12),
new AnnualDecimal(13, 13),
new AnnualDecimal(14, 14),
new AnnualDecimal(15, 15)
});
timeSeriesData.FillInGapsWith(year => new AnnualDecimal(year, 55));
var enumerator = timeSeriesData.GetEnumerator();
enumerator.Reset();
enumerator.MoveNext();
Assert.That(enumerator.Current, Is.EqualTo(new AnnualDecimal(10, 10)));
enumerator.MoveNext();
Assert.That(enumerator.Current, Is.EqualTo(new AnnualDecimal(11, 11)));
enumerator.MoveNext();
Assert.That(enumerator.Current, Is.EqualTo(new AnnualDecimal(12, 12)));
enumerator.MoveNext();
Assert.That(enumerator.Current, Is.EqualTo(new AnnualDecimal(13, 13)));
enumerator.MoveNext();
Assert.That(enumerator.Current, Is.EqualTo(new AnnualDecimal(14, 14)));
enumerator.MoveNext();
Assert.That(enumerator.Current, Is.EqualTo(new AnnualDecimal(15, 15)));
}
public void GapsAreFilledInAndListSorted()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.AddRange(new[]
{
new AnnualDecimal(10, 99),
new AnnualDecimal(13, 99),
new AnnualDecimal(15, 99)
});
timeSeriesData.FillInGapsWith(year => new AnnualDecimal(year, 55));
var enumerator = timeSeriesData.GetEnumerator();
enumerator.Reset();
enumerator.MoveNext();
Assert.That(enumerator.Current, Is.EqualTo(new AnnualDecimal(10, 99)));
enumerator.MoveNext();
Assert.That(enumerator.Current, Is.EqualTo(new AnnualDecimal(11, 55)));
enumerator.MoveNext();
Assert.That(enumerator.Current, Is.EqualTo(new AnnualDecimal(12, 55)));
enumerator.MoveNext();
Assert.That(enumerator.Current, Is.EqualTo(new AnnualDecimal(13, 99)));
enumerator.MoveNext();
Assert.That(enumerator.Current, Is.EqualTo(new AnnualDecimal(14, 55)));
enumerator.MoveNext();
Assert.That(enumerator.Current, Is.EqualTo(new AnnualDecimal(15, 99)));
}
private void EnrichWithStockMetadata([NotNull] JProperty metadataJson, [NotNull] TimeSeriesData timeSeriesData)
{
var metadatas = metadataJson.Children().Single();
foreach (var metadataItem in metadatas)
{
var metadataProperty = (JProperty)metadataItem;
var metadataItemName = metadataProperty.Name;
var metadataItemValue = metadataProperty.Value.ToString();
if (metadataItemName.Contains(StockMetaDataJsonToken.InformationToken))
{
timeSeriesData.Type = GetTimeSeriesType(metadataItemValue);
timeSeriesData.IsAdjusted = IsAdjusted(metadataItemValue);
}
else if (metadataItemName.Contains(StockMetaDataJsonToken.RefreshTimeToken))
{
var refreshTime = metadataItemValue.ParseDateTime();
timeSeriesData.LastRefreshedUtc = DateTime.SpecifyKind(refreshTime, DateTimeKind.Local);
}
else if (metadataItemName.Contains(StockMetaDataJsonToken.SymbolToken))
{
timeSeriesData.Symbol = metadataItemValue;
}
else if (metadataItemName.Contains(StockMetaDataJsonToken.TimezoneToken))
{
timeSeriesData.LastRefreshedUtc = timeSeriesData.LastRefreshedUtc.ConvetToUtc(metadataItemValue);
}
}
}
private void EnrichWithFxMetadata([NotNull] JProperty metadataJson, [NotNull] TimeSeriesData timeSeriesData)
{
var metadatas = metadataJson.Children().Single();
foreach (var metadataItem in metadatas)
{
var metadataProperty = (JProperty)metadataItem;
var metadataItemName = metadataProperty.Name;
var metadataItemValue = metadataProperty.Value.ToString();
if (metadataItemName.Contains(FxMetaDataJsonToken.InformationToken))
{
timeSeriesData.Type = GetTimeSeriesType(metadataItemValue);
timeSeriesData.IsAdjusted = IsAdjusted(metadataItemValue);
}
else if (metadataItemName.Contains(FxMetaDataJsonToken.RefreshTimeToken))
{
var refreshTime = metadataItemValue.Replace("(end of day)", string.Empty).Trim().ParseDateTime();
timeSeriesData.LastRefreshedUtc = DateTime.SpecifyKind(refreshTime, DateTimeKind.Local);
}
else if (metadataItemName.Contains(FxMetaDataJsonToken.SymbolFrom))
{
timeSeriesData.Symbol = metadataItemValue;
}
else if (metadataItemName.Contains(FxMetaDataJsonToken.SymbolTo))
{
timeSeriesData.Market = metadataItemValue;
}
}
}
public void EmptyListHasNoGap()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.FillInGapsWith(year => new AnnualDecimal(year, 55));
Assert.That(timeSeriesData.Count, Is.EqualTo(0));
}
public void TrimmingAnEmptyTimeSeriesData()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.TrimNullData();
Assert.That(timeSeriesData.Count, Is.EqualTo(0));
}
public void GettingAbsentValue()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.Add(new AnnualDecimal(5, 5));
timeSeriesData.Add(new AnnualDecimal(20, 20));
Assert.That(timeSeriesData.GetYear(10), Is.Null);
}
public void SettingAndGettingData()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.Add(new AnnualDecimal(10, 100));
Assert.That(timeSeriesData.Count, Is.EqualTo(1));
Assert.That(timeSeriesData.GetYear(10).Value, Is.EqualTo(100));
}
public void HasNonNullValues()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.Add(new AnnualDecimal(10, 0));
timeSeriesData.Add(new AnnualDecimal(20, null));
Assert.That(timeSeriesData.HasNonNullValues(), Is.True);
Assert.That(timeSeriesData.HasNonZeroValues(), Is.False);
}
public void RewritingTheSameYearOnAnSingleElementList()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.Add(new AnnualDecimal(10, 100));
timeSeriesData.Add(new AnnualDecimal(10, 200));
Assert.That(timeSeriesData.Count, Is.EqualTo(1));
Assert.That(timeSeriesData.GetYear(10).Value, Is.EqualTo(200));
}
public void StartAndEndYearShouldFailWhenTimeSeriesEmpty()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
Assert.That(timeSeriesData.IsNotEmpty(), Is.False);
Assert.Throws <InvalidOperationException>(() => timeSeriesData.StartYear());
Assert.Throws <InvalidOperationException>(() => timeSeriesData.EndYear());
Assert.Throws <InvalidOperationException>(() => timeSeriesData.StartYearOfNonZeroValue());
Assert.Throws <InvalidOperationException>(() => timeSeriesData.EndYearOfNonZeroValue());
}
private async Task StartBatchModeProcessAsync()
{
try
{
detectingAnomalyBtn.IsEnabled = false;
string timestampFormat = curScenario.ScenarioType == AnomalyDetectionScenarioType.Telecom ? ShortDateFormat : ShortDateWithTimeFormat;
double dataRange = curScenario.MaxValue - curScenario.MinValue;
double yScale = (resultGrid.ActualHeight / dataRange);
double yZeroLine = yScale * curScenario.MinValue;
for (int i = 0; i < dataPolyline.Points.Count; i++)
{
progressIndicator.Offset = new Vector3(float.Parse(dataPolyline.Points[i].X.ToString()), float.Parse(resultGrid.ActualHeight.ToString()), resultGrid.CenterPoint.Z);
progressLine.X1 = dataPolyline.Points[i].X;
progressLine.X2 = dataPolyline.Points[i].X;
if (anomalyEntireDetectResult != null)
{
Point newUpperPoint = new Point(dataPolyline.Points[i].X, yZeroLine + resultGrid.ActualHeight - (yScale * (anomalyEntireDetectResult.ExpectedValues[i] + anomalyEntireDetectResult.UpperMargins[i])));
Point newLowerPoint = new Point(dataPolyline.Points[i].X, yZeroLine + resultGrid.ActualHeight - (yScale * (anomalyEntireDetectResult.ExpectedValues[i] - anomalyEntireDetectResult.LowerMargins[i])));
if (anomalyEntireDetectResult.IsAnomaly[i])
{
SpriteVisual anomalyIndicator = GetNewAnomalyIndicator(dataPolyline.Points[i]);
TimeSeriesData timeSeriesData = curScenario.AllData[i];
AnomalyInfo anomalyInfo = new AnomalyInfo
{
Text = Util.StringToDateFormat(timeSeriesData.Timestamp, timestampFormat),
Value = timeSeriesData.Value.ToString("F2"),
ExpectedValue = anomalyEntireDetectResult.ExpectedValues[i].ToString("F2")
};
containerRoot.Children.InsertAtTop(anomalyIndicator);
allAnomalyIndicators.Add(new Tuple <SpriteVisual, AnomalyInfo>(anomalyIndicator, anomalyInfo));
}
int endOfUpper = progressPolyline.Points.Count / 2;
int endOfLower = progressPolyline.Points.Count / 2 + 1;
progressPolyline.Points.Insert(endOfUpper, newUpperPoint);
progressPolyline.Points.Insert(endOfLower, newLowerPoint);
}
}
}
catch (Exception ex)
{
await Util.GenericApiCallExceptionHandler(ex, "Failure during batch detection.");
}
finally
{
detectingAnomalyBtn.IsEnabled = true;
}
}
public void CanSerializeAndDeserializeEmptyClass()
{
var tsd = new TimeSeriesData <AnnualDecimal>();
var json = JsonConvert.SerializeObject(tsd);
Assert.That(json, Is.Not.Null);
Debug.WriteLine(json);
var deserialized = JsonConvert.DeserializeObject <TimeSeriesData <AnnualDecimal> >(json);
Assert.That(deserialized, Is.Not.Null);
}
public void HasZeroValues()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.Add(new AnnualDecimal(10, 0));
timeSeriesData.Add(new AnnualDecimal(20, 0));
Assert.That(timeSeriesData.HasNonNullValues(), Is.True);
Assert.That(timeSeriesData.HasNonZeroValues(), Is.False);
Assert.That(timeSeriesData.StartYear(), Is.EqualTo(10));
Assert.That(timeSeriesData.EndYear(), Is.EqualTo(20));
}
public void RewritingTheSameYearOnPopulatedList()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.Add(new AnnualDecimal(1, 100));
timeSeriesData.Add(new AnnualDecimal(2, 100));
timeSeriesData.Add(new AnnualDecimal(10, 100));
timeSeriesData.Add(new AnnualDecimal(10, 200));
Assert.That(timeSeriesData.Count, Is.EqualTo(3));
Assert.That(timeSeriesData.GetYear(10).Value, Is.EqualTo(200));
}
protected void LoadDataFromFile(string visDataFileName)
{
string filePath = Path.Combine(Application.streamingAssetsPath, visDataFileName);
if (File.Exists(filePath))
{
string dataAsJsonText = File.ReadAllText(filePath);
data = JsonUtility.FromJson <TimeSeriesData>(dataAsJsonText);
Debug.Log($"Loaded data for {data.datasets.Select(d => d.label).Aggregate("", (agg, name) => $"{agg}, {name}")}");
}
}
public void StartAndEndYearShouldFailWhenTimeSeriesIsAllZero()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.Add(new AnnualDecimal(10, 0));
timeSeriesData.Add(new AnnualDecimal(20, 0));
Assert.That(timeSeriesData.IsNotEmpty(), Is.True);
Assert.That(timeSeriesData.StartYear(), Is.EqualTo(10));
Assert.That(timeSeriesData.EndYear(), Is.EqualTo(20));
Assert.Throws <InvalidOperationException>(() => timeSeriesData.StartYearOfNonZeroValue());
Assert.Throws <InvalidOperationException>(() => timeSeriesData.EndYearOfNonZeroValue());
}
private static ITimeSeriesData <double> CreateTimeSeriesData(DateTime[] time, float[] values)
{
ITimeSeriesData <double> data = new TimeSeriesData <double>();
for (var i = 0; i < time.Length; i++)
{
data.DateTimes.Add(time[i]);
data.Values.Add(values[i]);
}
return(data);
}
public void CanCreateWithNonPopulatedYears()
{
var prepopulated = new List <AnnualDecimal>();
prepopulated.Add(new AnnualDecimal(0, 1));
prepopulated.Add(new AnnualDecimal(0, 2));
prepopulated.Add(new AnnualDecimal(0, 3));
var timeSeriesData = new TimeSeriesData <AnnualDecimal>(prepopulated);
Assert.That(timeSeriesData.Count, Is.EqualTo(3));
Assert.That(timeSeriesData.GetYear(0), Is.EqualTo(new AnnualDecimal(0, 1)));
Assert.That(timeSeriesData.GetYear(1), Is.EqualTo(new AnnualDecimal(1, 2)));
Assert.That(timeSeriesData.GetYear(2), Is.EqualTo(new AnnualDecimal(2, 3)));
}
public void GettingNonExistentYearShouldReturnNull()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.AddRange(new[]
{
new AnnualDecimal(10, null),
new AnnualDecimal(11, null),
new AnnualDecimal(12, null),
});
Assert.That(timeSeriesData.GetYear(100), Is.Null);
Assert.That(timeSeriesData.GetYear(10), Is.EqualTo(new AnnualDecimal(10, null)));
Assert.That(timeSeriesData.GetYear(12), Is.EqualTo(new AnnualDecimal(12, null)));
}
public void CanSerializeAndDeserialize()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.Add(new AnnualDecimal(10, 100));
timeSeriesData.Add(new AnnualDecimal(20, 200));
Assert.That(timeSeriesData.Count, Is.EqualTo(2));
var json = JsonConvert.SerializeObject(timeSeriesData);
Assert.That(json, Is.Not.Null);
Debug.WriteLine(json);
var deserialized = JsonConvert.DeserializeObject <TimeSeriesData <AnnualDecimal> >(json);
Assert.That(deserialized, Is.Not.Null);
Assert.That(deserialized.Count, Is.EqualTo(2));
}
public void TrimmingAllNullValuesTimeSeriesDataFromTheEnd()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.AddRange(new[]
{
new AnnualDecimal(10, null),
new AnnualDecimal(11, null),
new AnnualDecimal(12, null),
new AnnualDecimal(13, null),
new AnnualDecimal(14, null),
new AnnualDecimal(15, null)
});
timeSeriesData.TrimNullDataFromTheEnd();
Assert.That(timeSeriesData.Count, Is.EqualTo(0));
}
public void CanSerializeAndDeserializeTimeSeriesDataWithSomeZeroAndNullValues()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.Add(new AnnualDecimal(10, 100));
timeSeriesData.Add(new AnnualDecimal(20, 0));
timeSeriesData.Add(new AnnualDecimal(30, null));
var json = JsonConvert.SerializeObject(timeSeriesData);
Assert.That(json, Is.Not.Null);
Assert.That(json, Is.EqualTo("[{\"Year\":10,\"Value\":100.0},{\"Year\":20,\"Value\":0.0},{\"Year\":30,\"Value\":null}]"));
var deserialized = JsonConvert.DeserializeObject <TimeSeriesData <AnnualDecimal> >(json);
Assert.That(deserialized, Is.Not.Null);
Assert.That(deserialized.Count, Is.EqualTo(3));
Assert.That(timeSeriesData, Is.EqualTo(deserialized));
}
public void ShouldNotRemoveNullValuesFromTheMiddle()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.AddRange(new[]
{
new AnnualDecimal(10, 10),
new AnnualDecimal(11, null),
new AnnualDecimal(12, null),
new AnnualDecimal(13, null),
new AnnualDecimal(14, null),
new AnnualDecimal(15, 15)
});
timeSeriesData.TrimNullData();
Assert.That(timeSeriesData.Count, Is.EqualTo(6));
Assert.That(timeSeriesData.GetYear(timeSeriesData.StartYear()), Is.EqualTo(new AnnualDecimal(10, 10)));
Assert.That(timeSeriesData.GetYear(timeSeriesData.EndYear()), Is.EqualTo(new AnnualDecimal(15, 15)));
}
public void ShouldOnlyTrimTheStart()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.AddRange(new[]
{
new AnnualDecimal(10, null),
new AnnualDecimal(11, null),
new AnnualDecimal(12, 12),
new AnnualDecimal(13, 13),
new AnnualDecimal(14, null),
new AnnualDecimal(15, null)
});
timeSeriesData.TrimNullDataFromTheStart();
Assert.That(timeSeriesData.Count, Is.EqualTo(4));
Assert.That(timeSeriesData.GetYear(timeSeriesData.StartYear()), Is.EqualTo(new AnnualDecimal(12, 12)));
Assert.That(timeSeriesData.GetYear(timeSeriesData.EndYear()), Is.EqualTo(new AnnualDecimal(15, null)));
}
public void TrimmedNonNullDataWillReturnTheSameTimeSeries()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.AddRange(new[]
{
new AnnualDecimal(10, 10),
new AnnualDecimal(11, 11),
new AnnualDecimal(12, 12),
new AnnualDecimal(13, 13),
new AnnualDecimal(14, 14),
new AnnualDecimal(15, 15)
});
timeSeriesData.TrimNullData();
Assert.That(timeSeriesData.Count, Is.EqualTo(6));
Assert.That(timeSeriesData.GetYear(timeSeriesData.StartYear()), Is.EqualTo(new AnnualDecimal(10, 10)));
Assert.That(timeSeriesData.GetYear(timeSeriesData.EndYear()), Is.EqualTo(new AnnualDecimal(15, 15)));
}
public void DataIsSortedAfterAddingOneByOne()
{
var timeSeriesData = new TimeSeriesData <AnnualDecimal>();
timeSeriesData.Add(new AnnualDecimal(30, 3));
timeSeriesData.Add(new AnnualDecimal(10, 1));
timeSeriesData.Add(new AnnualDecimal(40, 4));
timeSeriesData.Add(new AnnualDecimal(20, 2));
var enumerator = timeSeriesData.GetEnumerator();
enumerator.Reset();
enumerator.MoveNext();
Assert.That(enumerator.Current, Is.EqualTo(new AnnualDecimal(10, 1)));
enumerator.MoveNext();
Assert.That(enumerator.Current, Is.EqualTo(new AnnualDecimal(20, 2)));
enumerator.MoveNext();
Assert.That(enumerator.Current, Is.EqualTo(new AnnualDecimal(30, 3)));
enumerator.MoveNext();
Assert.That(enumerator.Current, Is.EqualTo(new AnnualDecimal(40, 4)));
}
