public void AddOpDoubleTimeSeries_AddsDoubles()
{
var doubleTimeSeries1 = new DoubleTimeSeries <Month>(Month.CreateJanuary(2020), new[] { 1.0, 2.0, 3.0 });
var doubleTimeSeries2 = new DoubleTimeSeries <Month>(Month.CreateFebruary(2020), new[] { 1.8, 2.1 });
DoubleTimeSeries <Month> doubleTimeSeriesAdded = doubleTimeSeries1 + doubleTimeSeries2;
Assert.AreEqual(3, doubleTimeSeriesAdded.Count);
Assert.AreEqual(1.0, doubleTimeSeriesAdded[Month.CreateJanuary(2020)]);
Assert.AreEqual(3.8, doubleTimeSeriesAdded[Month.CreateFebruary(2020)]);
Assert.AreEqual(5.1, doubleTimeSeriesAdded[Month.CreateMarch(2020)]);
}
public void SubtractOpDoubleTimeSeries_ParameterIndicesStartLater_ThrowsArgumentException()
{
var doubleTimeSeries1 = new DoubleTimeSeries <Month>(Month.CreateJanuary(2020), new[] { 1.0, 2.0, 3.0 });
var doubleTimeSeries2 = new DoubleTimeSeries <Month>(Month.CreateMarch(2019), new[] { 1.8, 2.1 });
Assert.Throws(Is.TypeOf <ArgumentException>().And.Message.EqualTo("DoubleTimeSeries parameter instance has indices which are non-overlapping with the indices of the current instance."),
() =>
{
// ReSharper disable once UnusedVariable
var doubleTimeSeriesSubtracted = doubleTimeSeries1 - doubleTimeSeries2;
});
}
public void SubtractOpDoubleTimeSeries_SubtractsDoubles()
{
var doubleTimeSeries1 = new DoubleTimeSeries <Month>(Month.CreateJanuary(2020), new[] { 1.0, 2.0, 3.0 });
var doubleTimeSeries2 = new DoubleTimeSeries <Month>(Month.CreateFebruary(2020), new[] { 1.8, 2.1 });
DoubleTimeSeries <Month> doubleTimeSeriesSubtracted = doubleTimeSeries1 - doubleTimeSeries2;
Assert.AreEqual(3, doubleTimeSeriesSubtracted.Count);
Assert.AreEqual(1.0, doubleTimeSeriesSubtracted[Month.CreateJanuary(2020)]);
Assert.AreEqual(2.0 - 1.8, doubleTimeSeriesSubtracted[Month.CreateFebruary(2020)]);
Assert.AreEqual(3.0 - 2.1, doubleTimeSeriesSubtracted[Month.CreateMarch(2020)]);
}
public void SubtractOpDoubleTimeSeries_LeftOperandIsEmpty_ThrowsInvalidOperationException()
{
var doubleTimeSeries1 = new DoubleTimeSeries <Month>();
var doubleTimeSeries2 = new DoubleTimeSeries <Month>(Month.CreateFebruary(2020), new[] { 1.8, 2.1 });
Assert.Throws(Is.TypeOf <InvalidOperationException>().And.Message.EqualTo("TimeSeries is empty."),
() =>
{
// ReSharper disable once UnusedVariable
var doubleTimeSeriesSubtracted = doubleTimeSeries1 - doubleTimeSeries2;
});
}
public void MultiplyOpDoubleTimeSeries_MultipliesDoubles()
{
var doubleTimeSeries1 = new DoubleTimeSeries <Month>(Month.CreateJanuary(2020), new[] { 1.0, 2.0, 3.0 });
var doubleTimeSeries2 = new DoubleTimeSeries <Month>(Month.CreateFebruary(2020), new[] { 1.8, 2.1 });
DoubleTimeSeries <Month> doubleTimeSeriesMultiplied = doubleTimeSeries1 * doubleTimeSeries2;
Assert.AreEqual(3, doubleTimeSeriesMultiplied.Count);
Assert.AreEqual(1.0, doubleTimeSeriesMultiplied[Month.CreateJanuary(2020)]);
Assert.AreEqual(2.0 * 1.8, doubleTimeSeriesMultiplied[Month.CreateFebruary(2020)]);
Assert.AreEqual(3.0 * 2.1, doubleTimeSeriesMultiplied[Month.CreateMarch(2020)]);
}
public void AddOpDoubleOnRight_AddsNumberToData()
{
var doubleTimeSeries = new DoubleTimeSeries <Month>(Month.CreateJanuary(2020), new [] { 1.0, 2.0, 3.0 });
double doubleToAdd = 5.5;
DoubleTimeSeries <Month> doubleTimeSeriesAfterAdd = doubleTimeSeries + doubleToAdd;
foreach ((Month month, double value) in doubleTimeSeriesAfterAdd)
{
Assert.AreEqual(doubleTimeSeries[month] + doubleToAdd, value);
}
Assert.AreEqual(doubleTimeSeries.Count, doubleTimeSeriesAfterAdd.Count);
}
public void BuilderWithData_ConstructedWithCapacityParameter_AddsPointsToBuiltSeries()
{
var timeSeries = new DoubleTimeSeries <Month> .Builder(1)
.WithData(Month.CreateJanuary(2019), 1.0)
.WithData(Month.CreateFebruary(2019), 2.0)
.WithData(Month.CreateMarch(2019), 3.0)
.Build();
Assert.AreEqual(3, timeSeries.Count);
Assert.AreEqual(1.0, timeSeries[Month.CreateJanuary(2019)]);
Assert.AreEqual(2.0, timeSeries[Month.CreateFebruary(2019)]);
Assert.AreEqual(3.0, timeSeries[Month.CreateMarch(2019)]);
}
public void DivideOp_DividesNumberFromData()
{
var doubleTimeSeries = new DoubleTimeSeries <Month>(Month.CreateJanuary(2020), new[] { 1.0, 2.0, 3.0 });
double doubleToDivides = 5.5;
DoubleTimeSeries <Month> doubleTimeSeriesAfterAdd = doubleTimeSeries / doubleToDivides;
foreach ((Month month, double value) in doubleTimeSeriesAfterAdd)
{
Assert.AreEqual(doubleTimeSeries[month] / doubleToDivides, value);
}
Assert.AreEqual(doubleTimeSeries.Count, doubleTimeSeriesAfterAdd.Count);
}
public void SubtractOp_SubtractsNumberFromData()
{
var doubleTimeSeries = new DoubleTimeSeries <Month>(Month.CreateJanuary(2020), new[] { 1.0, 2.0, 3.0 });
double doubleToSubtract = 5.5;
DoubleTimeSeries <Month> doubleTimeSeriesAfterAdd = doubleTimeSeries - doubleToSubtract;
foreach ((Month month, double value) in doubleTimeSeriesAfterAdd)
{
Assert.AreEqual(doubleTimeSeries[month] - doubleToSubtract, value);
}
Assert.AreEqual(doubleTimeSeries.Count, doubleTimeSeriesAfterAdd.Count);
}
public void MultiplyOpDoubleOnLeft_MultipliesDataByNumber()
{
var doubleTimeSeries = new DoubleTimeSeries <Month>(Month.CreateJanuary(2020), new[] { 1.0, 2.0, 3.0 });
double doubleToMultiply = 5.5;
DoubleTimeSeries <Month> doubleTimeSeriesAfterAdd = doubleToMultiply * doubleTimeSeries;
foreach ((Month month, double value) in doubleTimeSeriesAfterAdd)
{
Assert.AreEqual(doubleTimeSeries[month] * doubleToMultiply, value);
}
Assert.AreEqual(doubleTimeSeries.Count, doubleTimeSeriesAfterAdd.Count);
}
public void BuilderBuild_AsExpected()
{
var timeSeries = new DoubleTimeSeries <Month> .Builder
{
{ Month.CreateJanuary(2019), 1.0 },
{ Month.CreateFebruary(2019), 2.0 },
{ Month.CreateMarch(2019), 3.0 }
}.Build();
Assert.AreEqual(3, timeSeries.Count);
Assert.AreEqual(1.0, timeSeries[Month.CreateJanuary(2019)]);
Assert.AreEqual(2.0, timeSeries[Month.CreateFebruary(2019)]);
Assert.AreEqual(3.0, timeSeries[Month.CreateMarch(2019)]);
}
private static TreeStorageValuationResults <T> TrinomialStorageValuationIntrinsic <T>(
DateTime valuationDateTime,
DateTime storageStartDateTime,
DateTime storageEndDateTime,
object injectWithdrawConstraints,
string injectWithdrawInterpolation,
double injectionCostRate,
double cmdtyConsumedOnInjection,
double withdrawalCostRate,
double cmdtyConsumedOnWithdrawal,
double currentInventory,
object forwardCurveIn,
object interestRateCurve,
object numGlobalGridPointsIn,
object numericalToleranceIn)
where T : ITimePeriod <T>
{
double numericalTolerance = StorageExcelHelper.DefaultIfExcelEmptyOrMissing(numericalToleranceIn, 1E-10,
"Numerical_tolerance");
var storage = StorageExcelHelper.CreateCmdtyStorageFromExcelInputs <T>(storageStartDateTime,
storageEndDateTime, injectWithdrawConstraints, injectWithdrawInterpolation, injectionCostRate, cmdtyConsumedOnInjection,
withdrawalCostRate, cmdtyConsumedOnWithdrawal, numericalTolerance);
T currentPeriod = TimePeriodFactory.FromDateTime <T>(valuationDateTime);
DoubleTimeSeries <T> forwardCurve = StorageExcelHelper.CreateDoubleTimeSeries <T>(forwardCurveIn, "Forward_curve");
// TODO input settlement dates
int numGridPoints =
StorageExcelHelper.DefaultIfExcelEmptyOrMissing <int>(numGlobalGridPointsIn, 100, "Num_global_grid_points");
Func <Day, double> interpolatedInterestRates =
StorageExcelHelper.CreateLinearInterpolatedInterestRateFunc(interestRateCurve, ExcelArg.InterestRateCurve.Name);
TreeStorageValuationResults <T> valuationResults = TreeStorageValuation <T>
.ForStorage(storage)
.WithStartingInventory(currentInventory)
.ForCurrentPeriod(currentPeriod)
.WithForwardCurve(forwardCurve)
.WithIntrinsicTree()
.WithCmdtySettlementRule(period => period.First <Day>()) // TODO get rid if this
.WithAct365ContinuouslyCompoundedInterestRate(interpolatedInterestRates)
.WithFixedNumberOfPointsOnGlobalInventoryRange(numGridPoints)
.WithLinearInventorySpaceInterpolation()
.WithNumericalTolerance(numericalTolerance)
.Calculate();
return(valuationResults);
}
public void PlotTimeSeries(DoubleTimeSeries ts, string titletext, Color color, RenderAs linetype)
{
if (!keepSeries.IsChecked.Value)
{
clearSeries_Click(null, null);
}
if (keepSeries.IsChecked.Value)
{
timeseriesChart.Titles[0].Text = "";
}
else
{
timeseriesChart.Titles[0].Text = titletext;
}
_DoubleTimeSeries = ts;
var dataSeries = new DataSeries();
// Set DataSeries properties
dataSeries.RenderAs = RenderAs.QuickLine;
dataSeries.XValueType = ChartValueTypes.DateTime;
dataSeries.LegendText = titletext;
dataSeries.LineThickness = 2;
double max = ts.Values.Max();
double min = ts.Values.Min();
double range = max - min;
var axisy = timeseriesChart.AxesY[0];
if (range > 0)
{
var maxy = max + range * 0.1;
var miny = min - range * 0.1;
miny = miny < 0 ? 0 : miny;
axisy.AxisMaximum = maxy;
axisy.AxisMinimum = miny;
}
for (int i = 0; i < ts.DateTimes.Count; i++)
{
DataPoint dataPoint = new DataPoint();
dataPoint.XValue = ts.DateTimes[i];
dataPoint.YValue = ts.Values[i];
dataSeries.DataPoints.Add(dataPoint);
}
dataSeries.Color = new SolidColorBrush(color);
timeseriesChart.Series.Add(dataSeries);
}
public void ForConstantData_AsExpected()
{
var start = new Day(2020, 9, 30);
var end = new Day(2020, 12, 15);
const double data = 1.25;
DoubleTimeSeries <Day> timeSeries = DoubleTimeSeries.ForConstantData(start, end, data);
Assert.AreEqual(start, timeSeries.Start);
Assert.AreEqual(end, timeSeries.End);
foreach (double x in timeSeries.Data)
{
Assert.AreEqual(data, x);
}
}
private void btnOpenCSVData_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog dlg = new OpenFileDialog();
dlg.Multiselect = false;
dlg.Filter = "csv Files (*.csv)|*.csv|All Files (*.*)|*.*";
if (!(dlg.ShowDialog() ?? false))
{
return;
}
var fs = dlg.File.OpenRead();
StreamReader sr = new StreamReader(fs);
var line = sr.ReadLine();
var splitor = new char[] { ',' };
var strs = line.Split(splitor);
var nts = strs.Count() - 1;
var legends = new string[nts];
DoubleTimeSeries[] ts = new DoubleTimeSeries[nts];
double[] vec = new double[nts];
for (int i = 0; i < nts; i++)
{
ts[i] = new DoubleTimeSeries();
ts[i].DateTimes = new System.Collections.ObjectModel.ObservableCollection <DateTime>();
ts[i].Values = new System.Collections.ObjectModel.ObservableCollection <double>();
}
while (!sr.EndOfStream)
{
line = sr.ReadLine();
if (line != "" && line != null)
{
strs = line.Split(splitor);
DateTime date = DateTime.Parse(strs[0]);
for (int i = 0; i < nts; i++)
{
ts[i].DateTimes.Add(date);
ts[i].Values.Add(double.Parse(strs[i + 1]));
}
}
}
sr.Close();
for (int i = 0; i < nts; i++)
{
PlotTimeSeries(ts[i], legends[i]);
}
}
private static void DoubleTimeSeries()
{
#region doubletimeseries
DoubleTimeSeries <Month> doubleTimeSeries = new DoubleTimeSeries <Month> .Builder()
{
{ new Month(2020, 1), 45.67 },
{ new Month(2020, 2), 47.01 },
{ new Month(2020, 3), 50.34 },
}
.Build();
Console.WriteLine("DoubleTimeSeries");
Console.WriteLine(doubleTimeSeries.FormatData("F2"));
Console.WriteLine();
DoubleTimeSeries <Month> doubleTimeSeriesAfterMultiply = doubleTimeSeries * 1.3;
Console.WriteLine("DoubleTimeSeries transformed with multiply operator and double");
Console.WriteLine(doubleTimeSeriesAfterMultiply.FormatData("F2"));
Console.WriteLine();
DoubleTimeSeries <Month> doubleTimeSeriesAfterAdd = doubleTimeSeries + 5.5;
Console.WriteLine("DoubleTimeSeries transformed with add operator and double");
Console.WriteLine(doubleTimeSeriesAfterAdd.FormatData("F2"));
Console.WriteLine();
DoubleTimeSeries <Month> otherDoubleTimeSeries = new DoubleTimeSeries <Month> .Builder()
{
{ new Month(2020, 1), 1.3 },
{ new Month(2020, 2), 1.4 },
{ new Month(2020, 3), 1.35 },
}
.Build();
DoubleTimeSeries <Month> timeSeriesSubtracted = doubleTimeSeries - otherDoubleTimeSeries;
Console.WriteLine("DoubleTimeSeries transformed with minus operator and other DoubleTimeSeries");
Console.WriteLine(timeSeriesSubtracted.FormatData("F2"));
Console.WriteLine();
DoubleTimeSeries <Month> timeSeriesDivided = doubleTimeSeries / otherDoubleTimeSeries;
Console.WriteLine("DoubleTimeSeries transformed with divide operator and other DoubleTimeSeries");
Console.WriteLine(timeSeriesDivided.FormatData("F2"));
Console.WriteLine();
#endregion
}
public void FromMap_AsExpected()
{
var start = new Day(2020, 9, 30);
var end = new Day(2020, 12, 15);
double Map(Day day) => day.OffsetFrom(start);
DoubleTimeSeries <Day> timeSeries = DoubleTimeSeries.FromMap(start, end, Map);
Assert.AreEqual(start, timeSeries.Start);
Assert.AreEqual(end, timeSeries.End);
foreach ((Day index, double data) in timeSeries)
{
double expectedData = Map(index);
Assert.AreEqual(expectedData, data);
}
}
private void client_GetDoubleTimeSeriesCompleted(object sender, GetDoubleTimeSeriesCompletedEventArgs e)
{
if (e.Error != null || e.Result == null)
{
_IsDownloadingTimeSeries = false;
CurrentAction = UserAction.None;
GeneralInfo.Content = "Failed to download time series";
return;
}
_DoubleTimeSeries = e.Result;
string title = string.Format("{0} at {1}", _QueryCriteria.VariableName, _SelectedStation.Name);
ChartWindow.Visibility = System.Windows.Visibility.Visible;
chart.PlotTimeSeries(_DoubleTimeSeries, title);
_IsDownloadingTimeSeries = false;
CurrentAction = UserAction.Idle;
GeneralInfo.Content = _DoubleTimeSeries.DateTimes.Count + " values downloaded";
}
// TODO add spot simulation Markov factors
public LsmcStorageValuationResults(double npv, DoubleTimeSeries <T> deltas, TimeSeries <T, StorageProfile> expectedStorageProfile,
Panel <T, double> regressionSpotPriceSim, Panel <T, double> valuationSpotPriceSim,
Panel <T, double> inventoryBySim, Panel <T, double> injectWithdrawVolumeBySim, Panel <T, double> cmdtyConsumedBySim,
Panel <T, double> inventoryLossBySim, Panel <T, double> netVolumeBySim, TimeSeries <T, TriggerPrices> triggerPrices,
TimeSeries <T, TriggerPriceVolumeProfiles> triggerPriceVolumeProfiles, Panel <T, double> pvByPeriodAndSim, IEnumerable <double> pvBySim)
{
Npv = npv;
Deltas = deltas;
ExpectedStorageProfile = expectedStorageProfile;
RegressionSpotPriceSim = regressionSpotPriceSim;
ValuationSpotPriceSim = valuationSpotPriceSim;
InventoryBySim = inventoryBySim;
InjectWithdrawVolumeBySim = injectWithdrawVolumeBySim;
CmdtyConsumedBySim = cmdtyConsumedBySim;
InventoryLossBySim = inventoryLossBySim;
NetVolumeBySim = netVolumeBySim;
TriggerPrices = triggerPrices;
TriggerPriceVolumeProfiles = triggerPriceVolumeProfiles;
PvByPeriodAndSim = pvByPeriodAndSim;
PvBySim = pvBySim.ToArray();
}
public static DoubleTimeSeries <T> CreateDoubleTimeSeries <T>(object excelValues, string excelArgumentName)
where T : ITimePeriod <T>
{
if (excelValues is ExcelMissing || excelValues is ExcelEmpty)
{
throw new ArgumentException(excelArgumentName + " hasn't been specified.");
}
if (!(excelValues is object[,] excelValuesArray))
{
throw new ArgumentException(excelArgumentName + " has been incorrectly entered. Argument value should be of a range with 2 columns, the first containing dates, the second containing numbers.");
}
if (excelValuesArray.GetLength(1) != 2)
{
throw new ArgumentException(excelArgumentName + " has been incorrectly entered. Argument value should be a range with 2 columns.");
}
var builder = new DoubleTimeSeries <T> .Builder();
for (int i = 0; i < excelValuesArray.GetLength(0); i++)
{
if (excelValuesArray[i, 0] is ExcelEmpty || excelValuesArray[i, 0] is ExcelError)
{
break;
}
if (!(excelValuesArray[i, 1] is double doubleValue))
{
throw new ArgumentException($"Value in the second column of row {i} for argument {excelArgumentName} is not a number.");
}
DateTime curvePointDateTime = ObjectToDateTime(excelValuesArray[i, 0], $"Cannot create DateTime from value in first row of argument {excelArgumentName}.");
T curvePointPeriod = TimePeriodFactory.FromDateTime <T>(curvePointDateTime);
builder.Add(curvePointPeriod, doubleValue);
}
return(builder.Build());
}
internal static CallOptionLikeTestData CreateThreeCallsLikeStorageTestData(DoubleTimeSeries <Day> forwardCurve)
{
var callOption1Date = new Day(2019, 12, 15);
var callOption2Date = new Day(2020, 1, 20);
var callOption3Date = new Day(2020, 3, 31);
var storageStart = new Day(2019, 12, 1);
var storageEnd = new Day(2020, 4, 1);
const double callOption1Notional = 1200.0;
const double callOption2Notional = 800.0;
const double callOption3Notional = 900.0;
const double storageStartingInventory = callOption1Notional + callOption2Notional + callOption3Notional;
TimeSeries <Month, Day> settlementDates = new TimeSeries <Month, Day> .Builder()
{
{ new Month(2019, 12), new Day(2020, 1, 20) },
{ new Month(2020, 1), new Day(2020, 2, 18) },
{ new Month(2020, 2), new Day(2020, 3, 21) },
{ new Month(2020, 3), new Day(2020, 4, 22) }
}
.Build();
// Make all call options at or out of the money so we are only looking at extrinsic value
double callOption1Strike = forwardCurve[callOption1Date];
double callOption2Strike = forwardCurve[callOption2Date] + 2.0;
double callOption3Strike = forwardCurve[callOption3Date] + 2.8;
var injectWithdrawConstraints = new List <InjectWithdrawRangeByInventoryAndPeriod <Day> >
{
(period : storageStart, injectWithdrawRanges : new List <InjectWithdrawRangeByInventory>
{
(inventory : 0.0, (minInjectWithdrawRate : 0.0, maxInjectWithdrawRate : 0.0)),
(inventory : storageStartingInventory, (minInjectWithdrawRate : 0.0, maxInjectWithdrawRate : 0.0)),
}),
public void Deconstruct(out double storageNpv, out DoubleTimeSeries <T> decisionProfile, out DoubleTimeSeries <T> cmdtyVolumeConsumed)
{
storageNpv = StorageNpv;
decisionProfile = DecisionProfile;
cmdtyVolumeConsumed = CmdtyVolumeConsumed;
}
