//15 minute events here:
public void OnFiftenMinuteSPY(object sender, TradeBar data)
{
if (!Portfolio.Invested)
{
SetHoldings("SPY", 1.0);
}
}
public void ResetsProperly()
{
var mfi = new MoneyFlowIndex(3);
foreach (var data in TestHelper.GetDataStream(4))
{
var tradeBar = new TradeBar
{
Open = data.Value,
Close = data.Value,
High = data.Value,
Low = data.Value,
Volume = Decimal.ToInt64(data.Value)
};
mfi.Update(tradeBar);
}
Assert.IsTrue(mfi.IsReady);
Assert.IsTrue(mfi.PositiveMoneyFlow.IsReady);
Assert.IsTrue(mfi.NegativeMoneyFlow.IsReady);
Assert.AreNotEqual(mfi.PreviousTypicalPrice, 0.0m);
mfi.Reset();
Assert.AreEqual(mfi.PreviousTypicalPrice, 0.0m);
TestHelper.AssertIndicatorIsInDefaultState(mfi);
TestHelper.AssertIndicatorIsInDefaultState(mfi.PositiveMoneyFlow);
TestHelper.AssertIndicatorIsInDefaultState(mfi.NegativeMoneyFlow);
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="window">The window of data held in this indicator</param>
/// <param name="input">The input given to the indicator</param>
/// <returns>A new value for this indicator</returns>
protected override decimal ComputeNextValue(IReadOnlyWindow<TradeBar> window, TradeBar input)
{
if (!IsReady)
{
return 0m;
}
decimal value;
if (
// white engulfs black
(GetCandleColor(input) == CandleColor.White && GetCandleColor(window[1]) == CandleColor.Black &&
input.Close > window[1].Open && input.Open < window[1].Close
)
||
// black engulfs white
(GetCandleColor(input) == CandleColor.Black && GetCandleColor(window[1]) == CandleColor.White &&
input.Open > window[1].Close && input.Close < window[1].Open
)
)
value = (int)GetCandleColor(input);
else
value = 0;
return value;
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="input">The input given to the indicator</param>
/// <returns> A new value for this indicator </returns>
protected override decimal ComputeNextValue(TradeBar input)
{
var obv = Current.Value;
if (_previousInput != null && input.Value > _previousInput.Value)
{
if (Current.Value != 0)
{
obv = input.Volume + Current.Value;
Update(input);
_previousInput = input;
return obv;
}
}
if (_previousInput != null && input.Value < _previousInput.Value)
{
if (Current.Value != 0)
{
obv = Current.Value - input.Volume;
Update(input);
_previousInput = input;
return obv;
}
}
_previousInput = input;
return obv;
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="window">The window of data held in this indicator</param>
/// <param name="input">The input given to the indicator</param>
/// <returns>A new value for this indicator</returns>
protected override decimal ComputeNextValue(IReadOnlyWindow<TradeBar> window, TradeBar input)
{
if (!IsReady)
{
if (Samples >= Period - _bodyLongAveragePeriod)
{
_bodyLongPeriodTotal += GetCandleRange(CandleSettingType.BodyLong, window[4]);
}
return 0m;
}
decimal value;
if (
// 1st long
GetRealBody(window[4]) > GetCandleAverage(CandleSettingType.BodyLong, _bodyLongPeriodTotal, window[4]) &&
// 1st, 2nd, 4th same color, 5th opposite
GetCandleColor(window[4]) == GetCandleColor(window[3]) &&
GetCandleColor(window[3]) == GetCandleColor(window[1]) &&
(int)GetCandleColor(window[1]) == -(int)GetCandleColor(input) &&
(
(
// when 1st is black:
GetCandleColor(window[4]) == CandleColor.Black &&
// 2nd gaps down
GetRealBodyGapDown(window[3], window[4]) &&
// 3rd has lower high and low than 2nd
window[2].High < window[3].High && window[2].Low < window[3].Low &&
// 4th has lower high and low than 3rd
window[1].High < window[2].High && window[1].Low < window[2].Low &&
// 5th closes inside the gap
input.Close > window[3].Open && input.Close < window[4].Close
)
||
(
// when 1st is white:
GetCandleColor(window[4]) == CandleColor.White &&
// 2nd gaps up
GetRealBodyGapUp(window[3], window[4]) &&
// 3rd has higher high and low than 2nd
window[2].High > window[3].High && window[2].Low > window[3].Low &&
// 4th has higher high and low than 3rd
window[1].High > window[2].High && window[1].Low > window[2].Low &&
// 5th closes inside the gap
input.Close < window[3].Open && input.Close > window[4].Close
)
)
)
value = (int)GetCandleColor(input);
else
value = 0m;
// add the current range and subtract the first range: this is done after the pattern recognition
// when avgPeriod is not 0, that means "compare with the previous candles" (it excludes the current candle)
_bodyLongPeriodTotal += GetCandleRange(CandleSettingType.BodyLong, window[4]) -
GetCandleRange(CandleSettingType.BodyLong, window[4 + _bodyLongAveragePeriod]);
return value;
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="input">The trade bar input given to the indicator</param>
/// <returns>A new value for this indicator</returns>
protected override decimal ComputeNextValue(TradeBar input)
{
// On first iteration we can’t produce an SAR value so we save the current bar and return zero
if (Samples == 1)
{
_previousBar = input;
// return a value that's close to where we will be, returning 0 doesn't make sense
return input.Close;
}
// On second iteration we initiate the position the extreme point and the SAR
if (Samples == 2)
{
Init(input);
_previousBar = input;
return _sar;
}
if (_isLong)
{
HandleLongPosition(input);
}
else
{
HandleShortPosition(input);
}
_previousBar = input;
return _outputSar;
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="input">The input given to the indicator</param>
/// <returns>A new value for this indicator</returns>
protected override decimal ComputeNextValue(TradeBar input)
{
AroonUp.Update(input.Time, input.High);
AroonDown.Update(input.Time, input.Low);
return AroonUp - AroonDown;
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="window">The window of data held in this indicator</param>
/// <param name="input">The input given to the indicator</param>
/// <returns>A new value for this indicator</returns>
protected override decimal ComputeNextValue(IReadOnlyWindow<TradeBar> window, TradeBar input)
{
if (!IsReady)
{
if (Samples >= Period - _equalAveragePeriod)
{
_equalPeriodTotal += GetCandleRange(CandleSettingType.Equal, window[1]);
}
return 0m;
}
decimal value;
if (
// first black
GetCandleColor(window[1]) == CandleColor.Black &&
// second black
GetCandleColor(input) == CandleColor.Black &&
// 1st and 2nd same close
input.Close <= window[1].Close + GetCandleAverage(CandleSettingType.Equal, _equalPeriodTotal, window[1]) &&
input.Close >= window[1].Close - GetCandleAverage(CandleSettingType.Equal, _equalPeriodTotal, window[1])
)
value = 1m;
else
value = 0m;
// add the current range and subtract the first range: this is done after the pattern recognition
// when avgPeriod is not 0, that means "compare with the previous candles" (it excludes the current candle)
_equalPeriodTotal += GetCandleRange(CandleSettingType.Equal, window[1]) -
GetCandleRange(CandleSettingType.Equal, window[_equalAveragePeriod + 1]);
return value;
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="window">The window of data held in this indicator</param>
/// <param name="input">The input given to the indicator</param>
/// <returns>A new value for this indicator</returns>
protected override decimal ComputeNextValue(IReadOnlyWindow<TradeBar> window, TradeBar input)
{
if (!IsReady)
{
return 0m;
}
decimal value;
if (
(
// white engulfs black
GetCandleColor(window[1]) == CandleColor.White && GetCandleColor(window[2]) == CandleColor.Black &&
window[1].Close > window[2].Open && window[1].Open < window[2].Close &&
// third candle higher
input.Close > window[1].Close
)
||
(
// black engulfs white
GetCandleColor(window[1]) == CandleColor.Black && GetCandleColor(window[2]) == CandleColor.White &&
window[1].Open > window[2].Close && window[1].Close < window[2].Open &&
// third candle lower
input.Close < window[1].Close
)
)
value = (int)GetCandleColor(window[1]);
else
value = 0;
return value;
}
public void UpdatesProperly()
{
var bar = new TradeBar();
bar.UpdateTrade(10, 10);
Assert.AreEqual(10, bar.Open);
Assert.AreEqual(10, bar.High);
Assert.AreEqual(10, bar.Low);
Assert.AreEqual(10, bar.Close);
Assert.AreEqual(10, bar.Volume);
bar.UpdateTrade(20, 5);
Assert.AreEqual(10, bar.Open);
Assert.AreEqual(20, bar.High);
Assert.AreEqual(10, bar.Low);
Assert.AreEqual(20, bar.Close);
Assert.AreEqual(15, bar.Volume);
bar.UpdateTrade(5, 50);
Assert.AreEqual(10, bar.Open);
Assert.AreEqual(20, bar.High);
Assert.AreEqual(5, bar.Low);
Assert.AreEqual(5, bar.Close);
Assert.AreEqual(65, bar.Volume);
bar.UpdateTrade(11, 100);
Assert.AreEqual(10, bar.Open);
Assert.AreEqual(20, bar.High);
Assert.AreEqual(5, bar.Low);
Assert.AreEqual(11, bar.Close);
Assert.AreEqual(165, bar.Volume);
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="window">The window of data held in this indicator</param>
/// <param name="input">The input given to the indicator</param>
/// <returns>A new value for this indicator</returns>
protected override decimal ComputeNextValue(IReadOnlyWindow<TradeBar> window, TradeBar input)
{
if (!IsReady)
{
if (Samples >= Period - _bodyShortAveragePeriod)
{
_bodyShortPeriodTotal += GetCandleRange(CandleSettingType.BodyShort, input);
}
return 0m;
}
decimal value;
if (GetRealBody(input) < GetCandleAverage(CandleSettingType.BodyShort, _bodyShortPeriodTotal, input) &&
GetUpperShadow(input) > GetRealBody(input) &&
GetLowerShadow(input) > GetRealBody(input)
)
value = (int)GetCandleColor(input);
else
value = 0m;
// add the current range and subtract the first range: this is done after the pattern recognition
// when avgPeriod is not 0, that means "compare with the previous candles" (it excludes the current candle)
_bodyShortPeriodTotal += GetCandleRange(CandleSettingType.BodyShort, input) -
GetCandleRange(CandleSettingType.BodyShort, window[_bodyShortAveragePeriod]);
return value;
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="input">The input given to the indicator</param>
/// <returns> A new value for this indicator </returns>
protected override decimal ComputeNextValue(TradeBar input)
{
var obv = Current.Value;
if (_previousInput != null)
{
if (input.Value > _previousInput.Value)
{
obv += input.Volume;
Update(input);
}
else if (input.Value < _previousInput.Value)
{
obv -= input.Volume;
Update(input);
}
}
else
{
obv = input.Volume;
Update(input);
}
_previousInput = input;
return obv;
}
/// <summary>
/// Computes whether we have found a two bar pattern
/// </summary>
/// <param name="input">TradeBar - the current bar</param>
/// <returns></returns>
protected override decimal ComputeNextValue(TradeBar input)
{
BarsWindow.Add(input);
if (!IsReady) return 0;
if (Math.Abs(BarsWindow[0].Open - BarsWindow[0].Close) > MinimumBarSize)
{
if (UseBody)
{
if (Math.Abs(BarsWindow[0].Open - BarsWindow[1].Close) < BarDifferenceTolerance &&
Math.Abs(BarsWindow[0].Close - BarsWindow[1].Open) < BarDifferenceTolerance)
{
// 1 for up bar, -1 for down bar
return BarsWindow[0].Open < BarsWindow[0].Close ? 1m : -1m;
}
}
else
{
if (Math.Abs(BarsWindow[0].High - BarsWindow[1].Low) < BarDifferenceTolerance &&
Math.Abs(BarsWindow[0].Low - BarsWindow[1].High) < BarDifferenceTolerance)
{
// 1 for up bar, -1 for down bar
return BarsWindow[0].Low < BarsWindow[0].High ? 1m : -1m;
}
}
}
return 0;
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="input">The input given to the indicator</param>
/// <returns>A new value for this indicator</returns>
protected override decimal ComputeNextValue(TradeBar input)
{
_maximum.Update(new IndicatorDataPoint { Value = input.High });
_minimum.Update(new IndicatorDataPoint { Value = input.Low });
return (_maximum + _minimum) / 2;
}
/// <summary>
/// Logs the OrderEvent Transaction
/// </summary>
public void ReportDailyBar(TradeBar tradeBar)
{
#region "Print"
if(!HasPrintedHeading)
{
ReportHeading(_algorithm.Name);
HasPrintedHeading = true;
}
StringBuilder sb = new StringBuilder();
string msg = (string.Format(
"{0},{1},{2},{3},{4},{5}",
tradeBar.Time,
barcount++,
tradeBar.Open,
tradeBar.High,
tradeBar.Low,
tradeBar.Close
));
sb.Append(msg);
foreach (var item in ColumnList)
{
sb.Append(",");
sb.Append(item.Value);
}
_logHandler.Debug(sb.ToString());
#endregion
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="input">The input given to the indicator</param>
/// <returns>A new value for this indicator</returns>
protected override decimal ComputeNextValue(TradeBar input)
{
_trueRange.Update(input);
if (Samples == 1)
{
_previousInput = input;
return 50m;
}
var buyingPressure = new IndicatorDataPoint { Value = input.Close - Math.Min(input.Low, _previousInput.Close) };
_sumBuyingPressure1.Update(buyingPressure);
_sumBuyingPressure2.Update(buyingPressure);
_sumBuyingPressure3.Update(buyingPressure);
_sumTrueRange1.Update(_trueRange.Current);
_sumTrueRange2.Update(_trueRange.Current);
_sumTrueRange3.Update(_trueRange.Current);
_previousInput = input;
if (!IsReady)
return 50m;
var average1 = _sumBuyingPressure1 / _sumTrueRange1;
var average2 = _sumBuyingPressure2 / _sumTrueRange2;
var average3 = _sumBuyingPressure3 / _sumTrueRange3;
return 100m * (4 * average1 + 2 * average2 + average3) / 7;
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="window">The window of data held in this indicator</param>
/// <param name="input">The input given to the indicator</param>
/// <returns>A new value for this indicator</returns>
protected override decimal ComputeNextValue(IReadOnlyWindow<TradeBar> window, TradeBar input)
{
if (!IsReady)
{
if (Samples >= Period - _bodyShortAveragePeriod)
{
_bodyShortPeriodTotal += GetCandleRange(CandleSettingType.BodyShort, input);
}
if (Samples >= Period - _shadowLongAveragePeriod)
{
_shadowLongPeriodTotal += GetCandleRange(CandleSettingType.ShadowLong, input);
}
if (Samples >= Period - _shadowVeryShortAveragePeriod)
{
_shadowVeryShortPeriodTotal += GetCandleRange(CandleSettingType.ShadowVeryShort, input);
}
if (Samples >= Period - _nearAveragePeriod - 1 && Samples < Period - 1)
{
_nearPeriodTotal += GetCandleRange(CandleSettingType.Near, input);
}
return 0m;
}
decimal value;
if (
// small rb
GetRealBody(input) < GetCandleAverage(CandleSettingType.BodyShort, _bodyShortPeriodTotal, input) &&
// long lower shadow
GetLowerShadow(input) > GetCandleAverage(CandleSettingType.ShadowLong, _shadowLongPeriodTotal, input) &&
// very short upper shadow
GetUpperShadow(input) < GetCandleAverage(CandleSettingType.ShadowVeryShort, _shadowVeryShortPeriodTotal, input) &&
// rb near the prior candle's highs
Math.Min(input.Close, input.Open) >= window[1].High - GetCandleAverage(CandleSettingType.Near, _nearPeriodTotal, window[1])
)
value = -1m;
else
value = 0m;
// add the current range and subtract the first range: this is done after the pattern recognition
// when avgPeriod is not 0, that means "compare with the previous candles" (it excludes the current candle)
_bodyShortPeriodTotal += GetCandleRange(CandleSettingType.BodyShort, input) -
GetCandleRange(CandleSettingType.BodyShort, window[_bodyShortAveragePeriod]);
_shadowLongPeriodTotal += GetCandleRange(CandleSettingType.ShadowLong, input) -
GetCandleRange(CandleSettingType.ShadowLong, window[_shadowLongAveragePeriod]);
_shadowVeryShortPeriodTotal += GetCandleRange(CandleSettingType.ShadowVeryShort, input) -
GetCandleRange(CandleSettingType.ShadowVeryShort, window[_shadowVeryShortAveragePeriod]);
_nearPeriodTotal += GetCandleRange(CandleSettingType.Near, window[1]) -
GetCandleRange(CandleSettingType.Near, window[_nearAveragePeriod + 1]);
return value;
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="window">The window of data held in this indicator</param>
/// <param name="input">The input given to the indicator</param>
/// <returns>A new value for this indicator</returns>
protected override decimal ComputeNextValue(IReadOnlyWindow<TradeBar> window, TradeBar input)
{
if (!IsReady)
{
if (Samples >= Period - _nearAveragePeriod)
{
_nearPeriodTotal += GetCandleRange(CandleSettingType.Equal, window[1]);
}
return 0m;
}
decimal value;
if (
(
// upside gap
GetRealBodyGapUp(window[1], window[2]) &&
// 1st: white
GetCandleColor(window[1]) == CandleColor.White &&
// 2nd: black
GetCandleColor(input) == CandleColor.Black &&
// that opens within the white rb
input.Open < window[1].Close && input.Open > window[1].Open &&
// and closes under the white rb
input.Close < window[1].Open &&
// inside the gap
input.Close > Math.Max(window[2].Close, window[2].Open) &&
// size of 2 rb near the same
Math.Abs(GetRealBody(window[1]) - GetRealBody(input)) < GetCandleAverage(CandleSettingType.Near, _nearPeriodTotal, window[1])
) ||
(
// downside gap
GetRealBodyGapDown(window[1], window[2]) &&
// 1st: black
GetCandleColor(window[1]) == CandleColor.Black &&
// 2nd: white
GetCandleColor(input) == CandleColor.White &&
// that opens within the black rb
input.Open < window[1].Open && input.Open > window[1].Close &&
// and closes above the black rb
input.Close > window[1].Open &&
// inside the gap
input.Close < Math.Min(window[2].Close, window[2].Open) &&
// size of 2 rb near the same
Math.Abs(GetRealBody(window[1]) - GetRealBody(input)) < GetCandleAverage(CandleSettingType.Near, _nearPeriodTotal, window[1])
)
)
value = (int)GetCandleColor(window[1]);
else
value = 0m;
// add the current range and subtract the first range: this is done after the pattern recognition
// when avgPeriod is not 0, that means "compare with the previous candles" (it excludes the current candle)
_nearPeriodTotal += GetCandleRange(CandleSettingType.Near, window[1]) -
GetCandleRange(CandleSettingType.Near, window[_nearAveragePeriod + 1]);
return value;
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="input">The input given to the indicator</param>
/// <returns>A new value for this indicator</returns>
protected override decimal ComputeNextValue(TradeBar input)
{
_ad.Update(input);
_emaFast.Update(_ad.Current);
_emaSlow.Update(_ad.Current);
return IsReady ? _emaFast.Current.Value - _emaSlow.Current.Value : 0m;
}
public void AccessesTradeBarBySymbol()
{
TradeBar tradeBar = new TradeBar {Symbol = Symbols.SPY, Time = DateTime.Now};
Slice slice = new Slice(DateTime.Now, new[] { tradeBar });
TradeBar data = slice[tradeBar.Symbol];
Assert.AreEqual(tradeBar, data);
}
public void AccessesTradeBarCollection()
{
TradeBar tradeBar1 = new TradeBar { Symbol = Symbols.SPY, Time = DateTime.Now };
TradeBar tradeBar2 = new TradeBar { Symbol = Symbols.AAPL, Time = DateTime.Now };
Slice slice = new Slice(DateTime.Now, new[] { tradeBar1, tradeBar2 });
TradeBars tradeBars = slice.Bars;
Assert.AreEqual(2, tradeBars.Count);
}
public decimal Calculate(TradeBar data, OrderSignal signal, decimal rangeFactor)
{
decimal nLimitPrice = 0;
if (signal == OrderSignal.goLongLimit)
nLimitPrice = Math.Round(Math.Max(data.Low, (data.Close - (data.High - data.Low) * rangeFactor)), 2, MidpointRounding.ToEven);
if (signal == OrderSignal.goShortLimit)
nLimitPrice = Math.Round(Math.Min(data.High, (data.Close + (data.High - data.Low) * rangeFactor)), 2, MidpointRounding.ToEven);
return nLimitPrice;
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="window">The window of data held in this indicator</param>
/// <param name="input">The input given to the indicator</param>
/// <returns>A new value for this indicator</returns>
protected override decimal ComputeNextValue(IReadOnlyWindow<TradeBar> window, TradeBar input)
{
if (!IsReady)
{
if (Samples >= Period - _bodyDojiAveragePeriod)
{
_bodyDojiPeriodTotal += GetCandleRange(CandleSettingType.BodyDoji, input);
}
if (Samples >= Period - _shadowLongAveragePeriod)
{
_shadowLongPeriodTotal += GetCandleRange(CandleSettingType.ShadowLong, input);
}
if (Samples >= Period - _nearAveragePeriod)
{
_nearPeriodTotal += GetCandleRange(CandleSettingType.Near, input);
}
return 0m;
}
decimal value;
if (
// doji
GetRealBody(input) <= GetCandleAverage(CandleSettingType.BodyDoji, _bodyDojiPeriodTotal, input) &&
// long shadow
GetLowerShadow(input) > GetCandleAverage(CandleSettingType.ShadowLong, _shadowLongPeriodTotal, input) &&
// long shadow
GetUpperShadow(input) > GetCandleAverage(CandleSettingType.ShadowLong, _shadowLongPeriodTotal, input) &&
// body near midpoint
(
Math.Min(input.Open, input.Close)
<= input.Low + GetHighLowRange(input) / 2 + GetCandleAverage(CandleSettingType.Near, _nearPeriodTotal, input)
&&
Math.Max(input.Open, input.Close)
>= input.Low + GetHighLowRange(input) / 2 - GetCandleAverage(CandleSettingType.Near, _nearPeriodTotal, input)
)
)
value = 1m;
else
value = 0m;
// add the current range and subtract the first range: this is done after the pattern recognition
// when avgPeriod is not 0, that means "compare with the previous candles" (it excludes the current candle)
_bodyDojiPeriodTotal += GetCandleRange(CandleSettingType.BodyDoji, input) -
GetCandleRange(CandleSettingType.BodyDoji, window[_bodyDojiAveragePeriod]);
_shadowLongPeriodTotal += GetCandleRange(CandleSettingType.ShadowLong, input) -
GetCandleRange(CandleSettingType.ShadowLong, window[_shadowLongAveragePeriod]);
_nearPeriodTotal += GetCandleRange(CandleSettingType.Near, input) -
GetCandleRange(CandleSettingType.Near, window[_nearAveragePeriod]);
return value;
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="window">The window of data held in this indicator</param>
/// <param name="input">The input given to the indicator</param>
/// <returns>A new value for this indicator</returns>
protected override decimal ComputeNextValue(IReadOnlyWindow<TradeBar> window, TradeBar input)
{
if (!IsReady)
{
if (Samples >= Period - _shadowVeryShortAveragePeriod)
{
_shadowVeryShortPeriodTotal[2] += GetCandleRange(CandleSettingType.ShadowVeryShort, window[2]);
_shadowVeryShortPeriodTotal[1] += GetCandleRange(CandleSettingType.ShadowVeryShort, window[1]);
_shadowVeryShortPeriodTotal[0] += GetCandleRange(CandleSettingType.ShadowVeryShort, input);
}
return 0m;
}
decimal value;
if (
// white
GetCandleColor(window[3]) == CandleColor.White &&
// 1st black
GetCandleColor(window[2]) == CandleColor.Black &&
// very short lower shadow
GetLowerShadow(window[2]) < GetCandleAverage(CandleSettingType.ShadowVeryShort, _shadowVeryShortPeriodTotal[2], window[2]) &&
// 2nd black
GetCandleColor(window[1]) == CandleColor.Black &&
// very short lower shadow
GetLowerShadow(window[1]) < GetCandleAverage(CandleSettingType.ShadowVeryShort, _shadowVeryShortPeriodTotal[1], window[1]) &&
// 3rd black
GetCandleColor(input) == CandleColor.Black &&
// very short lower shadow
GetLowerShadow(input) < GetCandleAverage(CandleSettingType.ShadowVeryShort, _shadowVeryShortPeriodTotal[0], input) &&
// 2nd black opens within 1st black's rb
window[1].Open < window[2].Open && window[1].Open > window[2].Close &&
// 3rd black opens within 2nd black's rb
input.Open < window[1].Open && input.Open > window[1].Close &&
// 1st black closes under prior candle's high
window[3].High > window[2].Close &&
// three declining
window[2].Close > window[1].Close &&
// three declining
window[1].Close > input.Close
)
value = -1m;
else
value = 0m;
// add the current range and subtract the first range: this is done after the pattern recognition
// when avgPeriod is not 0, that means "compare with the previous candles" (it excludes the current candle)
for (var i = 2; i >= 0; i--)
{
_shadowVeryShortPeriodTotal[i] += GetCandleRange(CandleSettingType.ShadowVeryShort, window[i]) -
GetCandleRange(CandleSettingType.ShadowVeryShort, window[i + _shadowVeryShortAveragePeriod]);
}
return value;
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="window">The window of data held in this indicator</param>
/// <param name="input">The input given to the indicator</param>
/// <returns>A new value for this indicator</returns>
protected override decimal ComputeNextValue(IReadOnlyWindow<TradeBar> window, TradeBar input)
{
if (!IsReady)
{
if (Samples >= Period - _shadowVeryShortAveragePeriod)
{
_shadowVeryShortPeriodTotal[1] += GetCandleRange(CandleSettingType.ShadowVeryShort, window[1]);
_shadowVeryShortPeriodTotal[0] += GetCandleRange(CandleSettingType.ShadowVeryShort, input);
}
if (Samples >= Period - _bodyLongAveragePeriod)
{
_bodyLongPeriodTotal[1] += GetCandleRange(CandleSettingType.BodyLong, window[1]);
_bodyLongPeriodTotal[0] += GetCandleRange(CandleSettingType.BodyLong, input);
}
return 0m;
}
decimal value;
if (
// opposite candles
(int)GetCandleColor(window[1]) == -(int)GetCandleColor(input) &&
// 1st marubozu
GetRealBody(window[1]) > GetCandleAverage(CandleSettingType.BodyLong, _bodyLongPeriodTotal[1], window[1]) &&
GetUpperShadow(window[1]) < GetCandleAverage(CandleSettingType.ShadowVeryShort, _shadowVeryShortPeriodTotal[1], window[1]) &&
GetLowerShadow(window[1]) < GetCandleAverage(CandleSettingType.ShadowVeryShort, _shadowVeryShortPeriodTotal[1], window[1]) &&
// 2nd marubozu
GetRealBody(input) > GetCandleAverage(CandleSettingType.BodyLong, _bodyLongPeriodTotal[0], input) &&
GetUpperShadow(input) < GetCandleAverage(CandleSettingType.ShadowVeryShort, _shadowVeryShortPeriodTotal[0], input) &&
GetLowerShadow(input) < GetCandleAverage(CandleSettingType.ShadowVeryShort, _shadowVeryShortPeriodTotal[0], input) &&
// gap
(
(GetCandleColor(window[1]) == CandleColor.Black && GetCandleGapUp(input, window[1]))
||
(GetCandleColor(window[1]) == CandleColor.White && GetCandleGapDown(input, window[1]))
)
)
value = (int)GetCandleColor(input);
else
value = 0m;
// add the current range and subtract the first range: this is done after the pattern recognition
// when avgPeriod is not 0, that means "compare with the previous candles" (it excludes the current candle)
for (var i = 1; i >= 0; i--)
{
_shadowVeryShortPeriodTotal[i] += GetCandleRange(CandleSettingType.ShadowVeryShort, window[i]) -
GetCandleRange(CandleSettingType.ShadowVeryShort, window[i + _shadowVeryShortAveragePeriod]);
_bodyLongPeriodTotal[i] += GetCandleRange(CandleSettingType.BodyLong, window[i]) -
GetCandleRange(CandleSettingType.BodyLong, window[i + _bodyLongAveragePeriod]);
}
return value;
}
public static decimal ComputeOcCp(TradeBar previous, TradeBar current)
{
if (previous == null)
{
return 0m;
}
return (decimal)Math.Log((double)(current.Open / previous.Close));
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="input">The input given to the indicator</param>
/// <returns>A new value for this indicator</returns>
protected override decimal ComputeNextValue(TradeBar input)
{
Minimum.Update(input.Time, input.Low);
Maximum.Update(input.Time, input.High);
if (!this.IsReady) return 0;
var range = (Maximum.Current.Value - Minimum.Current.Value);
return range == 0 ? 0 : -100m*(Maximum.Current.Value - input.Close)/range;
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="window">The window of data held in this indicator</param>
/// <param name="input">The input given to the indicator</param>
/// <returns>A new value for this indicator</returns>
protected override decimal ComputeNextValue(IReadOnlyWindow<TradeBar> window, TradeBar input)
{
if (!IsReady)
{
if (Samples >= Period - _shadowVeryShortAveragePeriod)
{
_shadowVeryShortPeriodTotal[3] += GetCandleRange(CandleSettingType.ShadowVeryShort, window[3]);
_shadowVeryShortPeriodTotal[2] += GetCandleRange(CandleSettingType.ShadowVeryShort, window[2]);
_shadowVeryShortPeriodTotal[1] += GetCandleRange(CandleSettingType.ShadowVeryShort, window[1]);
}
return 0m;
}
decimal value;
if (
// 1st black
GetCandleColor(window[3]) == CandleColor.Black &&
// 2nd black
GetCandleColor(window[2]) == CandleColor.Black &&
// 3rd black
GetCandleColor(window[1]) == CandleColor.Black &&
// 4th black
GetCandleColor(input) == CandleColor.Black &&
// 1st: marubozu
GetLowerShadow(window[3]) < GetCandleAverage(CandleSettingType.ShadowVeryShort, _shadowVeryShortPeriodTotal[3], window[3]) &&
GetUpperShadow(window[3]) < GetCandleAverage(CandleSettingType.ShadowVeryShort, _shadowVeryShortPeriodTotal[3], window[3]) &&
// 2nd: marubozu
GetLowerShadow(window[2]) < GetCandleAverage(CandleSettingType.ShadowVeryShort, _shadowVeryShortPeriodTotal[2], window[2]) &&
GetUpperShadow(window[2]) < GetCandleAverage(CandleSettingType.ShadowVeryShort, _shadowVeryShortPeriodTotal[2], window[2]) &&
// 3rd: opens gapping down
GetRealBodyGapDown(window[1], window[2]) &&
// and has an upper shadow
GetUpperShadow(window[1]) > GetCandleAverage(CandleSettingType.ShadowVeryShort, _shadowVeryShortPeriodTotal[1], window[1]) &&
// that extends into the prior body
window[1].High > window[2].Close &&
// 4th: engulfs the 3rd including the shadows
input.High > window[1].High && input.Low < window[1].Low
)
value = 1m;
else
value = 0m;
// add the current range and subtract the first range: this is done after the pattern recognition
// when avgPeriod is not 0, that means "compare with the previous candles" (it excludes the current candle)
for (var i = 3; i >= 1; i--)
{
_shadowVeryShortPeriodTotal[i] += GetCandleRange(CandleSettingType.ShadowVeryShort, window[i]) -
GetCandleRange(CandleSettingType.ShadowVeryShort, window[i + _shadowVeryShortAveragePeriod]);
}
return value;
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="input">The input given to the indicator</param>
/// <returns>A new value for this indicator, which by convention is the mean value of the upper band and lower band.</returns>
protected override decimal ComputeNextValue(TradeBar input)
{
if (_previousInput != null)
{
UpperBand.Update(new IndicatorDataPoint(_previousInput.Time, _previousInput.High));
LowerBand.Update(new IndicatorDataPoint(_previousInput.Time, _previousInput.Low));
}
_previousInput = input;
return (UpperBand.Current.Value + LowerBand.Current.Value) / 2;
}
/// <summary>
/// Cloner constructor for implementing fill forward.
/// Return a new instance with the same values as this original.
/// </summary>
/// <param name="original">Original tradebar object we seek to clone</param>
public TradeBar(TradeBar original)
{
Time = new DateTime(original.Time.Ticks);
Symbol = original.Symbol;
Value = original.Close;
Open = original.Open;
High = original.High;
Low = original.Low;
Close = original.Close;
Volume = original.Volume;
}
/// <summary>
/// Parse an index bar from the LEAN disk format
/// </summary>
public static TradeBar ParseIndex(SubscriptionDataConfig config, string line, DateTime date)
{
var tradeBar = new TradeBar
{
Period = config.Increment,
Symbol = config.Symbol
};
var csv = line.ToCsv(6);
tradeBar.Time = date.Date.AddMilliseconds(csv[0].ToInt32()).ConvertTo(config.DataTimeZone, config.ExchangeTimeZone);
tradeBar.Open = csv[1].ToDecimal();
tradeBar.High = csv[2].ToDecimal();
tradeBar.Low = csv[3].ToDecimal();
tradeBar.Close = csv[4].ToDecimal();
tradeBar.Volume = csv[5].ToDecimal();
return(tradeBar);
}
private static void ParseCrypto(TradeBar tradeBar, SubscriptionDataConfig config, StreamReader streamReader, DateTime date)
{
if (config.Resolution == Resolution.Daily || config.Resolution == Resolution.Hour)
{
// hourly and daily have different time format, and can use slow, robust c# parser.
tradeBar.Time = streamReader.GetDateTime().ConvertTo(config.DataTimeZone, config.ExchangeTimeZone);
}
else
{
//Fast decimal conversion
tradeBar.Time = date.Date.AddMilliseconds(streamReader.GetInt32()).ConvertTo(config.DataTimeZone, config.ExchangeTimeZone);
}
tradeBar.Open = streamReader.GetDecimal();
tradeBar.High = streamReader.GetDecimal();
tradeBar.Low = streamReader.GetDecimal();
tradeBar.Close = streamReader.GetDecimal();
tradeBar.Volume = streamReader.GetDecimal();
}
private static void ParseEquity(TradeBar tradeBar, SubscriptionDataConfig config, StreamReader stream, DateTime date)
{
if (config.Resolution == Resolution.Daily || config.Resolution == Resolution.Hour)
{
// hourly and daily have different time format, and can use slow, robust c# parser.
tradeBar.Time = stream.GetDateTime().ConvertTo(config.DataTimeZone, config.ExchangeTimeZone);
}
else
{
// Using custom "ToDecimal" conversion for speed on high resolution data.
tradeBar.Time = date.Date.AddMilliseconds(stream.GetInt32()).ConvertTo(config.DataTimeZone, config.ExchangeTimeZone);
}
tradeBar.Open = stream.GetDecimal() * _scaleFactor;
tradeBar.High = stream.GetDecimal() * _scaleFactor;
tradeBar.Low = stream.GetDecimal() * _scaleFactor;
tradeBar.Close = stream.GetDecimal() * _scaleFactor;
tradeBar.Volume = stream.GetDecimal();
}
private static void ParseForex(TradeBar tradeBar, SubscriptionDataConfig config, string line, DateTime date)
{
var csv = line.ToCsv(5);
if (config.Resolution == Resolution.Daily || config.Resolution == Resolution.Hour)
{
// hourly and daily have different time format, and can use slow, robust c# parser.
tradeBar.Time = DateTime.ParseExact(csv[0], DateFormat.TwelveCharacter, CultureInfo.InvariantCulture).ConvertTo(config.DataTimeZone, config.ExchangeTimeZone);
}
else
{
//Fast decimal conversion
tradeBar.Time = date.Date.AddMilliseconds(csv[0].ToInt32()).ConvertTo(config.DataTimeZone, config.ExchangeTimeZone);
}
tradeBar.Open = csv[1].ToDecimal();
tradeBar.High = csv[2].ToDecimal();
tradeBar.Low = csv[3].ToDecimal();
tradeBar.Close = csv[4].ToDecimal();
}
/// <summary>
/// Parse an index bar from the LEAN disk format
/// </summary>
private static TradeBar StreamParseNoScale(SubscriptionDataConfig config, StreamReader streamReader, DateTime date, TradeBar bar = null, bool hasVolume = true)
{
var tradeBar = bar ?? new TradeBar
{
Period = config.Increment,
Symbol = config.Symbol
};
if (config.Resolution == Resolution.Daily || config.Resolution == Resolution.Hour)
{
// hourly and daily have different time format, and can use slow, robust c# parser.
tradeBar.Time = streamReader.GetDateTime().ConvertTo(config.DataTimeZone, config.ExchangeTimeZone);
}
else
{
// Using custom "ToDecimal" conversion for speed on high resolution data.
tradeBar.Time = date.Date.AddMilliseconds(streamReader.GetInt32()).ConvertTo(config.DataTimeZone, config.ExchangeTimeZone);
}
tradeBar.Open = streamReader.GetDecimal();
tradeBar.High = streamReader.GetDecimal();
tradeBar.Low = streamReader.GetDecimal();
tradeBar.Close = streamReader.GetDecimal();
if (hasVolume)
{
tradeBar.Volume = streamReader.GetDecimal();
}
return(tradeBar);
}
/// <summary>
/// Parse an index bar from the LEAN disk format
/// </summary>
private static TradeBar LineParseNoScale(SubscriptionDataConfig config, string line, DateTime date, TradeBar bar = null, bool hasVolume = true)
{
var tradeBar = bar ?? new TradeBar
{
Period = config.Increment,
Symbol = config.Symbol
};
var csv = line.ToCsv(hasVolume ? 6 : 5);
if (config.Resolution == Resolution.Daily || config.Resolution == Resolution.Hour)
{
// hourly and daily have different time format, and can use slow, robust c# parser.
tradeBar.Time = DateTime.ParseExact(csv[0], DateFormat.TwelveCharacter, CultureInfo.InvariantCulture).ConvertTo(config.DataTimeZone, config.ExchangeTimeZone);
}
else
{
// Using custom "ToDecimal" conversion for speed on high resolution data.
tradeBar.Time = date.Date.AddMilliseconds(csv[0].ToInt32()).ConvertTo(config.DataTimeZone, config.ExchangeTimeZone);
}
tradeBar.Open = csv[1].ToDecimal();
tradeBar.High = csv[2].ToDecimal();
tradeBar.Low = csv[3].ToDecimal();
tradeBar.Close = csv[4].ToDecimal();
if (hasVolume)
{
tradeBar.Volume = csv[5].ToDecimal();
}
return(tradeBar);
}
