/// <summary> /// Обработать входное значение. /// </summary> /// <param name="input">Входное значение.</param> /// <returns>Результирующее значение.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { if (input.IsFinal) IsFormed = true; return new DecimalIndicatorValue(this, (_isNegative ? -1 : 1) * Math.Abs(_line1.GetCurrentValue() - _line2.GetCurrentValue())); }
/// <summary> /// Обработать входное значение. /// </summary> /// <param name="input">Входное значение.</param> /// <returns>Результирующее значение.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { if (input.IsFinal) IsFormed = true; return new CandleIndicatorValue(this, input.GetValue<Candle>(), c => c.TotalVolume); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { if (input.IsFinal) IsFormed = true; return input.To<ShiftedIndicatorValue>(); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var shortValue = ShortSma.Process(input).GetValue<decimal>(); var longValue = LongSma.Process(input).GetValue<decimal>(); return new DecimalIndicatorValue(this, Math.Abs(100m * (shortValue - longValue) / longValue)); }
protected override IIndicatorValue OnProcess(IIndicatorValue input) { var result = base.OnProcess(input); IsBarCrossedOnLastValue = null; if (Container.Count > Length) { var lastValue = result.GetValue<decimal>(); var prevValue = this.GetCurrentValue(); if (prevValue < LBar && lastValue > LBar) { IsBarCrossedOnLastValue = new BarCrossedEventArgs { Side = Sides.Buy, PrevIndicatorValue = prevValue, LastIndicatorValue = lastValue }; OnBarCrossed(IsBarCrossedOnLastValue); } else { if (prevValue > HBar && lastValue < HBar) { IsBarCrossedOnLastValue = new BarCrossedEventArgs { Side = Sides.Sell, PrevIndicatorValue = prevValue, LastIndicatorValue = lastValue }; OnBarCrossed(IsBarCrossedOnLastValue); } } } return result; }
/// <summary> /// Обработать входное значение. /// </summary> /// <param name="input">Входное значение.</param> /// <returns>Результирующее значение.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var candle = input.GetValue<Candle>(); try { if (candle.LowPrice < _currentMinimum) { _currentMinimum = candle.LowPrice; _valueBarCount = _currentBarCount; } else if (candle.HighPrice >= _currentMinimum + ReversalAmount.Value) { if (input.IsFinal) IsFormed = true; return new DecimalIndicatorValue(this, _valueBarCount); } return new DecimalIndicatorValue(this, this.GetCurrentValue()); } finally { if(input.IsFinal) _currentBarCount++; } }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var value = base.OnProcess(input); if (IsFormed && !value.IsEmpty) { if (CurrentValue > value.GetValue<decimal>()) { return value; } else { var lastValue = this.GetCurrentValue<ShiftedIndicatorValue>(); if (input.IsFinal) IsFormed = !lastValue.IsEmpty; return IsFormed ? new ShiftedIndicatorValue(this, lastValue.Shift + 1, lastValue.Value) : lastValue; } } IsFormed = false; return value; }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var mpValue = MedianPrice.Process(input); var sValue = ShortMa.Process(mpValue).GetValue<decimal>(); var lValue = LongMa.Process(mpValue).GetValue<decimal>(); return new DecimalIndicatorValue(this, sValue - lValue); }
/// <summary> /// Обработать входное значение. /// </summary> /// <param name="input">Входное значение.</param> /// <returns>Результирующее значение.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var aoValue = Ao.Process(input); if (Ao.IsFormed) return new DecimalIndicatorValue(this, aoValue.GetValue<decimal>() - Sma.Process(aoValue).GetValue<decimal>()); return new DecimalIndicatorValue(this, aoValue.GetValue<decimal>()); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var candle = input.GetValue<Candle>(); if (input.IsFinal) IsFormed = true; return new DecimalIndicatorValue(this, (candle.HighPrice + candle.LowPrice) / 2); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var result = base.OnProcess(input); if (Buffer.Count > 0 && Buffer[0] != 0) return new DecimalIndicatorValue(this, result.GetValue<decimal>() / Buffer[0] * 100); return new DecimalIndicatorValue(this); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var macdValue = Macd.Process(input); var signalValue = Macd.IsFormed ? SignalMa.Process(macdValue) : new DecimalIndicatorValue(this, 0); var value = new ComplexIndicatorValue(this); value.InnerValues.Add(Macd, input.SetValue(this, macdValue.GetValue<decimal>() - signalValue.GetValue<decimal>())); value.InnerValues.Add(SignalMa, signalValue); return value; }
/// <summary> /// Обработать входное значение. /// </summary> /// <param name="input">Входное значение.</param> /// <returns>Результирующее значение.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var cov = base.OnProcess(input); var value = input.GetValue<Tuple<decimal, decimal>>(); var sourceDev = _source.Process(value.Item1); var otherDev = _other.Process(value.Item2); return new DecimalIndicatorValue(this, cov.GetValue<decimal>() / (sourceDev.GetValue<decimal>() * otherDev.GetValue<decimal>())); }
/// <summary> /// Обработать входное значение. /// </summary> /// <param name="input">Входное значение.</param> /// <returns>Результирующее значение.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var message = input.GetValue<Level1ChangeMessage>(); var retVal = message.Changes.TryGetValue(Field); if (!IsFormed && retVal != null && input.IsFinal) IsFormed = true; return retVal == null ? new DecimalIndicatorValue(this) : new DecimalIndicatorValue(this, (decimal)retVal); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var candle = input.GetValue<Candle>(); var emaValue = Ema.Process(input.SetValue(this, candle.HighPrice - candle.LowPrice)); if (Ema.IsFormed) { return Roc.Process(emaValue); } return input; }
/// <summary> /// Обработать входное значение. /// </summary> /// <param name="input">Входное значение.</param> /// <returns>Результирующее значение.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { _wmaSlow.Process(input); _wmaFast.Process(input); if (_wmaFast.IsFormed && _wmaSlow.IsFormed) { var diff = 2 * _wmaFast.GetCurrentValue() - _wmaSlow.GetCurrentValue(); _wmaResult.Process(diff); } return(new DecimalIndicatorValue(this, _wmaResult.GetCurrentValue())); }
/// <inheritdoc /> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var candle = input.GetValue <Candle>(); var emaValue = Ema.Process(input.SetValue(this, candle.HighPrice - candle.LowPrice)); if (Ema.IsFormed) { var val = Roc.Process(emaValue); return(new DecimalIndicatorValue(this, val.GetValue <decimal>())); } return(new DecimalIndicatorValue(this)); }
/// <inheritdoc /> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var ema1Value = _ema1.Process(input); if (!_ema1.IsFormed) { return(new DecimalIndicatorValue(this)); } var ema2Value = _ema2.Process(ema1Value); return(new DecimalIndicatorValue(this, 2 * ema1Value.GetValue <decimal>() - ema2Value.GetValue <decimal>())); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var message = input.GetValue <Level1ChangeMessage>(); var retVal = message.Changes.TryGetValue(Field); if (!IsFormed && retVal != null && input.IsFinal) { IsFormed = true; } return(retVal == null ? new DecimalIndicatorValue(this) : new DecimalIndicatorValue(this, (decimal)retVal)); }
/// <summary> /// Вызвать событие <see cref="Changed"/>. /// </summary> /// <param name="input">Входное значение индикатора.</param> /// <param name="result">Результирующее значение индикатора.</param> protected void RaiseChangedEvent(IIndicatorValue input, IIndicatorValue result) { if (input == null) { throw new ArgumentNullException("input"); } if (result == null) { throw new ArgumentNullException("result"); } Changed.SafeInvoke(input, result); }
private void OnNewValue(IIndicatorValue value) { _manager.Container.AddInput(Source, value); lock (SyncRoot) { foreach (var ind in this) { _manager.ProcessIndicator(ind, value); } } _manager.RaiseNewValueProcessed(Source, value); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var value = (ComplexIndicatorValue)base.OnProcess(input); var upper = value.InnerValues[Upper]; value.InnerValues[Upper] = upper.SetValue(this, upper.GetValue <decimal>() * (1 + Shift)); var lower = value.InnerValues[Lower]; value.InnerValues[Lower] = lower.SetValue(this, lower.GetValue <decimal>() * (1 - Shift)); return(value); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var newValue = input.GetValue <Candle>(); if (input.IsFinal) { _buffer.Add(newValue); if (_buffer.Count > Length) { _buffer.RemoveAt(0); } } if (IsFormed) { decimal valueUp, valueDn; if (input.IsFinal) { valueUp = ((_buffer[0].ClosePrice - _buffer[0].OpenPrice) + 2 * (_buffer[1].ClosePrice - _buffer[1].OpenPrice) + 2 * (_buffer[2].ClosePrice - _buffer[2].OpenPrice) + (_buffer[3].ClosePrice - _buffer[3].OpenPrice)) / 6m; valueDn = ((_buffer[0].HighPrice - _buffer[0].LowPrice) + 2 * (_buffer[1].HighPrice - _buffer[1].LowPrice) + 2 * (_buffer[2].HighPrice - _buffer[2].LowPrice) + (_buffer[3].HighPrice - _buffer[3].LowPrice)) / 6m; } else { valueUp = ((_buffer[1].ClosePrice - _buffer[1].OpenPrice) + 2 * (_buffer[2].ClosePrice - _buffer[2].OpenPrice) + 2 * (_buffer[3].ClosePrice - _buffer[3].OpenPrice) + (newValue.ClosePrice - newValue.OpenPrice)) / 6m; valueDn = ((_buffer[1].HighPrice - _buffer[1].LowPrice) + 2 * (_buffer[2].HighPrice - _buffer[2].LowPrice) + 2 * (_buffer[3].HighPrice - _buffer[3].LowPrice) + (newValue.HighPrice - newValue.LowPrice)) / 6m; } return(new DecimalIndicatorValue(this, valueDn == decimal.Zero ? valueUp : valueUp / valueDn)); } return(new DecimalIndicatorValue(this)); }
/// <summary> /// To call the event <see cref="BaseIndicator.Changed"/>. /// </summary> /// <param name="input">The input value of the indicator.</param> /// <param name="result">The resulting value of the indicator.</param> protected void RaiseChangedEvent(IIndicatorValue input, IIndicatorValue result) { if (input == null) { throw new ArgumentNullException(nameof(input)); } if (result == null) { throw new ArgumentNullException(nameof(result)); } Changed?.Invoke(input, result); }
/// <summary> /// Обработать входное значение. /// </summary> /// <param name="input">Входное значение.</param> /// <returns>Результирующее значение.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var candle = input.GetValue <Candle>(); // Находим минимум и максимум для заданного периода var lowValue = _low.Process(input.SetValue(this, candle.LowPrice)).GetValue <decimal>(); var highValue = _high.Process(input.SetValue(this, candle.HighPrice)).GetValue <decimal>(); if ((highValue - lowValue) != 0) { return(new DecimalIndicatorValue(this, -100m * (highValue - candle.ClosePrice) / (highValue - lowValue))); } return(new DecimalIndicatorValue(this)); }
/// <inheritdoc /> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var candle = input.GetValue <Candle>(); var average = (candle.HighPrice + candle.LowPrice) / 2; var halfRange = (candle.HighPrice - candle.LowPrice) / 2; Buffer.Add(average); //var Chec1 = Buffer[Buffer.Count - 1]; if (IsFormed) { if (Buffer.Count > Length) { Buffer.RemoveAt(0); } //Сглаженное приращение **************************************************************************** var avgDiff = Buffer[Buffer.Count - 1] - Buffer[Buffer.Count - 2]; var smoothDiff = _smoothConstant * avgDiff + _smoothConstant1 * _value1Old; _value1Old = smoothDiff; //Сглаженный Half Range ********************************************************************************* var smoothRng = _smoothConstant * halfRange + _smoothConstant1 * _value2Old; _value2Old = smoothRng; //Tracking index *********************************************************************************** if (smoothRng != 0) { _lambda = Math.Abs(smoothDiff / smoothRng); } //Alfa для альфа фильтра *************************************************************************** _alpha = (-_lambda * _lambda + (decimal)Math.Sqrt((double)(_lambda * _lambda * _lambda * _lambda + 16 * _lambda * _lambda))) / 8; //Smoothed result ********************************************************************************** var check2 = _alpha * average; var check3 = (1 - _alpha) * _resultOld; var result = check2 + check3; _resultOld = result; return(new DecimalIndicatorValue(this, result)); } _value2Old = halfRange; _resultOld = average; return(new DecimalIndicatorValue(this, _resultOld)); }
/// <inheritdoc /> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var newValue = input.GetValue <decimal>(); if (input.IsFinal) { Buffer.Add(newValue); if (Buffer.Count > Length) { Buffer.RemoveAt(0); } } var buff = Buffer; if (!input.IsFinal) { buff = new List <decimal>(); buff.AddRange(Buffer.Skip(1)); buff.Add(newValue); } //x - независимая переменная, номер значения в буфере //y - зависимая переменная - значения из буфера var sumX = 0m; //сумма x var sumY = 0m; //сумма y var sumXy = 0m; //сумма x*y var sumX2 = 0m; //сумма x^2 for (var i = 0; i < buff.Count; i++) { sumX += i; sumY += buff.ElementAt(i); sumXy += i * buff.ElementAt(i); sumX2 += i * i; } //коэффициент при независимой переменной var divisor = Length * sumX2 - sumX * sumX; if (divisor == 0) { return(new DecimalIndicatorValue(this)); } return(new DecimalIndicatorValue(this, (Length * sumXy - sumX * sumY) / divisor)); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var candle = input.GetValue <Candle>(); var highValue = _high.Process(input.SetValue(this, candle.HighPrice)).GetValue <decimal>(); var lowValue = _low.Process(input.SetValue(this, candle.LowPrice)).GetValue <decimal>(); var diff = highValue - lowValue; if (diff == 0) { return(new DecimalIndicatorValue(this, 0)); } return(new DecimalIndicatorValue(this, 100 * (candle.ClosePrice - lowValue) / diff)); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var candle = input.GetValue <Candle>(); if (candle.TotalVolume == 0) { return(new DecimalIndicatorValue(this)); } if (input.IsFinal) { IsFormed = true; } return(new DecimalIndicatorValue(this, (candle.HighPrice - candle.LowPrice) / candle.TotalVolume)); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var price = input.GetValue <Candle>().ClosePrice; if (Buffer.Count > Length) { Buffer.RemoveAt(0); } if (input.IsFinal) { Buffer.Add(price); } return(new DecimalIndicatorValue(this, price)); }
/// <summary> /// Обработать входное значение. /// </summary> /// <param name="input">Входное значение.</param> /// <returns>Результирующее значение.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var candle = input.GetValue <Candle>(); decimal?result = null; var buff = _buffer; if (input.IsFinal) { _buffer.Add(candle); // если буффер стал достаточно большим (стал больше длины) if (_buffer.Count > Length) { _buffer.RemoveAt(0); } } else { buff = _buffer.Skip(1).Concat(candle).ToList(); } if (buff.Count >= Length) { // рассчитываем значение var max = buff.Max(t => t.HighPrice); var min = buff.Min(t => t.LowPrice); if (Kijun.IsFormed && input.IsFinal) { Buffer.Add((max + min) / 2); } if (Buffer.Count >= Kijun.Length) { result = Buffer[0]; } if (Buffer.Count > Kijun.Length) { Buffer.RemoveAt(0); } } return(result == null ? new DecimalIndicatorValue(this) : new DecimalIndicatorValue(this, result.Value)); }
/// <inheritdoc /> protected override IIndicatorValue OnProcess(IIndicatorValue input) { if (input.IsFinal) { IsFormed = true; } var line1Curr = _line1.GetNullableCurrentValue(); var line2Curr = _line2.GetNullableCurrentValue(); if (line1Curr == null || line2Curr == null) { return(new DecimalIndicatorValue(this)); } return(new DecimalIndicatorValue(this, (_isNegative ? -1 : 1) * Math.Abs(line1Curr.Value - line2Curr.Value))); }
/// <inheritdoc /> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var candle = input.GetValue <Candle>(); var aveP = (candle.HighPrice + candle.LowPrice + candle.ClosePrice) / 3m; var meanValue = _mean.Process(new DecimalIndicatorValue(this, aveP) { IsFinal = input.IsFinal }); if (IsFormed && meanValue.GetValue <decimal>() != 0) { return(new DecimalIndicatorValue(this, ((aveP - _mean.Sma.GetCurrentValue()) / (0.015m * meanValue.GetValue <decimal>())))); } return(new DecimalIndicatorValue(this)); }
/// <summary> /// Обработать новые значения. /// </summary> /// <param name="time">Временная отметка формирования новых данных.</param> /// <param name="value">Значения индикатора.</param> /// <param name="draw">Метод отрисовки значения на графике.</param> /// <returns>Новые значения для отображения на графике.</returns> public override IEnumerable <decimal> ProcessValues(DateTimeOffset time, IIndicatorValue value, DrawHandler draw) { var newYValues = new List <decimal>(); if (!value.IsFormed) { draw(_pnl, 0, double.NaN, double.NaN); } else { var pnl = value.GetValue <decimal>(); draw(_pnl, 0, (double)pnl, (double)0); newYValues.Add(pnl); } return(newYValues); }
/// <inheritdoc /> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var cov = base.OnProcess(input); var value = input.GetValue <Tuple <decimal, decimal> >(); var sourceDev = _source.Process(value.Item1); var otherDev = _other.Process(value.Item2); var v = sourceDev.GetValue <decimal>() * otherDev.GetValue <decimal>(); if (v != 0) { v = cov.GetValue <decimal>() / v; } return(new DecimalIndicatorValue(this, v)); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var candle = input.GetValue <Candle>(); if (_previouseClosePrice != null) { var min = _previouseClosePrice.Value < candle.LowPrice ? _previouseClosePrice.Value : candle.LowPrice; var max = _previouseClosePrice.Value > candle.HighPrice ? _previouseClosePrice.Value : candle.HighPrice; input = input.SetValue(this, candle.ClosePrice - min); var p7BpValue = _period7BpSum.Process(input).GetValue <decimal>(); var p14BpValue = _period14BpSum.Process(input).GetValue <decimal>(); var p28BpValue = _period28BpSum.Process(input).GetValue <decimal>(); input = input.SetValue(this, max - min); var p7TrValue = _period7TrSum.Process(input).GetValue <decimal>(); var p14TrValue = _period14TrSum.Process(input).GetValue <decimal>(); var p28TrValue = _period28TrSum.Process(input).GetValue <decimal>(); if (input.IsFinal) { _previouseClosePrice = candle.ClosePrice; } if (p7TrValue != 0 && p14TrValue != 0 && p28TrValue != 0) { var average7 = p7BpValue / p7TrValue; var average14 = p14BpValue / p14TrValue; var average28 = p28BpValue / p28TrValue; return(new DecimalIndicatorValue(this, _stoProcentov * (_weight4 * average7 + _weight2 * average14 + _weight1 * average28) / (_weight4 + _weight2 + _weight1))); } return(new DecimalIndicatorValue(this)); } if (input.IsFinal) { _previouseClosePrice = candle.ClosePrice; } return(new DecimalIndicatorValue(this)); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { //если кол-во в буфере больше Shift, то первое значение отдали в прошлый раз, удалим его. if (Buffer.Count > Shift) { Buffer.RemoveAt(0); } var smaResult = _sma.Process(_medianPrice.Process(input)); if (_sma.IsFormed & input.IsFinal) { Buffer.Add(smaResult.GetValue <decimal>()); } return(Buffer.Count > Shift ? new DecimalIndicatorValue(this, Buffer[0]) : new DecimalIndicatorValue(this)); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> public virtual IIndicatorValue Process(IIndicatorValue input) { var result = OnProcess(input); result.InputValue = input; //var result = value as IIndicatorValue ?? input.SetValue(value); if (input.IsFinal) { result.IsFinal = input.IsFinal; Container.AddValue(input, result); } if (IsFormed && !result.IsEmpty) { RaiseChangedEvent(input, result); } return(result); }
/// <summary> /// Обработать входное значение. /// </summary> /// <param name="input">Входное значение.</param> /// <returns>Результирующее значение.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var value = base.OnProcess(input); if (IsFormed && !value.IsEmpty) { if (CurrentValue < value.GetValue <decimal>()) { return(value); } var lastValue = this.GetCurrentValue(); IsFormed = !lastValue.IsEmpty; return(IsFormed ? new ShiftedIndicatorValue(this, lastValue.Shift + 1, lastValue.Value) : lastValue); } IsFormed = false; return(value); }
/// <inheritdoc /> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var newValue = input.GetValue <decimal>(); if (input.IsFinal) { Buffer.Add(newValue); if ((Buffer.Count - 1) > Length) { Buffer.RemoveAt(0); } } if (Buffer.Count == 0) { return(new DecimalIndicatorValue(this)); } return(new DecimalIndicatorValue(this, newValue - Buffer[0])); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var smaValue = _sma.Process(input); if (_sma.IsFormed && input.IsFinal) { Buffer.Add(smaValue.GetValue <decimal>()); } if (!IsFormed) { return(new DecimalIndicatorValue(this)); } if (Buffer.Count > Length) { Buffer.RemoveAt(0); } return(new DecimalIndicatorValue(this, input.GetValue <decimal>() - Buffer[0])); }
/// <summary> /// Обработать входное значение. /// </summary> /// <param name="input">Входное значение.</param> /// <returns>Результирующее значение.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var newValue = input.GetValue <decimal>(); if (input.IsFinal) { Buffer.Add(newValue); if (Buffer.Count > Length) { Buffer.RemoveAt(0); } } if (input.IsFinal) { return(new DecimalIndicatorValue(this, Buffer.Sum() / Length)); } return(new DecimalIndicatorValue(this, (Buffer.Skip(1).Sum() + newValue) / Length)); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var candle = input.GetValue<Candle>(); if (_previouseClosePrice != null) { var min = _previouseClosePrice.Value < candle.LowPrice ? _previouseClosePrice.Value : candle.LowPrice; var max = _previouseClosePrice.Value > candle.HighPrice ? _previouseClosePrice.Value : candle.HighPrice; input = input.SetValue(this, candle.ClosePrice - min); var p7BpValue = _period7BpSum.Process(input).GetValue<decimal>(); var p14BpValue = _period14BpSum.Process(input).GetValue<decimal>(); var p28BpValue = _period28BpSum.Process(input).GetValue<decimal>(); input = input.SetValue(this, max - min); var p7TrValue = _period7TrSum.Process(input).GetValue<decimal>(); var p14TrValue = _period14TrSum.Process(input).GetValue<decimal>(); var p28TrValue = _period28TrSum.Process(input).GetValue<decimal>(); if (input.IsFinal) _previouseClosePrice = candle.ClosePrice; if (p7TrValue != 0 && p14TrValue != 0 && p28TrValue != 0) { var average7 = p7BpValue / p7TrValue; var average14 = p14BpValue / p14TrValue; var average28 = p28BpValue / p28TrValue; return new DecimalIndicatorValue(this, _stoProcentov * (_weight4 * average7 + _weight2 * average14 + _weight1 * average28) / (_weight4 + _weight2 + _weight1)); } return new DecimalIndicatorValue(this); } if (input.IsFinal) _previouseClosePrice = candle.ClosePrice; return new DecimalIndicatorValue(this); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var candle = input.GetValue<Candle>(); if (_prevCandle != null) { if (input.IsFinal) IsFormed = true; var priceMovements = GetPriceMovements(candle, _prevCandle); if (input.IsFinal) _prevCandle = candle; return new DecimalIndicatorValue(this, priceMovements.Max()); } if (input.IsFinal) _prevCandle = candle; return new DecimalIndicatorValue(this, candle.HighPrice - candle.LowPrice); }
protected override IIndicatorValue OnProcess(IIndicatorValue input) { var candle = input.GetValue <Candle>(); var medianPrice = (candle.ClosePrice + candle.OpenPrice + candle.HighPrice + candle.LowPrice) / 4m; Buffer.Add(medianPrice); Vector <double> val = DenseVector.Create(1, (i) => 0); val[0] = (double)medianPrice; RecalculateFilterParameters(val); if (Buffer.Count < 5) { return(new DecimalIndicatorValue(this, medianPrice)); } IsFormed = true; return(new DecimalIndicatorValue(this, (decimal)xplus[0])); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var newValue = input.IsSupport(typeof(Candle)) ? input.GetValue <Candle>().HighPrice : input.GetValue <decimal>(); var lastValue = Buffer.Count == 0 ? newValue : this.GetCurrentValue(); // добавляем новое начало if (input.IsFinal) { Buffer.Add(newValue); } if (newValue > lastValue) { // Новое значение и есть экстремум lastValue = newValue; } if (Buffer.Count > Length) { var first = Buffer[0]; // удаляем хвостовое значение if (input.IsFinal) { Buffer.RemoveAt(0); } // удаляется экстремум, для поиска нового значения необходим проход по всему буфферу if (first == lastValue && lastValue != newValue) { // ищем новый экстремум lastValue = Buffer.Aggregate(newValue, (current, t) => Math.Max(t, current)); } } return(new DecimalIndicatorValue(this, lastValue)); }
/// <summary> /// Обработать входное значение. /// </summary> /// <param name="input">Входное значение.</param> /// <returns>Результирующее значение.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var value = new ComplexIndicatorValue(this); foreach (var indicator in InnerIndicators) { var result = indicator.Process(input); value.InnerValues.Add(indicator, result); if (Mode == ComplexIndicatorModes.Sequence) { if (!indicator.IsFormed) { break; } input = result; } } return(value); }
/// <summary> /// Обработать входное значение. /// </summary> /// <param name="input">Входное значение.</param> /// <returns>Результирующее значение.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var value = new ComplexIndicatorValue(this); foreach (var indicator in InnerIndicators) { var result = indicator.Process(input); value.InnerValues.Add(indicator, result); if (Mode == ComplexIndicatorModes.Sequence) { if (!indicator.IsFormed) { break; } input = result; } } return value; }
protected override IIndicatorValue OnProcess(IIndicatorValue input) { var candle = input.GetValue<Candle>(); IsFormed = _security == null || candle.Security == _security; return new CandleIndicatorValue(this, candle, c => c.ClosePrice); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var candle = input.GetValue<Candle>(); if (_needAdd) { _buffer.Insert(0, candle); _lowBuffer.Insert(0, 0); _highBuffer.Insert(0, 0); _zigZagBuffer.Insert(0, 0); } else { _buffer[0] = candle; _lowBuffer[0] = 0; _highBuffer[0] = 0; _zigZagBuffer[0] = 0; } const int level = 3; int limit; decimal lastHigh = 0; decimal lastLow = 0; if (_buffer.Count - 1 == 0) { limit = _buffer.Count - Depth; } else { int i = 0, count = 0; while (count < level && i < _buffer.Count - Depth) { var res = _zigZagBuffer[i]; if (res != 0) { count++; } i++; } limit = --i; } for (var shift = limit; shift >= 0; shift--) { //--- low var val = _buffer.Skip(shift).Take(Depth).Min(v => _lowValue(v)); if (val == lastLow) { val = 0.0m; } else { lastLow = val; if (_lowValue(_buffer[shift]) - val > 0.0m * val / 100) { val = 0.0m; } else { for (var back = 1; back <= BackStep; back++) { var res = _lowBuffer[shift + back]; if (res != 0 && res > val) { _lowBuffer[shift + back] = 0.0m; } } } } if (_lowValue(_buffer[shift]) == val) _lowBuffer[shift] = val; else _lowBuffer[shift] = 0m; //--- high val = _buffer.Skip(shift).Take(Depth).Max(v => _highValue(v)); if (val == lastHigh) { val = 0.0m; } else { lastHigh = val; if (val - _highValue(_buffer[shift]) > 0.0m * val / 100) { val = 0.0m; } else { for (var back = 1; back <= BackStep; back++) { var res = _highBuffer[shift + back]; if (res != 0 && res < val) { _highBuffer[shift + back] = 0.0m; } } } } if (_highValue(_buffer[shift]) == val) _highBuffer[shift] = val; else _highBuffer[shift] = 0m; } // final cutting lastHigh = -1; lastLow = -1; var lastHighPos = -1; var lastLowPos = -1; for (var shift = limit; shift >= 0; shift--) { var curLow = _lowBuffer[shift]; var curHigh = _highBuffer[shift]; if ((curLow == 0) && (curHigh == 0)) continue; //--- if (curHigh != 0) { if (lastHigh > 0) { if (lastHigh < curHigh) { _highBuffer[lastHighPos] = 0; } else { _highBuffer[shift] = 0; } } //--- if (lastHigh < curHigh || lastHigh < 0) { lastHigh = curHigh; lastHighPos = shift; } lastLow = -1; } //---- if (curLow != 0) { if (lastLow > 0) { if (lastLow > curLow) { _lowBuffer[lastLowPos] = 0; } else { _lowBuffer[shift] = 0; } } //--- if ((curLow < lastLow) || (lastLow < 0)) { lastLow = curLow; lastLowPos = shift; } lastHigh = -1; } } for (var shift = limit; shift >= 0; shift--) { if (shift >= _buffer.Count - Depth) { _zigZagBuffer[shift] = 0.0m; } else { var res = _highBuffer[shift]; if (res != 0.0m) { _zigZagBuffer[shift] = res; } else { _zigZagBuffer[shift] = _lowBuffer[shift]; } } } int valuesCount = 0, valueId = 0; for (; valueId < _zigZagBuffer.Count && valuesCount < 2; valueId++) { if (_zigZagBuffer[valueId] != 0) valuesCount++; } _needAdd = input.IsFinal; if (valuesCount != 2) return new DecimalIndicatorValue(this); if (input.IsFinal) IsFormed = true; LastValueShift = valueId - 1; CurrentValue = _currentValue(_buffer[0]); return new DecimalIndicatorValue(this, _zigZagBuffer[LastValueShift]); }
public override IEnumerable<decimal> ProcessValues(DateTimeOffset time, IIndicatorValue value, DrawHandler draw) { var newYValues = new List<decimal>(); if (!value.IsFormed) { draw(_pnl, 0, double.NaN, double.NaN); } else { var pnl = value.GetValue<decimal>(); draw(_pnl, 0, (double)pnl, (double)0); newYValues.Add(pnl); } return newYValues; }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var shortValue = ShortMa.Process(input); var longValue = LongMa.Process(input); return new DecimalIndicatorValue(this, shortValue.GetValue<decimal>() - longValue.GetValue<decimal>()); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { return new DecimalIndicatorValue(this, _ma.GetCurrentValue() + (Width * _dev.GetCurrentValue())); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { _alligator.Process(input); return base.OnProcess(input); }
/// <summary> /// Add new values. /// </summary> /// <param name="input">The input value of the indicator.</param> /// <param name="result">The resulting value of the indicator.</param> public virtual void AddValue(IIndicatorValue input, IIndicatorValue result) { _values.Add(Tuple.Create(input, result)); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var value = (ComplexIndicatorValue)base.OnProcess(input); var upper = value.InnerValues[Upper]; value.InnerValues[Upper] = upper.SetValue(this, upper.GetValue<decimal>() * (1 + Shift)); var lower = value.InnerValues[Lower]; value.InnerValues[Lower] = lower.SetValue(this, lower.GetValue<decimal>() * (1 - Shift)); return value; }
/// <summary> /// Обработать входное значение. /// </summary> /// <param name="input">Входное значение.</param> /// <returns>Результирующее значение.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var candle = input.GetValue<Candle>(); if (_candles.Count == 0) _candles.Add(candle); _prevValue = this.GetCurrentValue(); if (candle.OpenTime != _candles[_candles.Count - 1].OpenTime) { _candles.Add(candle); //_prevValue = this.GetCurrentValue(); } else _candles[_candles.Count - 1] = candle; if (_candles.Count < 3) return new DecimalIndicatorValue(this, _prevValue); if (_candles.Count == 3) { _longPosition = _candles[_candles.Count - 1].HighPrice > _candles[_candles.Count - 2].HighPrice; var max = _candles.Max(t => t.HighPrice); var min = _candles.Min(t => t.LowPrice); _xp = _longPosition ? max : min; _af = Acceleration; return new DecimalIndicatorValue(this, _xp + (_longPosition ? -1 : 1) * (max - min) * _af); } if (_afIncreased && _prevBar != _candles.Count) _afIncreased = false; if (input.IsFinal) IsFormed = true; var value = _prevValue; if (_reverseBar != _candles.Count) { _todaySar = TodaySar(_prevValue + _af * (_xp - _prevValue)); for (var x = 1; x <= 2; x++) { if (_longPosition) { if (_todaySar > _candles[_candles.Count - 1 - x].LowPrice) _todaySar = _candles[_candles.Count - 1 - x].LowPrice; } else { if (_todaySar < _candles[_candles.Count - 1 - x].HighPrice) _todaySar = _candles[_candles.Count - 1 - x].HighPrice; } } if ((_longPosition && (_candles[_candles.Count - 1].LowPrice < _todaySar || _candles[_candles.Count - 2].LowPrice < _todaySar)) || (!_longPosition && (_candles[_candles.Count - 1].HighPrice > _todaySar || _candles[_candles.Count - 2].HighPrice > _todaySar))) { return new DecimalIndicatorValue(this, Reverse()); } if (_longPosition) { if (_prevBar != _candles.Count || _candles[_candles.Count - 1].LowPrice < _prevSar) { value = _todaySar; _prevSar = _todaySar; } else value = _prevSar; if (_candles[_candles.Count - 1].HighPrice > _xp) { _xp = _candles[_candles.Count - 1].HighPrice; AfIncrease(); } } else if (!_longPosition) { if (_prevBar != _candles.Count || _candles[_candles.Count - 1].HighPrice > _prevSar) { value = _todaySar; _prevSar = _todaySar; } else value = _prevSar; if (_candles[_candles.Count - 1].LowPrice < _xp) { _xp = _candles[_candles.Count - 1].LowPrice; AfIncrease(); } } } else { if (_longPosition && _candles[_candles.Count - 1].HighPrice > _xp) _xp = _candles[_candles.Count - 1].HighPrice; else if (!_longPosition && _candles[_candles.Count - 1].LowPrice < _xp) _xp = _candles[_candles.Count - 1].LowPrice; value = _prevSar; _todaySar = TodaySar(_longPosition ? Math.Min(_reverseValue, _candles[_candles.Count - 1].LowPrice) : Math.Max(_reverseValue, _candles[_candles.Count - 1].HighPrice)); } _prevBar = _candles.Count; return new DecimalIndicatorValue(this, value); }
/// <summary> /// Обработать входное значение. /// </summary> /// <param name="input">Входное значение.</param> /// <returns>Результирующее значение.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { _dev.Process(input); var maValue = MovingAverage.Process(input); var value = new ComplexIndicatorValue(this); value.InnerValues.Add(MovingAverage, maValue); value.InnerValues.Add(UpBand, UpBand.Process(input)); value.InnerValues.Add(LowBand, LowBand.Process(input)); return value; }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var candle = input.GetValue<Candle>(); var buffer = input.IsFinal ? _buffer : _buffer.ToList(); buffer.Add(candle); // если буфер стал достаточно большим (стал больше длины) if (buffer.Count > Length) { // Запоминаем интересующие изменения свечек до буфера if (buffer[0].HighPrice > buffer[1].HighPrice) _wasHighDown = true; else if (buffer[0].HighPrice < buffer[1].HighPrice) _wasHighDown = false; if (buffer[0].LowPrice < buffer[1].LowPrice) _wasLowUp = true; else if (buffer[0].LowPrice > buffer[1].LowPrice) _wasLowUp = false; buffer.RemoveAt(0); } // Логика расчета: последующие/предыдущие значения должны быть меньше/больше центрального значения if (buffer.Count >= Length) { // флаги для расчета фракталов (если флаг равен false, то на центральной свече нет фрактала) var isMax = true; var isMin = true; var centerHighPrice = buffer[_numCenter].HighPrice; var centerLowPrice = buffer[_numCenter].LowPrice; for (var i = 0; i < buffer.Count; i++) { if (i == _numCenter) continue; // Все значения до и после центральной свечи должны быть // больше для фрактала вверх и меньше для фрактала вниз if (buffer[i].HighPrice > centerHighPrice) { isMax = false; } if (buffer[i].LowPrice < centerLowPrice) { isMin = false; } } // Фильтр для ситуаций где цена у экстремума одинакова за период больше длины буфера if (isMax && _wasHighDown && buffer.GetRange(0, _numCenter).Min(i => i.HighPrice) == centerHighPrice) { isMax = false; } if (isMin && _wasLowUp && buffer.GetRange(0, _numCenter).Max(i => i.LowPrice) == centerLowPrice) { isMin = false; } var shift = buffer.Count - _numCenter - 1; var upValue = isMax ? new ShiftedIndicatorValue(this, shift, new DecimalIndicatorValue(this, centerHighPrice)) : new ShiftedIndicatorValue(this); var downValue = isMin ? new ShiftedIndicatorValue(this, shift, new DecimalIndicatorValue(this, centerLowPrice)) : new ShiftedIndicatorValue(this); upValue.IsFinal = input.IsFinal; downValue.IsFinal = input.IsFinal; var complexValue = new ComplexIndicatorValue(this); complexValue.InnerValues.Add(Up, Up.Process(upValue)); complexValue.InnerValues.Add(Down, Down.Process(downValue)); return complexValue; } return base.OnProcess(new ShiftedIndicatorValue(this, 0, input.SetValue(this, 0))); }
/// <summary> /// To handle the input value. /// </summary> /// <param name="input">The input value.</param> /// <returns>The resulting value.</returns> protected override IIndicatorValue OnProcess(IIndicatorValue input) { var value = _byPrice(input.GetValue<Candle>()); if (_needAdd) { _buffer.Add(value); _zigZagBuffer.Add(0); } else { _buffer[_buffer.Count - 1] = value; _zigZagBuffer[_zigZagBuffer.Count - 1] = 0; } const int level = 3; int limit = 0, count = 0; while (count < level && limit >= 0) { var res = _zigZagBuffer[limit]; if (res != 0) { count++; } limit--; } limit++; var min = _buffer[limit]; var max = min; int action = 0, j = 0; for (var i = limit + 1; i < _buffer.Count; i++) { if (_buffer[i] > max) { max = _buffer[i]; if (action != 2) //action=1:building the down-point (min) of ZigZag { if (max - min >= _deviation * min) //min (action!=2) end,max (action=2) begin { action = 2; _zigZagBuffer[i] = max; j = i; min = max; } else _zigZagBuffer[i] = 0.0m; //max-min=miser,(action!=2) continue } else //max (action=2) continue { _zigZagBuffer[j] = 0.0m; _zigZagBuffer[i] = max; j = i; min = max; } } else if (_buffer[i] < min) { min = _buffer[i]; if (action != 1) //action=2:building the up-point (max) of ZigZag { if (max - min >= _deviation * max) //max (action!=1) end,min (action=1) begin { action = 1; _zigZagBuffer[i] = min; j = i; max = min; } else _zigZagBuffer[i] = 0.0m; //max-min=miser,(action!=1) continue } else //min (action=1) continue { _zigZagBuffer[j] = 0.0m; _zigZagBuffer[i] = min; j = i; max = min; } } else _zigZagBuffer[i] = 0.0m; } int valuesCount = 0, valueId = 0; decimal last = 0, lastButOne = 0; for (var i = _zigZagBuffer.Count - 1; i > 0 && valuesCount < 2; i--, valueId++) { if (_zigZagBuffer[i] == 0) continue; valuesCount++; if (valuesCount == 1) last = _zigZagBuffer[i]; else lastButOne = _zigZagBuffer[i]; } _needAdd = input.IsFinal; if (valuesCount != 2) return Container.Count > 1 ? this.GetCurrentValue<ShiftedIndicatorValue>() : new ShiftedIndicatorValue(this); if (input.IsFinal) IsFormed = true; CurrentValue = last; return new ShiftedIndicatorValue(this, valueId - 1, input.SetValue(this, lastButOne)); }