public void TestEMA()
{
long ticks = 1000;
var data = new double[] { 20, 40, 22, 35, 33, 78, 21, 45, 33, 5, 67, 22, 98, 22, 34, 54 };
var input = new TimeSeries();
var ema = new EMA(input, 10);
foreach (var d in data)
input.Add(new DateTime().AddTicks(ticks++), d);
for (var i = 0; i < ema.Count; i++)
output.WriteLine(ema[i].ToString());
Assert.Equal(ema[0], 20, precision);
Assert.Equal(ema[1], 23.6363636363636, precision);
Assert.Equal(ema[2], 23.3388429752066, precision);
Assert.Equal(ema[3], 25.4590533433509, precision);
Assert.Equal(ema[4], 26.8301345536507, precision);
Assert.Equal(ema[5], 36.1337464529869, precision);
Assert.Equal(ema[6], 33.3821561888075, precision);
Assert.Equal(ema[7], 35.4944914272061, precision);
Assert.Equal(ema[8], 35.0409475313505, precision);
Assert.Equal(ema[9], 29.5789570711049, precision);
Assert.Equal(ema[10], 36.3827830581768, precision);
Assert.Equal(ema[11], 33.7677315930537, precision);
Assert.Equal(ema[12], 45.4463258488621, precision);
Assert.Equal(ema[13], 41.1833575127054, precision);
Assert.Equal(ema[14], 39.8772925103953, precision);
Assert.Equal(ema[15], 42.4450575085053, precision);
}
public TimeDecayLinear(decimal linearDecay, TimeSpan mobilePeriodLength)
: base(mobilePeriodLength)
{
_startCoeff = 2m / (1m + linearDecay);
_endCoeff = 2m - _startCoeff;
_timeDecayWeight = new TimeSeries();
}
public static double GetRegularTimeStepLengthDays(TimeSeries ts)
{
var t = ts.timeStep as EvenTimeStep;
if (t == null)
return -1;
return t.span.TotalDays;
}
public static TimeSeriesComplexType FromTimeSeries(TimeSeries ts,string forcedTimeStamp)
{
TimeSeriesComplexType result = new TimeSeriesComplexType( );
string locationName = LocationName(ts.name);
result.header = new HeaderComplexType
{
type = timeSeriesType.mean,
locationId = locationName,
//stationName = locationName,
startDate = new DateTimeComplexType {DateTime = MergeDT(ts.Start,forcedTimeStamp)},
endDate = new DateTimeComplexType {DateTime = MergeDT(ts.End,forcedTimeStamp)},
missVal = ts.NullValue,
units = PIUnits(ts),
timeStep = PITimeStep(ts.timeStep),
parameterId = ParameterName(ts.name)
};
IList<EventComplexType> events = new List<EventComplexType>();
for (int i = 0; i < ts.count(); i++)
{
var fewsDT = new DateTimeComplexType {DateTime = MergeDT(ts.timeForItem(i),forcedTimeStamp)};
events.Add( new EventComplexType
{
date = fewsDT.date,
time = fewsDT.time,
flag = 2,
flagSpecified = true,
value = ts[i]
});
}
result.@event = events.ToArray();
return result;
}
public override void OnStrategyStart()
{
series = new BarSeries();
if (VolatilityExitEnabled || VolatilityBarrierEnabled)
{
rangeSeries = new TimeSeries();
rangeSMA = new SMA(rangeSeries, VolatilitySMALength);
}
if (TickBarrierEnabled)
barrier = TickSize * BarrierSize;
lowestLowSeries = new TimeSeries();
highestHighSeries = new TimeSeries();
channelLowSeries = new TimeSeries();
channelHighSeries = new TimeSeries();
lowestLowSeries .Color = Color.Blue;
highestHighSeries.Color = Color.Blue;
channelLowSeries .Color = Color.Brown;
channelHighSeries.Color = Color.Brown;
Draw(lowestLowSeries , 0);
Draw(highestHighSeries, 0);
Draw(channelLowSeries , 0);
Draw(channelHighSeries, 0);
}
public TimeSeries<string> historySeries(DateTime sDate, DateTime eDate )
{
TimeSeries<string> hist = new TimeSeries<string>();
INDEX_DATA_Table_DAOManager dao_m = new INDEX_DATA_Table_DAOManager();
dao_m.INDEX_CODE_ = this.Code_;
dao_m.selectInterval(DataBaseConnectManager.ConnectionFactory("myDB"),sDate,eDate);
foreach (var item in dao_m.DAOList_)
{
string date = item.INDEX_DATE_;
int year = Convert.ToInt32(date.Substring(0, 4));
int month = Convert.ToInt32(date.Substring(4, 2));
int day = Convert.ToInt32(date.Substring(6, 2));
string value = item.INDEX_VALUE_;
hist.Add(new Date(new DateTime(year,month, day)), value);
}
return hist;
}
public Model()
{
ts = null;
seasonal = null;
values = null;
errors = null;
}
public ListItem(TimeSeries ts, int resultNo, double error, bool showIndex = false)
{
ResultNo = resultNo;
TimeSeriesData = ts;
Error = error;
ShowIndex = showIndex;
Render(ts);
}
public EWV(ISeries input, double length, double initValue = 0) : base(input)
{
Length = length;
InitValue = initValue;
this.ewm_0 = new EWM(input, length);
this.ewm_0.AutoUpdate = false;
this.timeSeries_0 = new TimeSeries();
this.ewm_1 = new EWM(this.timeSeries_0, length);
}
protected override void Init()
{
this.name = $"PDI ({this.length})";
this.description = "Plus Directional Indicator";
Clear();
this.calculate = true;
this.pdmTS = new TimeSeries();
this.trTS = new TimeSeries();
}
protected override void Init()
{
this.name = $"DX ({this.length})";
this.description = "Directional Movement Index";
Clear();
this.calculate = true;
this.pdmTS = new TimeSeries();
this.mdmTS = new TimeSeries();
}
protected override void Init()
{
this.name = "MDI (" + this.length + ")";
this.description = "Minus Directional Indicator";
base.Clear();
this.calculate = true;
this.mdmTS = new TimeSeries();
this.trTS = new TimeSeries();
}
public void addFixings(List<Date> d, List<double> v, bool forceOverwrite) {
if ((d.Count != v.Count) || d.Count == 0)
throw new ArgumentException("Wrong collection dimensions when creating index fixings");
TimeSeries<double> t = new TimeSeries<double>();
for(int i=0; i<d.Count; i++)
t.Add(d[i], v[i]);
addFixings(t, forceOverwrite);
}
public TimeSeriesComparison(TimeSeries ts1, TimeSeries ts2, double start, double end, double error)
{
Ts1 = ts1;
Ts2 = ts2;
Error = error;
IsPruned = true;
Start = start;
End = end;
}
public static double Value(ISeries input, int index, int length1, int length2)
{
if (index >= length1 - 1 && index >= length2 - 1)
{
var ts = new TimeSeries();
for (var i = index - Math.Max(length1, length2) + 1; i <= index; i++)
ts.Add(input.GetDateTime(i), input[i, BarData.Volume]);
return SMA.Value(ts, length1 - 1, length1) - SMA.Value(ts, length2 - 1, length2);
}
return double.NaN;
}
protected override void Init()
{
this.name = this.input is BarSeries
? $"RSI ({this.length}, {this.barData})"
: $"RSI ({this.length})";
this.description = "Relative Strength Index";
Clear();
this.calculate = true;
this.upTS = new TimeSeries();
this.downTS = new TimeSeries();
}
public static double Value(ISeries input, int index, int length1, int length2)
{
if (index >= length2 - 1)
{
var ts = new TimeSeries();
for (var i = 0; i <= index; i++)
ts.Add(input.GetDateTime(i), input[i, BarData.High] - input[i, BarData.Low]);
var ema = new EMA(ts, length1);
return (ema[index] - ema[index - length2 + 1])/ema[index - length2 + 1]*100;
}
return double.NaN;
}
protected override void Init()
{
this.name = $"VCH ({this.length1}, {this.length2})";
this.description = "Chaikin Volatility";
Clear();
this.calculate = true;
this.hlTS = new TimeSeries();
for (var i = 0; i < this.input.Count; i++)
this.hlTS.Add(this.input.GetDateTime(i), this.input[i, BarData.High] - this.input[i, BarData.Low]);
this.ema = new EMA(this.hlTS, this.length1);
}
public static TimeSeriesLink BuildLink(TimeSeries ts, ProjectViewRow row, AttributeRecordingState key, int runNumber)
{
return new TimeSeriesLink
{
TimeSeriesName = ts.name,
RunNumber = runNumber,
TimeSeriesUrl = BuildTimeSeriesUrl(row,key, runNumber),
NetworkElement = row.NetworkElementName,
RecordingElement = row.ElementName,
RecordingVariable = SelectRecordingVariable(key, row)
};
}
public EstimationResult Estimate(IEnumerable<IDateValue> dateValues)
{
var series = new TimeSeries();
dateValues.ForEach(x => series.Add(x.Date, x.Value, true));
armaModel.SetInput(0, series, null);
armaModel.FitByMLE(200, 100, 0, null);
armaModel.ComputeResidualsAndOutputs();
var result = armaModel.GetOutput(3) as TimeSeries;
return EstimationResult.Create(result[0], this);
}
public ListItem(TimeSeries ts, bool isPruned, double highlightStart, double highlightEnd,
int resultNo, double error, bool showIndex = false)
{
ResultNo = resultNo;
TimeSeriesData = ts;
Error = error;
IsPruned = isPruned;
HighlightStart = highlightStart;
HighlightEnd = highlightEnd;
ShowIndex = showIndex;
Render(ts);
}
public static bool TestTimeSeries(TimeSeries ts, double[] expValues, string expTimeStep, DateTime expectedStart)
{
var tsv = ts.ToArray();
if (tsv.Length != expValues.Length) return false;
for (int i = 0; i < tsv.Length; i++)
if (isDifferent(tsv[i], expValues[i])) return false;
if (ts.timeStep.ToString() != expTimeStep)
return false;
// TODO: even for a constructed time series with a start date with kind Utc specified, the time series property
// ends up with a start date time of kind Unspecified. Very curious; may be a TIME 'issue
// if (ts.Start != expectedStart) return false;
return true;
}
public TimeSeries GetResampled(TimeSeries timeSeriesData, int numSamples)
{
var kv = new TimeSeriesSamplingRatePair(timeSeriesData, numSamples);
if (StockTimeSeries.ContainsKey(kv))
{
return StockTimeSeries[kv];
}
var ts = new TimeSeries(timeSeriesData.Values);
TimeSeries resampled = ts.GetResampled(numSamples);
StockTimeSeries.Add(kv, resampled);
return resampled;
}
public static double Value(ISeries input, int index, int length, int order)
{
if (index >= length - 1)
{
var ts = new TimeSeries();
for (int i = 0; i <= index; i++)
ts.Add(input.GetDateTime(i), input[i, BarData.High] - input[i, BarData.Low]);
var ema = new EMA(ts, order);
var ema_ema = new EMA(ema, order);
return Enumerable.Range(index - length + 1, length).Reverse().Sum(i => ema[i]/ema_ema[i]);
}
return double.NaN;
}
public static double Value(ISeries input, int index, int length1, int length2)
{
if (index >= length2 - 1)
{
TimeSeries timeSeries = new TimeSeries();
for (int i = 0; i <= index; i++)
{
timeSeries.Add(input.GetDateTime(i), input[i, BarData.High] - input[i, BarData.Low]);
}
EMA eMA = new EMA(timeSeries, length1, BarData.Close);
return (eMA[index] - eMA[index - length2 + 1]) / eMA[index - length2 + 1] * 100.0;
}
return double.NaN;
}
protected override void Init()
{
this.name = $"MASS ({this.length}, {this.order})";
this.description = "Mass Index";
Clear();
this.calculate = true;
this.hlTS = new TimeSeries();
for (var i = 0; i < this.input.Count; i++)
this.hlTS.Add(this.input.GetDateTime(i), this.input[i, BarData.High] - this.input[i, BarData.Low]);
Detach();
this.ema = new EMA(this.hlTS, this.order);
this.ema_ema = new EMA(this.ema, this.order);
Attach();
}
public static double Value(ISeries input, int index, int length1, int length2)
{
if (index >= length1 - 1 && index >= length2 - 1)
{
TimeSeries timeSeries = new TimeSeries();
for (int i = index - Math.Max(length1, length2) + 1; i <= index; i++)
{
timeSeries.Add(input.GetDateTime(i), input[i, BarData.Volume]);
}
double num = SMA.Value(timeSeries, length1 - 1, length1, BarData.Close);
double num2 = SMA.Value(timeSeries, length2 - 1, length2, BarData.Close);
return num - num2;
}
return double.NaN;
}
public static TimeSeries CreateWaterLevelTimeSeries()
{
var ts = new TimeSeries
{
Components = {new Variable<double>("level", new Unit("m AD", "m AD"))},
Name = "water level time series"
};
ts.Components[0].Attributes[FunctionAttributes.StandardName] = FunctionAttributes.StandardNames.WaterLevel;
var variable = ts.Arguments.First();
variable.DefaultValue = new DateTime(2000, 1, 1);
variable.InterpolationType = InterpolationType.Linear;
variable.ExtrapolationType = ExtrapolationType.Constant;
return ts;
}
public void TestWMA()
{
long ticks = 1000;
var data = new double[] { 20, 40, 22, 35, 33, 78, 21, 45, 33, 5, 67, 22, 98, 22, 34, 54 };
var input = new TimeSeries();
var wma = new WMA(input, 10);
foreach (var d in data)
input.Add(new DateTime().AddTicks(ticks++), d);
Assert.Equal(wma[0], 32.6, precision);
Assert.Equal(wma[1], 38.7454545454545, precision);
Assert.Equal(wma[2], 35.8545454545455, precision);
Assert.Equal(wma[3], 47.1090909090909, precision);
Assert.Equal(wma[4], 43.1636363636364, precision);
Assert.Equal(wma[5], 41.6363636363636, precision);
Assert.Equal(wma[6], 43.7272727272727, precision);
}
public SimpleTimeSeries(TimeSeries source):base(source)
{
if (source == null)
{
Events = new TimeSeriesEvent[0];
return;
}
IList<TimeSeriesEvent> eventList = new List<TimeSeriesEvent>();
for (int i = 0; i < source.count(); i++)
eventList.Add(new TimeSeriesEvent
{
Date = source.timeForItem(i).ToString(CultureInfo.InvariantCulture),
Value = source[i]
});
Events = eventList.ToArray();
}
public TimeSeries GetPriceReturnTimeSeries()
{
TimeSeries last_ts = this.GetTimeSeries(TimeSeriesType.Close);
if (last_ts == null || last_ts.Count == 0)
{
return(null);
}
int count = last_ts.Count;
DateTime lastDate = last_ts.DateTimes[count - 1];
if (_prDB.ContainsKey(lastDate))
{
return(_prDB[lastDate]);
}
TimeSeries tr_ts = new TimeSeries(1);
tr_ts.AddDataPoint(last_ts.DateTimes[0], last_ts[0]);
for (int i = 1; i < count; i++)
{
DateTime date = last_ts.DateTimes[i];
DateTime date_1 = last_ts.DateTimes[i - 1];
double value = last_ts[i];
double value_1 = last_ts[i - 1];
//var corps = this.CorporateActions(date_1.Date);
var corps = this.CorporateActions(date.Date);
if (corps != null)
{
foreach (CorporateAction corp in corps)
{
//Console.WriteLine(corp);
double amount = corp.Amount;
if (corp.Type != "Stock Split" && corp.Type != "Scrip" && corp.Type != "Spinoff")
{
value += amount * 0;// No Dividend Reinvestment
}
else if (corp.Type == "Spinoff" && corp.Amount != 1.0)
{
value /= 1 - amount;
}
else if (corp.Type == "Stock Split")
{
value *= amount;
}
else if (corp.Type == "Scrip" && corp.Amount != 0.0)
{
value /= amount;
}
}
}
double v_1 = tr_ts[i - 1];
double v = v_1 * (value / value_1);
tr_ts.AddDataPoint(date, v);
}
double scale = last_ts[count - 1] / tr_ts[count - 1];
tr_ts *= scale;
_prDB.TryAdd(lastDate, tr_ts);
return(tr_ts);
}
public TimeSeries GetTotalReturnTimeSeries()
{
TimeSeries last_ts = this.GetTimeSeries(TimeSeriesType.Close);
if (last_ts == null || last_ts.Count == 0)
{
return(null);
}
int count = last_ts.Count;
DateTime lastDate = last_ts.DateTimes[count - 1];
if (_trDB.ContainsKey(lastDate))
{
return(_trDB[lastDate]);
}
TimeSeries tr_ts = new TimeSeries(1);
tr_ts.AddDataPoint(last_ts.DateTimes[0], last_ts[0]);
var all_corps = this.CorporateActions();
for (int i = 1; i < count; i++)
{
DateTime date = last_ts.DateTimes[i];
DateTime date_1 = last_ts.DateTimes[i - 1];
double value = last_ts[i];
double value_1 = last_ts[i - 1];
double adjustment = 1.0;
foreach (CorporateAction c in all_corps)
{
if (c.ExDate >= date.Date)
{
if (c.Type == "Stock Split")
{
adjustment *= c.Amount;
}
else if (c.Type == "Scrip" && c.Amount != 0.0)
{
adjustment /= c.Amount;
}
else if (c.Type == "Spinoff" && c.Amount != 1.0)
{
adjustment /= 1 - c.Amount;
}
}
}
var corps = this.CorporateActions(date.Date);
if (corps != null)
{
foreach (CorporateAction corp in corps)
{
double amount = corp.Amount;
if (corp.Type != "Stock Split" && corp.Type != "Scrip" && corp.Type != "Spinoff")// && corp.Type != "Rights Issue")
{
value += amount * adjustment;
}
else if (corp.Type == "Spinoff" && corp.Amount != 1.0)
{
value /= 1 - amount;
}
else if (corp.Type == "Stock Split")
{
value *= amount;
}
else if (corp.Type == "Scrip" && corp.Amount != 0.0)
{
value /= amount;
}
}
}
double v_1 = tr_ts[i - 1];
double v = v_1 * (value / value_1);
tr_ts.AddDataPoint(date, v);
}
double scale = last_ts[count - 1] / tr_ts[count - 1];
tr_ts *= scale;
_trDB.TryAdd(lastDate, tr_ts);
return(tr_ts);
}
public void Draw()
{
UltiDraw.Begin();
//DEBUG RENDERING
// {
// float _xMin = 0.025f;
// float _xMax = 0.25f;
// float _yMin = 0.05f;
// float _yMax = 0.25f;
// for(int b=0; b<Bones.Length; b++) {
// float w = (float)b/(float)(Bones.Length-1);
// List<float[]> values = new List<float[]>();
// float max = 0f;
// float[] first = new float[TimeSeries.FutureKeyCount+1];
// float[] second = new float[TimeSeries.FutureKeyCount+1];
// float[] third = new float[TimeSeries.FutureKeyCount+1];
// for(int i=0; i<TimeSeries.FutureKeyCount+1; i++) {
// first[i] = _PhaseMagnitudes[TimeSeries.GetKey(i+TimeSeries.PivotKey).Index][b];
// second[i] = _PhaseStates[TimeSeries.GetKey(i+TimeSeries.PivotKey).Index][b].magnitude;
// third[i] = _PhaseUpdateVectors[TimeSeries.GetKey(i+TimeSeries.PivotKey).Index][b].magnitude;
// max = Mathf.Max(max, first[i], second[i], third[i]);
// }
// values.Add(first);
// values.Add(second);
// values.Add(third);
// float vertical = Utility.Normalise(w, 0f, 1f, _yMin, _yMax);
// float height = 0.95f*(_yMax-_yMin)/(Bones.Length-1);
// UltiDraw.DrawGUIFunctions(new Vector2(0.5f * (_xMin + _xMax), vertical), new Vector2(_xMax-_xMin, height), values, 0f, max, UltiDraw.DarkGrey, new Color[3]{Color.yellow, Color.magenta, Color.cyan});
// }
// }
// {
// float _xMin = 0.025f;
// float _xMax = 0.25f;
// float _yMin = 0.3f;
// float _yMax = 0.5f;
// for(int b=0; b<Bones.Length; b++) {
// float w = (float)b/(float)(Bones.Length-1);
// List<float[]> values = new List<float[]>();
// float[] first = new float[TimeSeries.FutureKeyCount+1];
// float[] second = new float[TimeSeries.FutureKeyCount+1];
// for(int i=0; i<TimeSeries.FutureKeyCount+1; i++) {
// first[i] = _PhaseUpdateValues[TimeSeries.GetKey(i+TimeSeries.PivotKey).Index][b];
// second[i] = Utility.PhaseUpdate(0f, Utility.PhaseValue(_PhaseUpdateVectors[TimeSeries.GetKey(i+TimeSeries.PivotKey).Index][b]));
// }
// values.Add(first);
// values.Add(second);
// float vertical = Utility.Normalise(w, 0f, 1f, _yMin, _yMax);
// float height = 0.95f*(_yMax-_yMin)/(Bones.Length-1);
// UltiDraw.DrawGUIFunctions(new Vector2(0.5f * (_xMin + _xMax), vertical), new Vector2(_xMax-_xMin, height), values, 0f, 0.1f, UltiDraw.DarkGrey, new Color[2]{Color.yellow, Color.magenta});
// }
// }
//
float xMin = 0.3f;
float xMax = 0.7f;
float yMin = 0.75f;
float yMax = 0.95f;
//This is phase vector rendering
for (int b = 0; b < Bones.Length; b++)
{
float w = (float)b / (float)(Bones.Length - 1);
float[] values = new float[TimeSeries.KeyCount];
Color[] colors = new Color[TimeSeries.KeyCount];
for (int i = 0; i < TimeSeries.KeyCount; i++)
{
values[i] = Phases[TimeSeries.GetKey(i).Index][b];
colors[i] = UltiDraw.White.Transparent(Magnitudes[TimeSeries.GetKey(i).Index][b]);
}
float vertical = Utility.Normalise(w, 0f, 1f, yMin, yMax);
float height = 0.95f * (yMax - yMin) / (Bones.Length - 1);
UltiDraw.DrawGUIBars(new Vector2(0.5f * (xMin + xMax), vertical), new Vector2(xMax - xMin, height), values, 1f, 1f, 0.01f, UltiDraw.DarkGrey, Color.white);
// UltiDraw.DrawGUICircularPivot(new Vector2(xMax + height/2f, vertical), height/2f, UltiDraw.DarkGrey, 360f*Phases[TimeSeries.Pivot][b], 1f, colors[TimeSeries.PivotKey]);
UltiDraw.DrawGUICircularPivot(new Vector2(xMax + height / 2f, vertical), height / 2f, UltiDraw.DarkGrey, 360f * Phases[TimeSeries.Pivot][b], Magnitudes[TimeSeries.Pivot][b], colors[TimeSeries.PivotKey]);
for (int i = 0; i < TimeSeries.KeyCount; i++)
{
float horizontal = Utility.Normalise((float)i / (float)(TimeSeries.KeyCount - 1), 0f, 1f, xMin, xMax);
// UltiDraw.DrawGUICircularPivot(new Vector2(horizontal, vertical + height/4f), height/4f, UltiDraw.DarkGrey, 360f*Phases[TimeSeries.GetKey(i).Index][b], 1f, colors[i]);
UltiDraw.DrawGUICircularPivot(new Vector2(horizontal, vertical + height / 4f), height / 4f, UltiDraw.DarkGrey, 360f * Utility.PhaseUpdate(Phases[TimeSeries.Pivot][b], Phases[TimeSeries.GetKey(i).Index][b]), 1f, colors[i]);
// UltiDraw.DrawGUICircularPivot(new Vector2(horizontal, vertical + height/4f), height/4f, UltiDraw.DarkGrey, 360f*Values[TimeSeries.GetKey(i).Index][b], 1f, UltiDraw.Cyan);
// Vector2 phase = Utility.PhaseVectorUpdate(Vectors[TimeSeries.Pivot][b], Vectors[TimeSeries.GetKey(i).Index][b]);
// UltiDraw.DrawGUICircularPivot(new Vector2(horizontal, vertical + height/4f), height/4f, UltiDraw.DarkGrey, -Vector2.SignedAngle(Vector2.up, phase), 1f, colors[i]);
}
}
// //This is phase rendering
// for(int b=0; b<Bones.Length; b++) {
// float w = (float)b/(float)(Bones.Length-1);
// float[] values = new float[TimeSeries.KeyCount];
// Color[] colors = new Color[TimeSeries.KeyCount];
// for(int i=0; i<TimeSeries.KeyCount; i++) {
// values[i] = Values[TimeSeries.GetKey(i).Index][b];
// colors[i] = UltiDraw.White.Transparent(Mathf.Clamp(Magnitudes[TimeSeries.GetKey(i).Index][b], 0f, 1f));
// }
// float vertical = Utility.Normalise(w, 0f, 1f, yMin, yMax);
// float height = 0.95f*(yMax-yMin)/(Bones.Length-1);
// UltiDraw.DrawGUIBars(new Vector2(0.5f * (xMin + xMax), vertical), new Vector2(xMax-xMin, height), values, 01f, 1f, 0.01f, UltiDraw.DarkGrey, colors);
// UltiDraw.DrawGUICircularPivot(new Vector2(xMax + height/2f, vertical), height/2f, UltiDraw.DarkGrey, 360f*Values[TimeSeries.Pivot][b], 1f, UltiDraw.Cyan);
// }
//This is energy rendering
// for(int b=0; b<Bones.Length; b++) {
// float w = (float)b/(float)(Bones.Length-1);
// float[] values = new float[TimeSeries.KeyCount];
// Color[] colors = new Color[TimeSeries.KeyCount];
// for(int i=0; i<TimeSeries.KeyCount; i++) {
// values[i] = 1f;
// float weight = Vector2.Angle(Vector2.up, Utility.PhaseVector(Values[TimeSeries.GetKey(i).Index][b])) / 180f;
// colors[i] = Color.Lerp(UltiDraw.Cyan, UltiDraw.Orange, weight).Transparent(Mathf.Clamp(Magnitudes[TimeSeries.GetKey(i).Index][b], 0f, 1f));
// }
// float vertical = Utility.Normalise(w, 0f, 1f, yMin, yMax);
// float height = 0.95f*(yMax-yMin)/(Bones.Length-1);
// UltiDraw.DrawGUIBars(new Vector2(0.5f * (xMin + xMax), vertical), new Vector2(xMax-xMin, height), values, 01f, 1f, 0.01f, UltiDraw.DarkGrey, colors);
// UltiDraw.DrawGUICircle(new Vector2(xMax + height/2f, vertical), height/2f, colors[TimeSeries.PivotKey]);
// }
{
float max = 0f;
List <float[]> values = new List <float[]>();
for (int b = 0; b < Bones.Length; b++)
{
float[] v = new float[TimeSeries.KeyCount];
for (int i = 0; i < TimeSeries.KeyCount; i++)
{
v[i] = Magnitudes[TimeSeries.GetKey(i).Index][b];
max = Mathf.Max(max, v[i]);
}
values.Add(v);
}
float vertical = yMin - 1f * (yMax - yMin) / (Bones.Length - 1);
float height = 0.95f * (yMax - yMin) / (Bones.Length - 1);
UltiDraw.DrawGUIFunctions(new Vector2(0.5f * (xMin + xMax), vertical), new Vector2(xMax - xMin, height), values, 0f, Mathf.Max(1f, max), UltiDraw.DarkGrey, UltiDraw.GetRainbowColors(values.Count));
}
//This is vector rendering
// for(int b=0; b<Bones.Length; b++) {
// float w = (float)b/(float)(Bones.Length-1);
// float[] values = new float[TimeSeries.KeyCount];
// Color[] colors = new Color[TimeSeries.KeyCount];
// for(int i=0; i<TimeSeries.KeyCount; i++) {
// values[i] = Utility.PhaseValue(Vectors[TimeSeries.GetKey(i).Index][b]);
// colors[i] = UltiDraw.White.Transparent(Mathf.Clamp(Vectors[TimeSeries.GetKey(i).Index][b].magnitude, 0f, 1f));
// }
// float vertical = Utility.Normalise(w, 0f, 1f, yMin, yMax);
// float height = 0.95f*(yMax-yMin)/(Bones.Length-1);
// UltiDraw.DrawGUIBars(new Vector2(0.5f * (xMin + xMax), vertical), new Vector2(xMax-xMin, height), values, 01f, 1f, 0.01f, UltiDraw.DarkGrey, colors);
// UltiDraw.DrawGUICircularPivot(new Vector2(xMax + height/2f, vertical), height/2f, UltiDraw.DarkGrey, 360f*Utility.PhaseValue(Vectors[TimeSeries.Pivot][b]), 1f, UltiDraw.Cyan);
// }
// {
// float max = 0f;
// List<float[]> values = new List<float[]>();
// for(int b=0; b<Bones.Length; b++) {
// float[] v = new float[TimeSeries.KeyCount];
// for(int i=0; i<TimeSeries.KeyCount; i++) {
// v[i] = Vectors[TimeSeries.GetKey(i).Index][b].magnitude;
// max = Mathf.Max(max, v[i]);
// }
// values.Add(v);
// }
// float vertical = yMin - 1*(yMax-yMin)/(Bones.Length-1);
// float height = 0.95f*(yMax-yMin)/(Bones.Length-1);
// UltiDraw.DrawGUIFunctions(new Vector2(0.5f * (xMin + xMax), vertical), new Vector2(xMax-xMin, height), values, 0f, Mathf.Max(2f, max), UltiDraw.DarkGrey, UltiDraw.GetRainbowColors(values.Count));
// }
// {
// List<float[]> values = new List<float[]>();
// for(int b=0; b<Bones.Length; b++) {
// float[] v = new float[TimeSeries.KeyCount];
// for(int i=0; i<TimeSeries.KeyCount; i++) {
// v[i] = Frequencies[TimeSeries.GetKey(i).Index][b];
// }
// values.Add(v);
// }
// float vertical = yMin - 2*(yMax-yMin)/(Bones.Length-1);
// float height = 0.95f*(yMax-yMin)/(Bones.Length-1);
// UltiDraw.DrawGUIFunctions(new Vector2(0.5f * (xMin + xMax), vertical), new Vector2(xMax-xMin, height), values, 0f, Mathf.Max(0.5f, 2.5f), UltiDraw.DarkGrey, UltiDraw.GetRainbowColors(values.Count));
// }
// {
// float[] combination = new float[TimeSeries.KeyCount];
// for(int i=0; i<TimeSeries.KeyCount; i++) {
// combination[i] = GetAveragePhase(TimeSeries.GetKey(i).Index);
// }
// float vertical = yMin - 2f*(yMax-yMin)/(Bones.Length-1);
// float height = 0.95f*(yMax-yMin)/(Bones.Length-1);
// UltiDraw.DrawGUIBars(new Vector2(0.5f * (xMin + xMax), vertical), new Vector2(xMax-xMin, height), combination, 01f, 1f, 0.01f, UltiDraw.DarkGrey, UltiDraw.Red);
// UltiDraw.DrawGUICircularPivot(new Vector2(xMax + height/2f, vertical), height/2f, UltiDraw.DarkGrey, 360f*combination[TimeSeries.PivotKey], 1f, UltiDraw.DarkRed);
// }
/*
* for(int i=0; i<Values.Length; i++) {
* float min = 0.1f;
* float max = 0.9f;
* float size = 1f * (max-min) / Values.Length;
* float w = (float)i/(float)(Values.Length-1);
* Vector2 center = new Vector2(Utility.Normalise(w, 0f, 1f, min, max), 0.1f);
* UltiDraw.DrawGUICircularPivot(center, size, UltiDraw.DarkGrey, Values[i] * 360f, 1f, UltiDraw.Cyan);
* }
*
* for(int i=0; i<Values.Length; i++) {
* float min = 0.1f;
* float max = 0.9f;
* float size = 1f * (max-min) / Values.Length;
* float w = (float)i/(float)(Values.Length-1);
* Vector2 center = new Vector2(Utility.Normalise(w, 0f, 1f, min, max), 0.1f);
* //UltiDraw.DrawGUICircularPivot(center, size, UltiDraw.DarkGrey, -Vector2.SignedAngle(Vector2.up, Vectors[i]), 1f, UltiDraw.Cyan);
* }
*/
//UltiDraw.DrawGUIBars(new Vector2(0.875f, 0.510f), new Vector2(0.2f, 0.1f), Values, 01f, 1f, 0.01f, UltiDraw.DarkGrey, UltiDraw.White);
UltiDraw.End();
}
public async Task CanIncludeTypedTimeSeries_Rollup()
{
using (var store = GetDocumentStore())
{
var raw = new RawTimeSeriesPolicy(TimeSpan.FromHours(24));
var p1 = new TimeSeriesPolicy("By6Hours", TimeSpan.FromHours(6), raw.RetentionTime * 4);
var p2 = new TimeSeriesPolicy("By1Day", TimeSpan.FromDays(1), raw.RetentionTime * 5);
var p3 = new TimeSeriesPolicy("By30Minutes", TimeSpan.FromMinutes(30), raw.RetentionTime * 2);
var p4 = new TimeSeriesPolicy("By1Hour", TimeSpan.FromMinutes(60), raw.RetentionTime * 3);
var config = new TimeSeriesConfiguration
{
Collections = new Dictionary <string, TimeSeriesCollectionConfiguration>
{
["Users"] = new TimeSeriesCollectionConfiguration
{
RawPolicy = raw,
Policies = new List <TimeSeriesPolicy>
{
p1, p2, p3, p4
}
},
},
PolicyCheckFrequency = TimeSpan.FromSeconds(1)
};
await store.Maintenance.SendAsync(new ConfigureTimeSeriesOperation(config));
await store.TimeSeries.RegisterAsync <User, StockPrice>();
var database = await Databases.GetDocumentDatabaseInstanceFor(store);
var now = DateTime.UtcNow;
var nowMinutes = now.Minute;
now = now.AddMinutes(-nowMinutes);
database.Time.UtcDateTime = () => DateTime.UtcNow.AddMinutes(-nowMinutes);
var baseline = now.AddDays(-12);
var total = TimeSpan.FromDays(12).TotalMinutes;
using (var session = store.OpenSession())
{
session.Store(new User {
Name = "Karmel"
}, "users/karmel");
var ts = session.TimeSeriesFor <StockPrice>("users/karmel");
var entry = new StockPrice();
for (int i = 0; i <= total; i++)
{
entry.Open = i;
entry.Close = i + 100_000;
entry.High = i + 200_000;
entry.Low = i + 300_000;
entry.Volume = i + 400_000;
ts.Append(baseline.AddMinutes(i), entry, "watches/fitbit");
}
session.SaveChanges();
}
await database.TimeSeriesPolicyRunner.RunRollups();
await database.TimeSeriesPolicyRunner.DoRetention();
await TimeSeries.VerifyPolicyExecutionAsync(store, config.Collections["Users"], 12, rawName : "StockPrices");
using (var session = store.OpenSession())
{
var user = session.Query <User>()
.Include(x => x.IncludeTimeSeries($"StockPrices@{p1.Name}"))
.First();
// should not go to server
var ts = session.TimeSeriesRollupFor <StockPrice>(user.Id, p1.Name);
var res = ts.Get().ToList();
Assert.Equal(16, res.Count);
Assert.Equal(1, session.Advanced.NumberOfRequests);
}
}
}
//Ingore this function
public override TimeSeries ExtractSeries(MotionEditor editor, TimeSeries timeSeries = null)
{
return(null);
}
public R(TimeSeries series, int length, Color color)
{
this.indicator = new SmartQuant.Indicators.R(series.series, length, color);
}
public DirectionalIndicatorMaxValueProvider(TimeSeries diPlus, TimeSeries diMinus)
{
this.diPlus = diPlus;
this.diMinus = diMinus;
}
public void CalculateInventorySpace_CurrentPeriodBeforeStorageStartPeriod_AsExpected()
{
const double injectionRate = 5.0;
const double withdrawalRate = 6.0;
const double startingInventory = 11.0;
const double inventoryPercentLoss = 0.03;
const double minInventory = 0.0;
const double maxInventory = 23.5;
var storageStart = new Day(2019, 8, 19);
var storageEnd = new Day(2019, 8, 28);
var currentPeriod = new Day(2019, 8, 10);
var storage = CmdtyStorage <Day> .Builder
.WithActiveTimePeriod(storageStart, storageEnd)
.WithConstantInjectWithdrawRange(-withdrawalRate, injectionRate)
.WithConstantMinInventory(minInventory)
.WithConstantMaxInventory(maxInventory)
.WithPerUnitInjectionCost(1.5)
.WithNoCmdtyConsumedOnInject()
.WithPerUnitWithdrawalCost(0.8)
.WithNoCmdtyConsumedOnWithdraw()
.WithFixedPercentCmdtyInventoryLoss(inventoryPercentLoss)
.WithNoInventoryCost()
.MustBeEmptyAtEnd()
.Build();
TimeSeries <Day, InventoryRange> inventorySpace =
StorageHelper.CalculateInventorySpace(storage, startingInventory, currentPeriod);
int expectedInventorySpaceCount = storageEnd.OffsetFrom(storageStart);
Assert.Equal(expectedInventorySpaceCount, inventorySpace.Count);
double expectedInventoryLower = startingInventory * (1 - inventoryPercentLoss) - withdrawalRate;
double expectedInventoryUpper = startingInventory * (1 - inventoryPercentLoss) + injectionRate;
AssertInventoryRangeEqualsExpected(inventorySpace[new Day(2019, 8, 20)], expectedInventoryLower, expectedInventoryUpper);
expectedInventoryLower = Math.Max(expectedInventoryLower * (1 - inventoryPercentLoss) - withdrawalRate, minInventory);
expectedInventoryUpper = Math.Min(expectedInventoryUpper * (1 - inventoryPercentLoss) + injectionRate, maxInventory);
AssertInventoryRangeEqualsExpected(inventorySpace[new Day(2019, 8, 21)], expectedInventoryLower, expectedInventoryUpper);
expectedInventoryLower = Math.Max(expectedInventoryLower * (1 - inventoryPercentLoss) - withdrawalRate, minInventory);
expectedInventoryUpper = Math.Min(expectedInventoryUpper * (1 - inventoryPercentLoss) + injectionRate, maxInventory);
AssertInventoryRangeEqualsExpected(inventorySpace[new Day(2019, 8, 22)], expectedInventoryLower, expectedInventoryUpper);
expectedInventoryLower = Math.Max(expectedInventoryLower * (1 - inventoryPercentLoss) - withdrawalRate, minInventory);
expectedInventoryUpper = Math.Min(expectedInventoryUpper * (1 - inventoryPercentLoss) + injectionRate, maxInventory);
AssertInventoryRangeEqualsExpected(inventorySpace[new Day(2019, 8, 23)], expectedInventoryLower, expectedInventoryUpper);
expectedInventoryLower = Math.Max(expectedInventoryLower * (1 - inventoryPercentLoss) - withdrawalRate, minInventory);
expectedInventoryUpper = Math.Min(expectedInventoryUpper * (1 - inventoryPercentLoss) + injectionRate, maxInventory);
AssertInventoryRangeEqualsExpected(inventorySpace[new Day(2019, 8, 24)], expectedInventoryLower, expectedInventoryUpper);
// At this point the backwardly derived reduced inventory space kicks in so we need to start going backwards in time
expectedInventoryLower = 0.0;
expectedInventoryUpper = 0.0;
AssertInventoryRangeEqualsExpected(inventorySpace[new Day(2019, 8, 28)], expectedInventoryLower, expectedInventoryUpper);
expectedInventoryUpper = Math.Min((expectedInventoryUpper + withdrawalRate) / (1 - inventoryPercentLoss), maxInventory);
AssertInventoryRangeEqualsExpected(inventorySpace[new Day(2019, 8, 27)], expectedInventoryLower, expectedInventoryUpper);
expectedInventoryUpper = Math.Min((expectedInventoryUpper + withdrawalRate) / (1 - inventoryPercentLoss), maxInventory);
AssertInventoryRangeEqualsExpected(inventorySpace[new Day(2019, 8, 26)], expectedInventoryLower, expectedInventoryUpper);
expectedInventoryUpper = Math.Min((expectedInventoryUpper + withdrawalRate) / (1 - inventoryPercentLoss), maxInventory);
AssertInventoryRangeEqualsExpected(inventorySpace[new Day(2019, 8, 25)], expectedInventoryLower, expectedInventoryUpper);
}
//static Series method
public static FourierSeries Series(TimeSeries ds, Int32 period)
{
return(new FourierSeries(ds, period));
}
public override ComponentSeries DerivedExtractSeries(TimeSeries global, float timestamp, bool mirrored)
{
return(null);
}
public FO(TimeSeries series, int length)
{
this.indicator = new FreeQuant.Indicators.FO(series.series, length);
}
//populate
public override void Populate()
{
TimeSeries ds = Parameters[0].AsTimeSeries;
Int32 period = Parameters[1].AsInt;
Double k = Parameters[2].AsDouble;
DateTimes = ds.DateTimes;
if (period <= 0 || ds.Count == 0)
{
return;
}
var halfperiod = period / 2;
var HH = new Highest(ds, halfperiod);
var LL = new Lowest(ds, halfperiod);
var Log2 = Math.Log(2);
//Assign first bar that contains indicator data
var FirstValidValue = ds.FirstValidIndex + 2 * halfperiod - 1;
if (FirstValidValue > ds.Count)
{
FirstValidValue = ds.Count;
}
//Initialize start of series
for (int bar = 0; bar < FirstValidValue; bar++)
{
Values[bar] = ds[bar];
}
//Rest of series
for (int bar = FirstValidValue; bar < ds.Count; bar++)
{
//First half
double hh1 = HH[bar - halfperiod];
double ll1 = LL[bar - halfperiod];
double n1 = (hh1 - ll1) / halfperiod;
//Second half
double hh2 = HH[bar];
double ll2 = LL[bar];
double n2 = (hh2 - ll2) / halfperiod;
//Complete interval
double hh3 = Math.Max(hh1, hh2);
double ll3 = Math.Min(ll1, ll2);
double n3 = (hh3 - ll3) / (2 * halfperiod);
//Set Dimension variable
double n = n1 + n2;
double Dimen = 1;
if (n > 0)
{
Dimen = Math.Log(n / n3) / Log2; // always less than 2
}
//Formula for exp. moving average
if (Dimen < 1)
{
Dimen = 1;
}
double alpha = Math.Exp(-k * (Dimen - 1));
Values[bar] = alpha * ds[bar] + (1 - alpha) * Values[bar - 1];
}
}
public MACD(TimeSeries series, int length1, int length2, Color color)
{
this.indicator = new SmartQuant.Indicators.MACD(series.series, length1, length2, color);
}
public TRIX(TimeSeries input, int length) : base(input)
{
this.fLength = 14;
this.fLength = length;
this.Init();
}
public void CalculateInventorySpace_CurrentPeriodAfterStorageStartPeriod_AsExpected()
{
const double injectionRate = 5.0;
const double withdrawalRate = 6.0;
const double startingInventory = 8.0;
const double inventoryPercentLoss = 0.03;
const double minInventory = 0.0;
const double maxInventory = 23.5;
var storageStart = new Day(2019, 8, 1);
var storageEnd = new Day(2019, 8, 28);
var currentPeriod = new Day(2019, 8, 20);
var storage = CmdtyStorage <Day> .Builder
.WithActiveTimePeriod(storageStart, storageEnd)
.WithConstantInjectWithdrawRange(-withdrawalRate, injectionRate)
.WithConstantMinInventory(minInventory)
.WithConstantMaxInventory(maxInventory)
.WithPerUnitInjectionCost(1.5)
.WithNoCmdtyConsumedOnInject()
.WithPerUnitWithdrawalCost(0.8)
.WithNoCmdtyConsumedOnWithdraw()
.WithFixedPercentCmdtyInventoryLoss(inventoryPercentLoss)
.WithNoInventoryCost()
.WithTerminalInventoryNpv((cmdtyPrice, inventory) => 0.0)
.Build();
TimeSeries <Day, InventoryRange> inventorySpace =
StorageHelper.CalculateInventorySpace(storage, startingInventory, currentPeriod);
int expectedInventorySpaceCount = storageEnd.OffsetFrom(currentPeriod);
Assert.Equal(expectedInventorySpaceCount, inventorySpace.Count);
double expectedInventoryLower = startingInventory * (1 - inventoryPercentLoss) - withdrawalRate;
double expectedInventoryUpper = startingInventory * (1 - inventoryPercentLoss) + injectionRate;
AssertInventoryRangeEqualsExpected(inventorySpace[new Day(2019, 8, 21)], expectedInventoryLower, expectedInventoryUpper);
expectedInventoryLower = Math.Max(expectedInventoryLower * (1 - inventoryPercentLoss) - withdrawalRate, minInventory);
expectedInventoryUpper = Math.Min(expectedInventoryUpper * (1 - inventoryPercentLoss) + injectionRate, maxInventory);
AssertInventoryRangeEqualsExpected(inventorySpace[new Day(2019, 8, 22)], expectedInventoryLower, expectedInventoryUpper);
expectedInventoryLower = Math.Max(expectedInventoryLower * (1 - inventoryPercentLoss) - withdrawalRate, minInventory);
expectedInventoryUpper = Math.Min(expectedInventoryUpper * (1 - inventoryPercentLoss) + injectionRate, maxInventory);
AssertInventoryRangeEqualsExpected(inventorySpace[new Day(2019, 8, 23)], expectedInventoryLower, expectedInventoryUpper);
expectedInventoryLower = Math.Max(expectedInventoryLower * (1 - inventoryPercentLoss) - withdrawalRate, minInventory);
expectedInventoryUpper = Math.Min(expectedInventoryUpper * (1 - inventoryPercentLoss) + injectionRate, maxInventory);
AssertInventoryRangeEqualsExpected(inventorySpace[new Day(2019, 8, 24)], expectedInventoryLower, expectedInventoryUpper);
expectedInventoryLower = Math.Max(expectedInventoryLower * (1 - inventoryPercentLoss) - withdrawalRate, minInventory);
expectedInventoryUpper = Math.Min(expectedInventoryUpper * (1 - inventoryPercentLoss) + injectionRate, maxInventory);
AssertInventoryRangeEqualsExpected(inventorySpace[new Day(2019, 8, 25)], expectedInventoryLower, expectedInventoryUpper);
expectedInventoryLower = Math.Max(expectedInventoryLower * (1 - inventoryPercentLoss) - withdrawalRate, minInventory);
expectedInventoryUpper = Math.Min(expectedInventoryUpper * (1 - inventoryPercentLoss) + injectionRate, maxInventory);
AssertInventoryRangeEqualsExpected(inventorySpace[new Day(2019, 8, 26)], expectedInventoryLower, expectedInventoryUpper);
expectedInventoryLower = Math.Max(expectedInventoryLower * (1 - inventoryPercentLoss) - withdrawalRate, minInventory);
expectedInventoryUpper = Math.Min(expectedInventoryUpper * (1 - inventoryPercentLoss) + injectionRate, maxInventory);
AssertInventoryRangeEqualsExpected(inventorySpace[new Day(2019, 8, 27)], expectedInventoryLower, expectedInventoryUpper);
expectedInventoryLower = Math.Max(expectedInventoryLower * (1 - inventoryPercentLoss) - withdrawalRate, minInventory);
expectedInventoryUpper = Math.Min(expectedInventoryUpper * (1 - inventoryPercentLoss) + injectionRate, maxInventory);
AssertInventoryRangeEqualsExpected(inventorySpace[new Day(2019, 8, 28)], expectedInventoryLower, expectedInventoryUpper);
}
public WilliamsRIndicator(TimeSeries timeSeries, int timeFrame) : this(new ClosePriceIndicator(timeSeries), timeFrame, new MaxPriceIndicator(timeSeries), new MinPriceIndicator(timeSeries))
{
}
public override void Recompute()
{
IsValid = false;
tsOutput = null;
mvtsOutput = null;
// make sure we have at least 2 data points in the time series to be sampled
var tp = GetInputType(0);
if (tp != InputType.UnivariateTS && tp != InputType.MultivariateTS)
{
return;
}
var rp = GetInputType(1);
if (rp != InputType.UnivariateTS && rp != InputType.MultivariateTS)
{
return;
}
// first get the reference times
var times = new List <DateTime>(1000);
var input1 = GetInput(1);
var mvref = input1 as MVTimeSeries;
var uref = input1 as TimeSeries;
if (rp == InputType.UnivariateTS)
{
if (uref == null)
{
return;
}
for (int t = 0; t < uref.Count; ++t)
{
times.Add(uref.TimeStamp(t));
}
}
else if (rp == InputType.MultivariateTS)
{
if (mvref == null)
{
return;
}
for (int t = 0; t < mvref.Count; ++t)
{
times.Add(mvref.TimeStamp(t));
}
}
else
{
throw new ApplicationException("Invalid input type; this should not happen!");
}
int refDim = uref != null ? 1 : mvref.Dimension;
// then sample to get the output
if (tp == InputType.UnivariateTS)
{
var uts = GetInput(0) as TimeSeries;
if (uts == null)
{
return;
}
// split it up
if (!IncludeReferenceInOutput)
{
tsOutput = new TimeSeries();
for (int t = 0; t < times.Count; ++t)
{
tsOutput.Add(times[t], uts.ValueAtTime(times[t]), true);
}
}
else
{
mvtsOutput = new MVTimeSeries(1 + refDim);
for (int t = 0; t < times.Count; ++t)
{
var val = new double[1 + refDim];
val[0] = uts.ValueAtTime(times[t]);
for (int i = 1; i <= refDim; ++i)
{
val[i] = mvref != null ? mvref[t][i - 1] : uref[t];
}
mvtsOutput.Add(times[t], val, true);
}
}
IsValid = true;
}
if (tp == InputType.MultivariateTS)
{
var mts = GetInput(0) as MVTimeSeries;
if (mts == null)
{
return;
}
// split it up
if (!IncludeReferenceInOutput)
{
mvtsOutput = new MVTimeSeries();
for (int t = 0; t < times.Count; ++t)
{
mvtsOutput.Add(times[t], mts.ValueAtTime(times[t]), true);
}
}
else
{
int thisDim = mts.Dimension;
mvtsOutput = new MVTimeSeries(thisDim + refDim);
for (int t = 0; t < times.Count; ++t)
{
var val = new double[thisDim + refDim];
var dv = mts.ValueAtTime(times[t]);
for (int i = 0; i < thisDim; ++i)
{
val[i] = dv[i];
}
for (int i = 0; i < refDim; ++i)
{
val[i + thisDim] = mvref != null ? mvref[t][i] : uref[t];
}
mvtsOutput.Add(times[t], val, true);
}
}
IsValid = true;
}
}
public async Task <IAggregatedEvent> GetArtistAggregatedEventAsync(int id, TimeSeries timeSeries)
{
IAggregatedEvent aggregatedEvent = await _artistTimeSeriesCache.FetchTimeSeriesAggregatedEventAsync(id, timeSeries);
return(aggregatedEvent);
}
//populate
public override void Populate()
{
TimeSeries ds = Parameters[0].AsTimeSeries;
Int32 period = Parameters[1].AsInt;
DateTimes = ds.DateTimes;
int FirstValidValue = period + 2;
if (period <= 0 || ds.Count < FirstValidValue)
{
return;
}
double Bandwidth = 0.1;
double G1 = 0, S1 = 0, L1 = 0, G2 = 0, S2 = 0, L2 = 0, G3 = 0, S3 = 0, L3 = 0;
TimeSeries BP1 = new TimeSeries(DateTimes), BP2 = new TimeSeries(DateTimes), BP3 = new TimeSeries(DateTimes),
Q1 = new TimeSeries(DateTimes), Q2 = new TimeSeries(DateTimes), Q3 = new TimeSeries(DateTimes),
P1 = new TimeSeries(DateTimes), P2 = new TimeSeries(DateTimes), P3 = new TimeSeries(DateTimes);
double Deg2Rad = Math.PI / 180.0;
BP1.Description = string.Format("BP1({0},{1})", ds, period);
BP2.Description = string.Format("BP2({0},{1})", ds, period);
BP3.Description = string.Format("BP3({0},{1})", ds, period);
Q1.Description = string.Format("Q1({0},{1})", ds, period);
Q2.Description = string.Format("Q2({0},{1})", ds, period);
Q3.Description = string.Format("Q3({0},{1})", ds, period);
P1.Description = string.Format("P1({0},{1})", ds, period);
P2.Description = string.Format("P2({0},{1})", ds, period);
P3.Description = string.Format("P3({0},{1})", ds, period);
//compute filter coefficients once
L1 = Math.Cos(360d / period * Deg2Rad);
G1 = Math.Cos(Bandwidth * 360 / period * Deg2Rad);
S1 = 1d / G1 - Math.Sqrt(1d / (G1 * G1) - 1);
L2 = Math.Cos(360d / (period / 2d) * Deg2Rad);
G2 = Math.Cos(Bandwidth * 360 / (period / 2d) * Deg2Rad);
S2 = 1d / G2 - Math.Sqrt(1d / (G2 * G2) - 1);
L3 = Math.Cos(360 / (period / 3d) * Deg2Rad);
G3 = Math.Cos(Bandwidth * 360 / (period / 3d) * Deg2Rad);
S3 = 1d / G3 - Math.Sqrt(1d / (G3 * G3) - 1);
for (int i = 0; i < FirstValidValue; i++)
{
BP1[i] = BP2[i] = BP3[i] = 0;
Q1[i] = Q2[i] = Q3[i] = 0;
P1[i] = P2[i] = P3[i] = 0;
}
for (int bar = FirstValidValue; bar < ds.Count; bar++)
{
//Fundamental Band-Pass
if (bar >= 2)
{
BP1[bar] = .5 * (1 - S1) * (ds[bar] - ds[bar - 2]) + L1 * (1 + S1) * BP1[bar - 1] - S1 * BP1[bar - 2];
}
if (bar <= 3)
{
BP1[bar] = 0;
BP2[bar] = 0;
BP3[bar] = 0;
}
//Fundamental Quadrature
if (bar >= 1)
{
Q1[bar] = (period / 6.28) * (BP1[bar] - BP1[bar - 1]);
}
if (bar <= 4)
{
Q1[bar] = 0;
Q2[bar] = 0;
Q3[bar] = 0;
}
//Second Harmonic Band-Pass
if (bar >= 2)
{
BP2[bar] = .5 * (1 - S2) * (ds[bar] - ds[bar - 2]) + L2 * (1 + S2) * BP2[bar - 1] - S2 * BP2[bar - 2];
}
//Second Harmonic Quadrature
if (bar >= 1)
{
Q2[bar] = (period / 6.28) * (BP2[bar] - BP2[bar - 1]);
}
//Third Harmonic Band-Pass
if (bar >= 2)
{
BP3[bar] = .5 * (1 - S3) * (ds[bar] - ds[bar - 2]) + L3 * (1 + S3) * BP3[bar - 1] - S3 * BP3[bar - 2];
}
//Third Harmonic Quadrature
if (bar >= 1)
{
Q3[bar] = (period / 6.28) * (BP3[bar] - BP3[bar - 1]);
}
//Sum power of each harmonic at each bar over the Fundamental period
P1[bar] = 0;
P2[bar] = 0;
P3[bar] = 0;
for (int count = 0; count < period; count++)
{
P1[bar] = P1[bar] + BP1[bar - count] * BP1[bar - count] + Q1[bar - count] * Q1[bar - count];
P2[bar] = P2[bar] + BP2[bar - count] * BP2[bar - count] + Q2[bar - count] * Q2[bar - count];
P3[bar] = P3[bar] + BP3[bar - count] * BP3[bar - count] + Q3[bar - count] * Q3[bar - count];
}
//Add the three harmonics together using their relative amplitudes
if (P1[bar] != 0)
{
Values[bar] = BP1[bar] + Math.Sqrt(P2[bar] / P1[bar]) * BP2[bar] + Math.Sqrt(P3[bar] / P1[bar]) * BP3[bar];
}
}
}
private List <TimeSeriesPoint> LoadPointsFrom3X(IAquariusClient client)
{
var timeSeriesDescription = client.Publish.Get(new Get3xTimeSeriesDescription
{
LocationIdentifier = Context.SourceTimeSeries.LocationIdentifier,
Parameter = Context.SourceTimeSeries.Parameter
})
.TimeSeriesDescriptions
.SingleOrDefault(ts => ts.Identifier == Context.SourceTimeSeries.TargetIdentifier);
if (timeSeriesDescription == null)
{
throw new ExpectedException($"Can't find '{Context.SourceTimeSeries.Identifier}' time-series in location '{Context.SourceTimeSeries.LocationIdentifier}'.");
}
Log.Info($"Loading points from '{timeSeriesDescription.Identifier}' ...");
var correctedData = client.Publish.Get(new Get3xCorrectedData
{
TimeSeriesIdentifier = Context.SourceTimeSeries.Identifier,
QueryFrom = Context.SourceQueryFrom?.ToDateTimeOffset(),
QueryTo = Context.SourceQueryTo?.ToDateTimeOffset()
});
var points = correctedData
.Points
.Select(p => new TimeSeriesPoint
{
Time = Instant.FromDateTimeOffset(p.Timestamp),
Value = p.Value,
GradeCode = p.Grade
})
.ToList();
// 3.X Publish API's TimeSeriesDescription is missing some info, so grab those pieces from elsewhere
// The time-range start will always be in the offset of the time-series, even when no points exist
var utcOffset = Offset.FromHoursAndMinutes(correctedData.TimeRange.StartTime.Offset.Hours, correctedData.TimeRange.StartTime.Offset.Minutes);
// We can infer the interpolationType from the last point (if one exists)
var interpolationType = Context.InterpolationType ?? (correctedData.Points.Any()
? (InterpolationType?)correctedData.Points.Last().Interpolation
: null);
var timeSeries = new TimeSeries
{
Identifier = Context.SourceTimeSeries.Identifier,
Parameter = timeSeriesDescription.Parameter,
Label = timeSeriesDescription.Label,
Unit = timeSeriesDescription.Unit,
Publish = timeSeriesDescription.Publish,
Description = timeSeriesDescription.Description,
Comment = timeSeriesDescription.Comment,
TimeSeriesType = KnownTimeSeriesTypes[timeSeriesDescription.TimeSeriesType],
UtcOffset = utcOffset,
ComputationIdentifier = timeSeriesDescription.ComputationIdentifier,
ComputationPeriodIdentifier = timeSeriesDescription.ComputationPeriodIdentifier,
SubLocationIdentifier = timeSeriesDescription.SubLocationIdentifier,
LocationIdentifier = timeSeriesDescription.LocationIdentifier,
ExtendedAttributeValues = timeSeriesDescription.ExtendedAttributes.Select(ea =>
new ExtendedAttributeValue
{
ColumnIdentifier = $"{ea.Name.ToUpperInvariant()}@TIMESERIES_EXTENSION",
Value = ea.Value?.ToString()
})
.ToList()
};
SetTimeSeriesCreationProperties(timeSeries, interpolationType: interpolationType);
if (!Context.IgnoreNotes)
{
var corrections = client.Publish.Get(new Get3xCorrectionList
{
TimeSeriesIdentifier = Context.SourceTimeSeries.Identifier,
QueryFrom = Context.SourceQueryFrom?.ToDateTimeOffset(),
QueryTo = Context.SourceQueryTo?.ToDateTimeOffset()
}).Corrections;
var utcTimespan = utcOffset.ToTimeSpan();
Notes.AddRange(corrections.Select(c => Convert3XCorrection(utcTimespan, c)));
}
Log.Info($"Loaded {PointSummarizer.Summarize(points)} and {"note".ToQuantity(Notes.Count)} from {Context.SourceTimeSeries.Identifier}");
return(points);
}
public SlimTimeSeries(TimeSeriesLink link, TimeSeries source) : base(link, source)
{
Values = source.ToArray();
}
public static string GetIsoDateTimeStringStart(TimeSeries timeSeries)
{
var d = timeSeries.Start;
return(d.ToString(IsoDateTime.DATE_WHITESPACE_TIME_FORMAT_TO_SECOND, CultureInfo.InvariantCulture));
}
public Phase(TimeSeries timeSeries)
{
timeSeries.Add(this);
Values = new float[TimeSeries.Samples.Length];
}
public MaxPriceIndicator(TimeSeries series) : base(series)
{
_series = series;
}
public ParabolicSarIndicator(TimeSeries series, int timeFrame) : base(series)
{
_series = series;
_lowestValueIndicator = new LowestValueIndicator(new MinPriceIndicator(series), timeFrame);
_highestValueIndicator = new HighestValueIndicator(new MaxPriceIndicator(series), timeFrame);
}
public CandleQuantityDiPlusVsDiMinusProvider(TimeSeries diPlus, TimeSeries diMinus)
{
this.diPlus = diPlus;
this.diMinus = diMinus;
}
public async Task CanIndexRollups()
{
using (var store = GetDocumentStore())
{
var raw = new RawTimeSeriesPolicy(TimeValue.FromHours(24));
var p1 = new TimeSeriesPolicy("By6Hours", TimeValue.FromHours(6), raw.RetentionTime * 4);
var p2 = new TimeSeriesPolicy("By1Day", TimeValue.FromDays(1), raw.RetentionTime * 5);
var p3 = new TimeSeriesPolicy("By30Minutes", TimeValue.FromMinutes(30), raw.RetentionTime * 2);
var p4 = new TimeSeriesPolicy("By1Hour", TimeValue.FromMinutes(60), raw.RetentionTime * 3);
var config = new TimeSeriesConfiguration
{
Collections = new Dictionary <string, TimeSeriesCollectionConfiguration>
{
["Users"] = new TimeSeriesCollectionConfiguration
{
RawPolicy = raw,
Policies = new List <TimeSeriesPolicy>
{
p1, p2, p3, p4
}
},
},
PolicyCheckFrequency = TimeSpan.FromSeconds(1)
};
await store.Maintenance.SendAsync(new ConfigureTimeSeriesOperation(config));
var database = await Databases.GetDocumentDatabaseInstanceFor(store);
var now = DateTime.UtcNow;
var nowSeconds = now.Second;
now = now.AddSeconds(-nowSeconds);
database.Time.UtcDateTime = () => DateTime.UtcNow.AddSeconds(-nowSeconds);
var baseline = now.AddDays(-12);
var total = ((TimeSpan)TimeValue.FromDays(12)).TotalMinutes;
await new TimeSeriesIndex().ExecuteAsync(store);
using (var session = store.OpenSession())
{
session.Store(new User {
Name = "Karmel"
}, "users/karmel");
for (int i = 0; i <= total; i++)
{
session.TimeSeriesFor("users/karmel", "Heartrate")
.Append(baseline.AddMinutes(i), new[] { 29d * i, i }, "watches/fitbit");
}
session.SaveChanges();
}
await TimeSeries.WaitForPolicyRunnerAsync(database);
await TimeSeries.VerifyPolicyExecutionAsync(store, config.Collections["Users"], 4, policies : new List <TimeSeriesPolicy> {
p1
});
await TimeSeries.VerifyPolicyExecutionAsync(store, config.Collections["Users"], 5, policies : new List <TimeSeriesPolicy> {
p2
});
await TimeSeries.VerifyPolicyExecutionAsync(store, config.Collections["Users"], 2, policies : new List <TimeSeriesPolicy> {
p3
});
await TimeSeries.VerifyPolicyExecutionAsync(store, config.Collections["Users"], 3, policies : new List <TimeSeriesPolicy> {
p4
});
Indexes.WaitForIndexing(store);
RavenTestHelper.AssertNoIndexErrors(store);
using (var session = store.OpenSession())
{
var user = session.Load <User>("users/karmel");
var count = session
.TimeSeriesFor(user, "Heartrate")
.Get(DateTime.MinValue, DateTime.MaxValue)
.Count(entry => entry.IsRollup == false);
count += session
.TimeSeriesFor(user, "Heartrate@By6Hours")
.Get(DateTime.MinValue, DateTime.MaxValue)
.Count();
count += session
.TimeSeriesFor(user, "Heartrate@By1Day")
.Get(DateTime.MinValue, DateTime.MaxValue)
.Count();
count += session
.TimeSeriesFor(user, "Heartrate@By30Minutes")
.Get(DateTime.MinValue, DateTime.MaxValue)
.Count();
count += session
.TimeSeriesFor(user, "Heartrate@By1Hour")
.Get(DateTime.MinValue, DateTime.MaxValue)
.Count();
var results = session.Query <TimeSeriesIndex.Result, TimeSeriesIndex>()
.ToList();
Assert.True(count == results.Count, $"Test time = {now}");
}
}
}
public void SetUp()
{
_mockdata = GenerateTimeSeries.From(29.49, 28.30, 27.74, 27.65, 27.60, 28.70, 28.60, 28.19, 27.40, 27.20, 27.28, 27.00, 27.59, 26.20, 25.75, 24.75, 23.33, 24.45, 24.25, 25.02, 23.60, 24.20, 24.28, 25.70, 25.46, 25.10, 25.00, 25.00, 25.85);
_closePrice = new ClosePriceIndicator(_mockdata);
}
public MOM(TimeSeries series, int length)
{
this.indicator = new SmartQuant.Indicators.MOM(series.series, length);
}
public void SetUp()
{
_timeSeries = GenerateTimeSeries.WithArbitraryTicks();
_amountIndicator = new AmountIndicator(_timeSeries);
}
