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); }