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