private void AddSignal(Series series, TimedValue <DateTime, Signal> signal)
{
var price = GetPointForSignal(signal);
if (price == null)
{
// actually this should result at least in a warning
price = new SimplePrice(signal.Time, 0.0);
}
series.Points.AddXY(signal.Time, price.Value);
var point = series.Points[series.Points.Count - 1];
if (signal.Value.Type == SignalType.Buy)
{
point.MarkerStyle = MarkerStyle.Triangle;
point.MarkerColor = Color.Green;
}
else if (signal.Value.Type == SignalType.Sell)
{
point.MarkerStyle = MarkerStyle.Cross;
point.MarkerColor = Color.Red;
}
}
private IEnumerable <TimedValue <DateTime, double> > FillMissingDates(IPriceSeries series)
{
yield return(series.First());
var expectedPoint = series.First();
foreach (var point in series.Skip(1))
{
while (true)
{
expectedPoint = new TimedValue <DateTime, double>(expectedPoint.Time.AddDays(1), expectedPoint.Value);
if (expectedPoint.Time == point.Time)
{
break;
}
if (expectedPoint.Time.DayOfWeek == DayOfWeek.Saturday ||
expectedPoint.Time.DayOfWeek == DayOfWeek.Sunday)
{
// no trading at weekends usually
continue;
}
// missing price at this date - take over the last one we have
yield return(expectedPoint);
}
expectedPoint = point;
yield return(point);
}
}
public IPromise Animate(TimedValue<TransformState> target)
{
this.previous = new TimedValue<TransformState>(new TransformState(transform.localPosition, transform.localRotation, transform.localScale), getTime());
this.target = target;
finishAnimation = new UndoablePromise();
animating = true;
return finishAnimation.WithName(string.Format("Animate {0}", name));
}
public override Vector2 RelativeLerp(TimedValue <Vector2> otherRef, float time)
{
Vector3 lerpedVec = TimedVector3.Lerp(this.Value,
this.Timestamp,
otherRef.Value,
otherRef.Timestamp,
time);
return((Vector2)lerpedVec);
}
public void Mark(double value)
{
var tv = new TimedValue(_sw.ElapsedMilliseconds, value);
lock (_syncLock)
{
_data.AddFirst(tv);
_needToRecomputeEstimation = true;
ClearOutOfWindowData(); // remove out of window data
}
}
public override Random.State RelativeLerp(TimedValue <Random.State> otherRef, float time)
{
if (time > otherRef.Timestamp)
{
return(otherRef.Value);
}
else
{
return(this.Value);
}
}
public TimedValue <DateTime, double> GetPointForSignal(TimedValue <DateTime, Signal> signal)
{
if (mySignals == null)
{
return(null);
}
TimedValue <DateTime, double> value = null;
myReferenceTimeIndex.TryGetValue(signal.Time, out value);
return(value);
}
/// <summary>
/// Calculates the certainty between two values.
/// </summary>
/// <param name="seenGoodAltitude"></param>
/// <param name="previousAltitude"></param>
/// <param name="thisAltitude"></param>
/// <returns></returns>
private Certainty CalculateAltitudeCertainty(bool seenGoodAltitude, TimedValue <int> previousAltitude, TimedValue <int> thisAltitude)
{
var altitudeChange = (double)thisAltitude.Value - (double)previousAltitude.Value;
var period = (thisAltitude.Time - previousAltitude.Time).TotalSeconds;
var changePerSecond = altitudeChange / period;
return((changePerSecond < 0.0 && changePerSecond < MaxDescendSpeedFeedPerSecond) ||
(changePerSecond > 0.0 && changePerSecond > MaxClimbSpeedFeetPerSecond)
? seenGoodAltitude ? Certainty.CertainlyWrong
: Certainty.Uncertain
: Certainty.ProbablyRight);
}
public void OnNext(T t)
{
long now = scheduler.NowUtc();
Trim(now);
TimedValue v = new TimedValue();
v.value = t;
v.timestamp = now + maxAge;
q.Offer(v);
}
public void SetTimedAdjustor(string key, float val, float time)
{
TimedValue oldVal;
if (timedAdjustors.TryGetValue(key, out oldVal))
{
totalValue -= oldVal.value;
}
timedAdjustors[key] = new TimedValue(val, time);
totalValue += val;
}
LinkedList <TimedValue> splitBefore(int splitIndex,
LinkedList <TimedValue> remainingValues)
{
LinkedList <TimedValue> splitValues = new LinkedList <TimedValue>();
for (int i = 0; i < splitIndex; i++)
{
TimedValue moveValue = remainingValues.First();
remainingValues.RemoveFirst();
splitValues.AddLast(moveValue);
}
return(splitValues);
}
public void OnNext(T t)
{
long now = scheduler.NowUtc();
TimedValue tv = new TimedValue();
tv.timestamp = now;
tv.value = t;
queue.Offer(tv);
drainOld(now);
}
/// <summary>
/// Queue the time-data value pair.
/// If the queue is longer than the defined capacity,
/// it will start to dequeue.
/// </summary>
/// <param name="time"></param>
/// <param name="value"></param>
public void Add(float time, float value)
{
TimedValue t = new TimedValue();
t.value = value;
t.time = time;
DataSeries.Enqueue(t);
LastTimedData = t;
while (DataSeries.Count > Capacity)
{
DataSeries.Dequeue();
}
}
public override Quaternion RelativeLerp(TimedValue <Quaternion> otherRef, float time)
{
Vector3 thisEuler = this.Value.eulerAngles;
Vector3 otherEuler = otherRef.Value.eulerAngles;
Vector3 lerpedVec = TimedVector3.Lerp(thisEuler,
this.Timestamp,
otherEuler,
otherRef.Timestamp,
time);
return(Quaternion.Euler(lerpedVec));
}
/// <summary>
/// Does all the work for <see cref="CheckAltitude"/> and <see cref="CheckPosition"/>.
/// </summary>
/// <typeparam name="TValue"></typeparam>
/// <typeparam name="TNullable"></typeparam>
/// <param name="aircraftId"></param>
/// <param name="timedValue"></param>
/// <param name="map"></param>
/// <param name="calculateCertainty"></param>
/// <param name="findFirstValue"></param>
/// <returns></returns>
private Certainty CheckValue <TValue, TNullable>(
int aircraftId,
TimedValue <TValue> timedValue,
ExpiringDictionary <int, ValueHistory <TValue, TNullable> > map,
Func <bool, TimedValue <TValue>, TimedValue <TValue>, Certainty> calculateCertainty,
Func <List <TimedValue <TValue> >, TNullable> findFirstValue
)
{
var valueHistory = map.GetAndRefreshOrCreate(aircraftId, (unused) => new ValueHistory <TValue, TNullable>()
{
AircraftId = aircraftId,
});
if (valueHistory.RecordedFirstGoodValue && valueHistory.FirstGoodValue != null)
{
valueHistory.FirstGoodValue = default(TNullable);
}
var resetThreshold = timedValue.Time.AddSeconds(-ResetHistorySeconds);
var resetOnMessage = valueHistory.PreviousValue;
if (resetOnMessage != null && resetOnMessage.Time <= resetThreshold)
{
valueHistory.Reset();
}
var result = Certainty.Uncertain;
var previousValue = valueHistory.PreviousValue;
valueHistory.AddValue(timedValue);
if (previousValue != null)
{
result = calculateCertainty(valueHistory.PreviousValueIsGood, previousValue, timedValue);
if (result != Certainty.ProbablyRight)
{
valueHistory.Reset();
}
else
{
if (!valueHistory.RecordedFirstGoodValue)
{
valueHistory.FirstGoodValue = findFirstValue(valueHistory.History);
valueHistory.RecordedFirstGoodValue = true;
}
valueHistory.PreviousValueIsGood = true;
}
}
return(result);
}
public void AddValue(TimedValue <TValue> value)
{
PreviousValue = value;
// We don't need to record any more history once the first good value has been seen.
if (!RecordedFirstGoodValue)
{
History.Add(value);
}
else if (History != null)
{
History = null;
}
}
/// <summary>
/// Calcualtes whether we are certain than an aircraft could potentially move between two points in a given span of time.
/// </summary>
/// <param name="seenGoodPosition"></param>
/// <param name="previousPosition"></param>
/// <param name="thisPosition"></param>
/// <returns></returns>
private Certainty CalculatePositionCertainty(bool seenGoodPosition, TimedValue <GlobalCoordinate> previousPosition, TimedValue <GlobalCoordinate> thisPosition)
{
var result = Certainty.Uncertain;
if (thisPosition.Value.Latitude != 0.0 || thisPosition.Value.Longitude != 0.0)
{
var distance = GreatCircleMaths.Distance(previousPosition.Value.Latitude, previousPosition.Value.Longitude, thisPosition.Value.Latitude, thisPosition.Value.Longitude);
var time = (thisPosition.Time - previousPosition.Time).TotalSeconds;
var speed = distance / time;
result = speed <= MaxSpeedKilometersPerSecond ? Certainty.ProbablyRight
: seenGoodPosition ? Certainty.CertainlyWrong : Certainty.Uncertain;
}
return(result);
}
public override bool RelativeLerp(TimedValue <bool> otherRef, float time)
{
TimedValue <bool> left = otherRef.Timestamp < this.Timestamp ? otherRef : this;
TimedValue <bool> right = left == this? otherRef : this;
if (time < left.Timestamp)
{
return(left.Value);
}
else if (time > right.Timestamp)
{
return(right.Value);
}
// return closest value to time
return(Mathf.Abs(time - left.Timestamp) > Mathf.Abs(right.Timestamp - time)?
left.Value :
right.Value);
}
public ISignalSeries Generate(IPriceSeries referencePrices, IPriceSeries indicatorPoints)
{
var signals = new List <TimedSignal>();
var prevPrice = referencePrices.First();
TimedValue <DateTime, double> prevIndicatorPoint = null;
foreach (var price in referencePrices.Skip(1))
{
var indicatorPoint = indicatorPoints.TryGet(price.Time);
if (indicatorPoint == null)
{
signals.Add(new TimedSignal(price.Time, Signal.None));
continue;
}
if (prevIndicatorPoint == null)
{
prevIndicatorPoint = indicatorPoint;
continue;
}
if (prevPrice.Value < prevIndicatorPoint.Value && price.Value > indicatorPoint.Value)
{
signals.Add(new TimedSignal(indicatorPoint.Time, new BuySignal()));
}
else if (prevPrice.Value > prevIndicatorPoint.Value && price.Value < indicatorPoint.Value)
{
signals.Add(new TimedSignal(indicatorPoint.Time, new SellSignal()));
}
prevPrice = price;
}
return(new SignalSeries(referencePrices, indicatorPoints.Identifier, signals));
}
void SaveCurrentTransform()
{
lastPosition = new TimedValue <Vector3>(transform.position, Time.time);
lastForward = new TimedValue <Vector3>(transform.forward, Time.time);
}
void SaveCurrentTransform()
{
lastPosition = new TimedValue<Vector3>(transform.position, Time.time);
lastForward = new TimedValue<Vector3>(transform.forward, Time.time);
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="aircraftId"></param>
/// <param name="messageReceived"></param>
/// <param name="latitude"></param>
/// <param name="longitude"></param>
/// <returns></returns>
public Certainty CheckPosition(int aircraftId, DateTime messageReceived, double latitude, double longitude)
{
var timedValue = new TimedValue <GlobalCoordinate>(messageReceived, new GlobalCoordinate(latitude, longitude));
return(CheckValue(aircraftId, timedValue, _PositionHistoryMap, CalculatePositionCertainty, FindFirstGoodPosition));
}
public static void Dump <TTime, TValue>(this TextWriter writer, TimedValue <TTime, TValue> value)
where TTime : IComparable <TTime>, IEquatable <TTime>
{
writer.WriteLine("{0}:{1}", value.Time, value.Value);
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="aircraftId"></param>
/// <param name="messageReceived"></param>
/// <param name="altitude"></param>
/// <returns></returns>
public Certainty CheckAltitude(int aircraftId, DateTime messageReceived, int altitude)
{
var timedValue = new TimedValue <int>(messageReceived, altitude);
return(CheckValue(aircraftId, timedValue, _AltitudeHistoryMap, CalculateAltitudeCertainty, FindFirstGoodAltitude));
}
public static string GetDisplayText( TimedValue<DateTime,Signal> signal )
{
return string.Format( "{0}: {1}", signal.Time.ToString( "yyyy-MM-dd" ), GetDisplayText( signal.Value ) );
}
public ISignalSeries Generate(IPriceSeries referencePrices, IPriceSeries indicatorPoints)
{
var signals = new List <TimedSignal>();
var signalDaysInterval = ClosedInterval.FromOffsetLength(MinDaysAfterCutForSignal, KeepSignalForMaxDays);
var prevPrice = referencePrices.First();
TimedValue <DateTime, double> prevIndicatorPoint = null;
TimedSignal activeSignal = null;
foreach (var price in referencePrices.Skip(1))
{
var indicatorPoint = indicatorPoints.TryGet(price.Time);
if (indicatorPoint == null)
{
signals.Add(new TimedSignal(price.Time, Signal.None));
continue;
}
if (prevIndicatorPoint == null)
{
prevIndicatorPoint = indicatorPoint;
continue;
}
if (prevPrice.Value < prevIndicatorPoint.Value && price.Value > indicatorPoint.Value)
{
var signal = new TimedSignal(indicatorPoint.Time, new BuySignal());
if (signalDaysInterval.IsEmpty)
{
signals.Add(signal);
}
else
{
activeSignal = signal;
}
}
else if (prevPrice.Value > prevIndicatorPoint.Value && price.Value < indicatorPoint.Value)
{
var signal = new TimedSignal(indicatorPoint.Time, new SellSignal());
if (signalDaysInterval.IsEmpty)
{
signals.Add(signal);
}
else
{
activeSignal = signal;
}
}
if (activeSignal != null)
{
// we have a cut signal -> handle it
int daysSinceCut = (int)Math.Round((price.Time - activeSignal.Time).TotalDays);
// if we are in defined range -> add the signal
if (signalDaysInterval.Includes(daysSinceCut))
{
signals.Add(new TimedSignal(indicatorPoint.Time, activeSignal.Value));
}
if (daysSinceCut > signalDaysInterval.Max)
{
// left the interval -> reset the signal
activeSignal = null;
}
}
prevPrice = price;
prevIndicatorPoint = indicatorPoint;
}
return(new SignalSeries(referencePrices, indicatorPoints.Identifier, signals));
}
public void Reset()
{
PreviousValue = null;
PreviousValueIsGood = false;
}
// it is completely ok to get None-Signals here.
// we could also get neutral signals here if it is a combined chart and a combined signal
private static bool IsSignalToDisplay(TimedValue <DateTime, Signal> timedSignal)
{
return(timedSignal.Value.Type == SignalType.Buy ||
timedSignal.Value.Type == SignalType.Sell);
}
public override void InitInternal()
{
new ValueTracker<TimedValue<TransformState>>(v => previous = v, () => previous);
new ValueTracker<TimedValue<TransformState>>(v => target = v, () => target);
new BoolTracker(v => animating = v, () => animating);
}
public void Animate(TimedValue <TransformState> target)
{
this.previous = new TimedValue <TransformState>(new TransformState(transform.localPosition, transform.localScale), Time.time);
this.target = target;
animating = true;
}
public static string GetDisplayText(TimedValue <DateTime, Signal> signal)
{
return(string.Format("{0}: {1}", signal.Time.ToString("yyyy-MM-dd"), GetDisplayText(signal.Value)));
}
public abstract V RelativeLerp(TimedValue <V> otherRef, float time);
void FixedUpdate()
{
secondLastPosition = lastPosition;
lastPosition = new TimedValue<Vector3>(transform.parent.position, Time.realtimeSinceStartup);
}
public override float RelativeLerp(TimedValue <float> otherRef, float time)
{
float ratio = (otherRef.Value - this.Value) / (otherRef.Timestamp - this.Timestamp);
return(ratio * (time - this.Timestamp) + this.Value);
}
public TimeSeries WriteToPI(string PITag, DateTime time, string Value )
{
// This function will the value provide to the named tag at the time provided
TimeSeries ts = null;
try
{
string path = String.Format("pi:\\\\{0}\\{1}", mstrPISrvNm, PITag);
TimedValue val = new TimedValue();
val.Path = path;
val.Time = time;
val.Value = Value;
TimeSeries[] events = new TimeSeries[1];
events[0] = new TimeSeries();
events[0].TimedValues = new TimedValue[1];
events[0].TimedValues.SetValue(val, 0);
ts = client.InsertPIData(events,
InsertPIDataDuplicateSwitch.ReplaceDuplicate);
// Always close the client.
client.Close();
WriteOutput();
}
catch (Exception ex)
{
output.AppendLine(ex.Message);
WriteOutput();
}
return ts;
}
public override void InitInternal()
{
lastPosition = new TimedValue<Vector3>(transform.parent.position, Time.realtimeSinceStartup);
secondLastPosition = new TimedValue<Vector3>(transform.parent.position, float.NegativeInfinity);
}
