private int GetClosestIndexByDate(MarketSeries series, DateTime time)
{
var lastIndex = series.Close.Count - 1;
if (time >= series.OpenTime[lastIndex])
return lastIndex;
var timeDifference = time.Subtract(series.OpenTime[0]);
int index = 0;
for (int i = 0; i < lastIndex - 1; i++)
{
if (time < series.OpenTime[i])
break;
var currDiff = time.Subtract(series.OpenTime[i]);
if (currDiff < timeDifference)
{
timeDifference = currDiff;
index = i;
}
}
return index;
}
protected override void Initialize()
{
thisCandle = MarketSeries.Open.Count - 1;
startCandle = thisCandle;
minuut = MarketData.GetSeries(TimeFrame.Minute);
for (int i = 1; i <= startCandle; i++)
oldCows(i);
}
public FractalService(MarketSeries marketSeries, int period)
{
this.period = period;
this.marketSeries = marketSeries;
lastIndex = 0;
onFractalListeners = new List <Action <FractalEvent> >();
}
private void SendFirstOrder(int orderVolume, MarketSeries marketSeries, Symbol symbol)
{
int signal = GetStdIlanSignal(marketSeries);
if (!(signal < 0))
{
TradeResult result;
switch (signal)
{
case 0:
result = ExecuteMarketOrder(TradeType.Buy, symbol, orderVolume, RobotLabel, null, TakeProfit);
if (!result.IsSuccessful)
{
if (result.Error.Equals(ErrorCode.NoMoney) || result.Error.Equals(ErrorCode.BadVolume))
{
Stop();
}
}
break;
case 1:
result = ExecuteMarketOrder(TradeType.Sell, symbol, orderVolume, RobotLabel, null, TakeProfit);
if (!result.IsSuccessful)
{
if (result.Error.Equals(ErrorCode.NoMoney) || result.Error.Equals(ErrorCode.BadVolume))
{
Stop();
}
}
break;
}
}
}
protected override void OnInitializing()
{
base.OnInitializing();
OnInitializing_();
DataSeries = Template.IndicatorBarSource ?? MarketSeries.GetDataSeries(Template.IndicatorBarComponent);
}
//set out of area
protected override void Initialize()
{
RSINow = Indicators.RelativeStrengthIndex(SourceSeries, RSI_period);
seriesH1 = MarketData.GetSeries(TimeFrame.Daily);
ATR = Indicators.AverageTrueRange(seriesH1, ATR_period, MovingAverageType.Simple);
}
public static double volatility(this MarketSeries marketSeries, int period)
{
double maximum = marketSeries.High.Maximum(period);
double minimum = marketSeries.Low.Minimum(period);
return(maximum - minimum);
}
protected override void Initialize()
{
// Calculate all VWAPS once
if (MarketSeries.TimeFrame < TimeFrame.Daily)
M1 = MarketData.GetSeries(TimeFrame.Minute);
else
M1 = MarketData.GetSeries(TimeFrame.Minute10);
for (int idx = (MarketSeries.Close.Count - 2) - Lookback; idx <= MarketSeries.Close.Count - 2; idx++)
{
double M1Vwap = 0;
int M1FirstIndex = M1.OpenTime.GetIndexByTime(MarketSeries.OpenTime[idx]);
if (M1FirstIndex != -1)
{
for (int i = M1FirstIndex; i < M1.OpenTime.GetIndexByTime(MarketSeries.OpenTime[idx + 1]); i++)
{
M1Vwap += M1.Median[i] * M1.TickVolume[i];
}
}
else
continue;
M1Vwap = M1Vwap / MarketSeries.TickVolume[idx];
if (M1Vwap <= MarketSeries.High[idx] && M1Vwap >= MarketSeries.Low[idx])
ChartObjects.DrawText("vwap" + idx, Markers[MarkerType], idx, M1Vwap, VerticalAlignment.Center, HorizontalAlignment.Center, MarketSeries.TickVolume[idx] >= MarketSeries.TickVolume[idx - 1] ? (Colors)Enum.Parse(typeof(Colors), VolumeUpColor, true) : (Colors)Enum.Parse(typeof(Colors), VolumeDownColor, true));
}
// Prepare vwap of the current bar with minute data for incoming realtime tick data
for (int i = M1.OpenTime.GetIndexByTime(MarketSeries.OpenTime.LastValue); i <= M1.Close.Count - 1; i++)
{
RealtimeVwap[0, 0] += M1.Median[i] * M1.TickVolume[i];
}
RealtimeVwap[0, 1] = MarketSeries.TickVolume.LastValue;
BarCount = MarketSeries.Close.Count - 1;
}
//******************************************
protected override void Initialize()
{
//**************************************
LR_Slope = Indicators.LinearRegressionSlope(MarketSeries.Close, 12);
MA20 = Indicators.ExponentialMovingAverage(MarketSeries.Close, 20);
MA50 = Indicators.ExponentialMovingAverage(MarketSeries.Close, 50);
MA100 = Indicators.ExponentialMovingAverage(MarketSeries.Close, 100);
LTF_Candle = MarketData.GetSeries(LTF);
MTF_Candle = MarketData.GetSeries(MTF);
STF_Candle = MarketData.GetSeries(STF);
//**************************************
///////////////////////////////////////////////////////////
// Initialize and create nested indicators
MA = Indicators.MovingAverage(MarketSeries.Close, MA_Periods, MovingAverageType.Exponential);
// Initalize RSI
RSI = Indicators.RelativeStrengthIndex(MarketSeries.Close, RSI_Periods);
// Initalize CCI
CCI = Indicators.CommodityChannelIndex(MarketSeries, CCI_Periods);
thecount = MarketSeries.Close.Count;
Print("theCount = " + thecount);
}
private int DailyPeriodAdjustment(MarketSeries ms, int index)
{
if (index < 1)
{
return(0);
}
int periods = 1;
DateTime CurrentDate = ms.OpenTime[index].AddHours(2);
DateTime PreviousDate = ms.OpenTime[index - periods].AddHours(2);
int DateDifference = (int)(CurrentDate.Date - PreviousDate.Date).TotalDays;
while (CurrentDate.DayOfWeek == PreviousDate.DayOfWeek || PreviousDate.DayOfWeek == DayOfWeek.Sunday || CurrentDate.DayOfWeek == DayOfWeek.Saturday)
{
periods++;
if (index < periods)
{
return(periods - 1);
}
PreviousDate = ms.OpenTime[index - periods].AddHours(2);
DateDifference = (int)(CurrentDate.Date - PreviousDate.Date).TotalDays;
}
return(periods - 1);
}
//====================================================================================================================
// Insert()
//====================================================================================================================
public void Insert(string Currency = "GBPJPY")
{
// Current UNIX timestamp
//Int32 Stamp = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
MarketSeries data = MarketData.GetSeries(Currency, TimeFrame.Weekly);
DataSeries series = data.Close;
int index = series.Count - 1;
double close = data.Close[index];
double high = data.High[index];
double low = data.Low[index];
double open = data.Open[index];
Int32 opentime = (Int32)(data.OpenTime[index].Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
Print(open);
//string query = "INSERT INTO account (time, accountid, balance, equity) VALUES('" + Stamp + "','" + Account.Number + "', '" + Account.Balance + "', '" + Account.Equity + "')";
string query = "INSERT INTO " + Currency + " (time, open, close, low, high) VALUES('" + opentime + "','" + open + "', '" + close + "', '" + low + "', '" + high + "')";
//create command and assign the query and connection from the constructor
MySqlCommand cmd = new MySqlCommand(query, connection);
//Execute command
cmd.ExecuteNonQuery();
}
private int CalculateTiming(MacdCrossOver macd, ExponentialMovingAverage ma, MarketSeries series)
{
if (IsTrendUp(series, ma))
{
if (macd.Histogram.LastValue > 0)
{
return(1);
}
else
{
return(2);
}
}
else
{
if (macd.Histogram.LastValue <= 0)
{
return(-1);
}
else
{
return(-2);
}
}
}
////////////TVI Params End //////////////////
protected override void Initialize()
{
//////////////TVI Init Start //////////////
UpTick = CreateDataSeries();
DnTick = CreateDataSeries();
TVI_Calculate = CreateDataSeries();
EMA_UpTick = Indicators.ExponentialMovingAverage(UpTick, EMA);
EMA_DnTick = Indicators.ExponentialMovingAverage(DnTick, EMA);
DEMA_UpTick = Indicators.ExponentialMovingAverage(EMA_UpTick.Result, DEMA);
DEMA_DnTick = Indicators.ExponentialMovingAverage(EMA_DnTick.Result, DEMA);
TVI = Indicators.ExponentialMovingAverage(TVI_Calculate, TEMA);
//////////////TVI init End ///////////////
// Initialize and create nested indicators
LongTF_Series = MarketData.GetSeries(Ref_TF);
MedTF_Series = MarketData.GetSeries(Med_TF);
SmallTF_Series = MarketData.GetSeries(Lil_TF);
MA50 = Indicators.ExponentialMovingAverage(MarketSeries.Close, Ma_Periods);
MA50_LongTF = Indicators.ExponentialMovingAverage(LongTF_Series.Close, Ma_Periods);
MA50_MedTF = Indicators.ExponentialMovingAverage(MedTF_Series.Close, Ma_Periods);
MA50_SmallTF = Indicators.ExponentialMovingAverage(SmallTF_Series.Close, Ma_Periods);
}
protected override void Initialize()
{
series1D = MarketData.GetSeries(TEMATimeframe);
TemaFast = Indicators.GetIndicator <TEMA>(series1D.Close, PeriodFast);
TemaSlow = Indicators.GetIndicator <TEMA>(series1D.Close, PeriodSlow);
}
protected override void Initialize()
{
try
{
// Get the 1 min timeframe series of data
minuteSeries = MarketData.GetSeries(Symbol, TimeFrame.Minute);
warningTextColor = (Colors)Enum.Parse(typeof(Colors), WarningColor, true);
spreadTextColor = (Colors)Enum.Parse(typeof(Colors), SpreadColor, true);
} catch (Exception e)
{
errorOccured = true;
Print("Scalpers Buddy: " + e.Message);
}
// position alert message on screen
switch (WarningPostion)
{
case 1:
position = StaticPosition.TopLeft;
break;
case 2:
position = StaticPosition.TopCenter;
break;
case 3:
position = StaticPosition.TopRight;
//lowerPosition = "\n\n";
break;
case 4:
position = StaticPosition.Right;
lowerPosition = "\n\n";
break;
case 5:
position = StaticPosition.BottomRight;
lowerPosition = "\n\n";
break;
case 6:
position = StaticPosition.BottomCenter;
lowerPosition = "\n\n";
break;
case 7:
position = StaticPosition.BottomLeft;
lowerPosition = "\n\n";
break;
case 8:
position = StaticPosition.Left;
lowerPosition = "\n\n";
break;
default:
position = StaticPosition.TopLeft;
break;
}
}
public void CalculateHeikenAshi(MarketSeries marketSeries, int index, int maPeriods, MovingAverageType maType, int periods = 1)
{
int seriesIndex = marketSeries.OpenTime.GetIndexByTime(marketSeries.OpenTime[index]);
if (seriesIndex <= maPeriods)
{
return;
}
double barMaOpen = GetSeriesMovingAverageValue(marketSeries, SeriesType.Open, maPeriods, maType, seriesIndex);
double barMaHigh = GetSeriesMovingAverageValue(marketSeries, SeriesType.High, maPeriods, maType, seriesIndex);
double barMaLow = GetSeriesMovingAverageValue(marketSeries, SeriesType.Low, maPeriods, maType, seriesIndex);
double barMaClose = GetSeriesMovingAverageValue(marketSeries, SeriesType.Close, maPeriods, maType, seriesIndex);
_close[seriesIndex] = (barMaOpen + barMaClose + barMaHigh + barMaLow) / 4;
if (seriesIndex < periods || double.IsNaN(_open[seriesIndex - 1]))
{
_open[seriesIndex] = (barMaOpen + barMaClose) / 2;
_high[seriesIndex] = barMaHigh;
_low[seriesIndex] = barMaLow;
}
else
{
_open[seriesIndex] = (_open[seriesIndex - periods] + _close[seriesIndex - periods]) / 2;
_high[seriesIndex] = Math.Max(barMaHigh, Math.Max(_open[seriesIndex], _close[seriesIndex]));
_low[seriesIndex] = Math.Min(barMaLow, Math.Min(_open[seriesIndex], _close[seriesIndex]));
}
}
protected override void Initialize()
{
symbol2 = MarketData.GetSymbol(Symbol2);
symbol3 = MarketData.GetSymbol(Symbol3);
symbol4 = MarketData.GetSymbol(Symbol4);
symbol5 = MarketData.GetSymbol(Symbol5);
symbol6 = MarketData.GetSymbol(Symbol6);
symbol7 = MarketData.GetSymbol(Symbol7);
symbol8 = MarketData.GetSymbol(Symbol8);
symbol9 = MarketData.GetSymbol(Symbol9);
symbol10 = MarketData.GetSymbol(Symbol10);
series2 = MarketData.GetSeries(symbol2, TimeFrame);
series3 = MarketData.GetSeries(symbol3, TimeFrame);
series4 = MarketData.GetSeries(symbol4, TimeFrame);
series5 = MarketData.GetSeries(symbol5, TimeFrame);
series6 = MarketData.GetSeries(symbol6, TimeFrame);
series7 = MarketData.GetSeries(symbol7, TimeFrame);
series8 = MarketData.GetSeries(symbol8, TimeFrame);
series9 = MarketData.GetSeries(symbol9, TimeFrame);
series10 = MarketData.GetSeries(symbol10, TimeFrame);
ma1 = Indicators.MovingAverage(MarketSeries.Close, Period, MaType);
ma2 = Indicators.MovingAverage(series2.Close, Period, MaType);
ma3 = Indicators.MovingAverage(series3.Close, Period, MaType);
ma4 = Indicators.MovingAverage(series4.Close, Period, MaType);
ma5 = Indicators.MovingAverage(series5.Close, Period, MaType);
ma6 = Indicators.MovingAverage(series6.Close, Period, MaType);
ma7 = Indicators.MovingAverage(series7.Close, Period, MaType);
ma8 = Indicators.MovingAverage(series8.Close, Period, MaType);
ma9 = Indicators.MovingAverage(series9.Close, Period, MaType);
ma10 = Indicators.MovingAverage(series10.Close, Period, MaType);
}
protected override void Initialize()
{
if (EnableATRInfo)
{
atr = Indicators.AverageTrueRange(14, MovingAverageType.Exponential);
}
if (EnableD1)
{
seriesD1 = MarketData.GetSeries(TimeFrame.Daily);
macdD1 = Indicators.MacdCrossOver(seriesD1.Close, 26, 12, 9);
mmD1 = Indicators.ExponentialMovingAverage(seriesD1.Close, 200);
}
if (EnableH4)
{
seriesH4 = MarketData.GetSeries(TimeFrame.Hour4);
macdH4 = Indicators.MacdCrossOver(seriesH4.Close, 26, 12, 9);
mmH4 = Indicators.ExponentialMovingAverage(seriesH4.Close, 200);
}
if (EnableH1)
{
seriesH1 = MarketData.GetSeries(TimeFrame.Hour);
macdH1 = Indicators.MacdCrossOver(seriesH1.Close, 26, 12, 9);
mmH1 = Indicators.ExponentialMovingAverage(seriesH1.Close, 200);
}
if (EnableM5)
{
seriesM5 = MarketData.GetSeries(TimeFrame.Minute5);
macdM5 = Indicators.MacdCrossOver(seriesM5.Close, 26, 12, 9);
mmM5 = Indicators.ExponentialMovingAverage(seriesM5.Close, 200);
}
}
/// <summary>
/// Returns a market series specific data series based on provided series type
/// </summary>
/// <param name="marketSeries">The market series</param>
/// <param name="seriesType">Series type</param>
/// <returns>DataSeries</returns>
public static DataSeries GetSeries(this MarketSeries marketSeries, SeriesType seriesType)
{
switch (seriesType)
{
case SeriesType.Open:
return(marketSeries.Open);
case SeriesType.High:
return(marketSeries.High);
case SeriesType.Low:
return(marketSeries.Low);
case SeriesType.Close:
return(marketSeries.Close);
case SeriesType.Median:
return(marketSeries.Median);
case SeriesType.TickVolume:
return(marketSeries.TickVolume);
case SeriesType.Typical:
return(marketSeries.Typical);
case SeriesType.WeightedClose:
return(marketSeries.WeightedClose);
default:
return(null);
}
}
/// <summary>Return the series for a given symbol and time frame</summary>
public MarketSeries GetSeries(Symbol sym, TimeFrame tf)
{
if (MarketSeries.SymbolCode == sym.Code && MarketSeries.TimeFrame == tf)
{
return(MarketSeries);
}
if (IsBacktesting)
{
throw new Exception("This can't be used in back testing");
}
MarketSeries res = null;
using (var wait = new ManualResetEvent(false))
{
BeginInvokeOnMainThread(() =>
{
res = MarketData.GetSeries(sym, tf);
wait.Set();
});
wait.WaitOne();
return(res);
}
}
private int GetClosestIndexByDate(MarketSeries series, DateTime time)
{
var lastIndex = series.Close.Count - 1;
if (time >= series.OpenTime[lastIndex])
{
return(lastIndex);
}
var timeDifference = time.Subtract(series.OpenTime[0]);
int index = 0;
for (int i = 0; i < lastIndex - 1; i++)
{
if (time < series.OpenTime[i])
{
break;
}
var currDiff = time.Subtract(series.OpenTime[i]);
if (currDiff < timeDifference)
{
timeDifference = currDiff;
index = i;
}
}
return(index);
}
protected override void Initialize()
{
m = MarketData.GetSeries(TimeFrame.Daily);
lastHi = double.MinValue;
lastLo = double.MaxValue;
OnTimer();
Timer.Start(10);
}
public void Initialize(TimeFrame tm)
{
m_ds = m_indicator.MarketData.GetSeries(tm);
m_highZigZags = m_indicator.CreateDataSeries();
m_lowZigZags = m_indicator.CreateDataSeries();
m_point = m_indicator.Symbol.TickSize;
}
protected override void Initialize()
{
_marketSerieGlobal = MarketData.GetSeries(GlobalTimeFrame2);
int period = 2 * (int)(GlobalTimeFrame2.ToTimeSpan().Ticks / MarketSeries.TimeFrame.ToTimeSpan().Ticks);
_localMA = Indicators.MovingAverage(LocalTrendSignal, period, MovingAverageType.Exponential);
}
protected override void Initialize()
{
m = MarketData.GetSeries(TimeFrame.Daily);
lastHi = double.MinValue;
lastLo = double.MaxValue;
OnTimer();
Timer.Start(10);
}
public MarketSeriesData(MarketSeries series)
{
Series = series;
LastTransmitUTC = DateTimeOffset.MinValue;
LastUpdateUTC = DateTimeOffset.MinValue;
LastTransmittedPriceData = PriceData.Default;
LastTransmittedCandle = PriceCandle.Default;
}
protected override void Initialize()
{
HmaHour4Series = MarketData.GetSeries(TimeFrame.Hour4);
HmaHourSeries = MarketData.GetSeries(TimeFrame.Hour);
ma4hr = Indicators.GetIndicator <HMAHTFSHIFT>(HmaHour4Series, HTF_Period, HTFShift, false, false, 3, false, 24);
ma1hr = Indicators.GetIndicator <HMAHTFSHIFT>(HmaHourSeries, HTF_Period, HTFShift, false, false, 3, false, 24);
}
protected override void Initialize()
{
_xbrsymbol = MarketData.GetSymbol("XBRUSD");
_xtisymbol = MarketData.GetSymbol("XTIUSD");
_xbrseries = MarketData.GetSeries(_xbrsymbol, TimeFrame);
_xtiseries = MarketData.GetSeries(_xtisymbol, TimeFrame);
_nocorel = Colors.Gray;
}
protected override void Initialize()
{
X_Series = CreateDataSeries();
Y_Series = CreateDataSeries();
X_Source = MarketData.GetSeries(X_Symbol, TimeFrame);
Y_Source = MarketData.GetSeries(Y_Symbol, TimeFrame);
}
protected override void OnBar()
{
MarketSeries data = MarketData.GetSeries(Symbol, TimeFrame.Minute15);
DataSeries series = data.Close;
int index = series.Count - 1;
close = data.Close[index];
high = data.High[index];
low = data.Low[index];
open = data.Open[index];
// Int32 opentime = (Int32)(data.OpenTime[index].Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
var longPosition = Positions.Find(label, Symbol, TradeType.Buy);
var shortPosition = Positions.Find(label, Symbol, TradeType.Sell);
var currentSlowMa = slowMa.Result.Last(0);
var currentFastMa = fastMa.Result.Last(0);
var previousSlowMa = slowMa.Result.Last(1);
var previousFastMa = fastMa.Result.Last(1);
Symbol1 = MarketData.GetSymbol("EURUSD");
if (shortPosition == null && longPosition == null && previousFastMa < open && previousFastMa < close)
{
Print("BUY MA " + previousFastMa + " O " + open + " C " + close);
Position position = Positions.Find(label, Symbol, TradeType.Sell);
double vol = Quantity;
if (position.NetProfit > 0)
{
vol = vol * 2;
}
long Volume = Symbol.QuantityToVolume(vol);
ExecuteMarketOrder(TradeType.Buy, Symbol, Volume, label, 222, 50);
//ExecuteMarketOrder(TradeType.Sell, Symbol1, VolumeInUnitsBuy, label, 111, 50);
}
if (longPosition == null && shortPosition == null && previousFastMa > open && previousFastMa > close)
{
Print("SELL MA " + previousFastMa + " O " + open + " C " + close);
Position position = Positions.Find(label, Symbol, TradeType.Buy);
double vol = Quantity;
if (position.NetProfit > 0)
{
vol = vol * 2;
}
long Volume = Symbol.QuantityToVolume(vol);
ExecuteMarketOrder(TradeType.Sell, Symbol, Volume, label, 222, 50);
// ExecuteMarketOrder(TradeType.Buy, Symbol1, VolumeInUnitsBuy, label, 111, 50);
}
}
protected override void Initialize()
{
// Initialize and create nested indicators
accDist = CreateDataSeries();
ema3 = Indicators.ExponentialMovingAverage(accDist, 3);
ema10 = Indicators.ExponentialMovingAverage(accDist, 10);
marketSeriesDaily = MarketData.GetSeries(TimeFrame.Daily);
}
private int GetIndexByDate(MarketSeries series, DateTime time)
{
for (int i = series.Close.Count - 1; i > 0; i--)
{
if (time == series.OpenTime[i])
return i;
}
return -1;
}
public double GetSeriesMovingAverageValue(
MarketSeries marketSeries, SeriesType seriesType, int periods, MovingAverageType type, int index)
{
DataSeries series = marketSeries.GetSeries(seriesType);
MovingAverage ma = _algo.Indicators.MovingAverage(series, periods, type);
return(ma.Result[index]);
}
protected override void Initialize()
{
series5 = MarketData.GetSeries(TimeFrame.Minute5);
series10 = MarketData.GetSeries(TimeFrame.Minute10);
ma = Indicators.MovingAverage(MarketSeries.Close, Period, MovingAverageType.Triangular);
ma5 = Indicators.MovingAverage(series5.Close, Period, MovingAverageType.Triangular);
ma10 = Indicators.MovingAverage(series10.Close, Period, MovingAverageType.Triangular);
}
protected override void Initialize()
{
_ratio = 80;
_xausymbol = MarketData.GetSymbol("XAUUSD");
_xagsymbol = MarketData.GetSymbol("XAGUSD");
_xauseries = MarketData.GetSeries(_xausymbol, TimeFrame);
_xagseries = MarketData.GetSeries(_xagsymbol, TimeFrame);
_nocorel = Colors.Gray;
}
protected override void Initialize()
{
Lng_Series = MarketData.GetSeries(MacD3_TF);
Mid_Series = MarketData.GetSeries(MacD2_TF);
// Initialize and create nested indicators
MacD3 = Indicators.MacdHistogram(Lng_Series.Close, LngCycle, ShrtCycle, SigPeriod);
MacD2 = Indicators.MacdHistogram(Mid_Series.Close, LngCycle, ShrtCycle, SigPeriod);
MacD1 = Indicators.MacdHistogram(MarketSeries.Close, LngCycle, ShrtCycle, SigPeriod);
}
protected override void Initialize()
{
_marketSerieGlobal = MarketData.GetSeries(GlobalTimeFrame);
int period = 2 * (int) (GlobalTimeFrame.ToTimeSpan().Ticks / MarketSeries.TimeFrame.ToTimeSpan().Ticks);
_localMA = Indicators.MovingAverage(LocalTrendSignal, period, MovingAverageType.Exponential);
}
public void DrawSeries(MarketSeries serie, int index, IndicatorDataSeries indicator, double offset)
{
int index2 = serie.OpenTime.GetIndexByExactTime(MarketSeries.OpenTime[index]);
Print("{0} - {1}", MarketSeries.OpenTime[index], serie.OpenTime[index2]);
if (serie != null)
indicator[index2] = (serie.Close[index2 + (int)Symbol2SerieOffset]) * multiplier;
}
protected override void Initialize()
{
// Fetch market series for second symbol
this.SecondSymbol = MarketData.GetSymbol(SecondPair);
this.SecondSeries = MarketData.GetSeries(this.SecondSymbol, this.TimeFrame);
// Now create a stochastic for both
this.FirstStoch = Indicators.StochasticOscillator(this.MarketSeries, this.kPeriods, this.kSlowing, this.dPeriods, MovingAverageType.Simple);
this.SecondStoch = Indicators.StochasticOscillator(this.SecondSeries, this.kPeriods, this.kSlowing, this.dPeriods, MovingAverageType.Simple);
}
protected override void Initialize()
{
series1 = MarketData.GetSeries(EMATimeframe1);
series2 = MarketData.GetSeries(EMATimeframe2);
series3 = MarketData.GetSeries(EMATimeframe3);
Ema1 = Indicators.ExponentialMovingAverage(series1.Close, Periods);
Ema2 = Indicators.ExponentialMovingAverage(series2.Close, Periods);
Ema3 = Indicators.ExponentialMovingAverage(series3.Close, Periods);
}
private void Execute(MarketSeries marketSeries, Symbol symbol)
{
Position[] positions = Positions.FindAll(RobotLabel, symbol);
if (positions.Length == 0)
SendFirstOrder(FirstLot, marketSeries, symbol);
else
ControlSeries(marketSeries, symbol);
TrailPositions(symbol);
}
protected override void Initialize()
{
//seriesM1 = MarketData.GetSeries(TimeFrame.Minute);
//seriesM5 = MarketData.GetSeries(TimeFrame.Minute5);
//seriesM15 = MarketData.GetSeries(TimeFrame.Minute15);
//seriesM30 = MarketData.GetSeries(TimeFrame.Minute30);
seriesH1 = MarketData.GetSeries(TimeFrame.Hour);
seriesH4 = MarketData.GetSeries(TimeFrame.Hour4);
seriesD1 = MarketData.GetSeries(TimeFrame.Daily);
seriesW1 = MarketData.GetSeries(TimeFrame.Weekly);
seriesMN = MarketData.GetSeries(TimeFrame.Monthly);
}
protected override void Initialize()
{
// Initialize and create nested indicators
accDist = CreateDataSeries();
ema3 = Indicators.ExponentialMovingAverage(accDist, 3);
ema10 = Indicators.ExponentialMovingAverage(accDist, 10);
marketSeriesDaily = MarketData.GetSeries(TimeFrame.Daily);
}
protected override void Initialize()
{
ma = Indicators.MovingAverage(MarketSeries.Close, 200, MovingAverageType.Simple);
if (Symbol2 != "")
{
symbol2 = MarketData.GetSymbol(Symbol2);
series2 = MarketData.GetSeries(symbol2, TimeFrame);
}
multiplier = Symbol.Ask / symbol2.Ask;
}
protected override void Initialize()
{
try
{
// Get the 1 min timeframe series of data
minuteSeries = MarketData.GetSeries(Symbol, TimeFrame.Minute);
warningTextColor = (Colors)Enum.Parse(typeof(Colors), WarningColor, true);
spreadTextColor = (Colors)Enum.Parse(typeof(Colors), SpreadColor, true);
} catch (Exception e)
{
errorOccured = true;
Print("Scalpers Buddy: " + e.Message);
}
// position alert message on screen
switch (WarningPostion)
{
case 1:
position = StaticPosition.TopLeft;
break;
case 2:
position = StaticPosition.TopCenter;
break;
case 3:
position = StaticPosition.TopRight;
//lowerPosition = "\n\n";
break;
case 4:
position = StaticPosition.Right;
lowerPosition = "\n\n";
break;
case 5:
position = StaticPosition.BottomRight;
lowerPosition = "\n\n";
break;
case 6:
position = StaticPosition.BottomCenter;
lowerPosition = "\n\n";
break;
case 7:
position = StaticPosition.BottomLeft;
lowerPosition = "\n\n";
break;
case 8:
position = StaticPosition.Left;
lowerPosition = "\n\n";
break;
default:
position = StaticPosition.TopLeft;
break;
}
}
protected override void Initialize()
{
if (!Enum.TryParse(color_label_str, out color_label))
color_label = Colors.Lime;
if (!Enum.TryParse(color_value_str, out color_value))
color_value = Colors.White;
if (timeframe_daily)
mseries = MarketData.GetSeries(TimeFrame.Daily);
else
mseries = MarketSeries;
}
private double AverageRange(MarketSeries marketSeries, int index)
{
double sum = 0;
for (int i = index - Length; i <= index; i++)
{
double high = marketSeries.High[i];
double low = marketSeries.Low[i];
sum += (high - low);
}
return sum / Length;
}
protected override void Initialize()
{
string IndicatorName = GetType().ToString().Substring(GetType().ToString().LastIndexOf('.') + 1);
// returns ClassName
Print("Indicator: " + IndicatorName);
Print("IndicatorTimeZone: {0} Offset: {1} DST: {2}", TimeZone, TimeZone.BaseUtcOffset, TimeZone.SupportsDaylightSavingTime);
msUSDJPY = MarketData.GetSeries("USDJPY", TimeFrame);
msGBPUSD = MarketData.GetSeries("GBPUSD", TimeFrame);
msAUDUSD = MarketData.GetSeries("AUDUSD", TimeFrame);
msUSDCHF = MarketData.GetSeries("USDCHF", TimeFrame);
msEURJPY = MarketData.GetSeries("EURJPY", TimeFrame);
msEURGBP = MarketData.GetSeries("EURGBP", TimeFrame);
msEURAUD = MarketData.GetSeries("EURAUD", TimeFrame);
msEURCHF = MarketData.GetSeries("EURCHF", TimeFrame);
}
private void CalculateAccumulationDistribution(MarketSeries series, int index)
{
double close = series.Close[index];
double low = series.Low[index];
double high = series.High[index];
double volume = marketSeriesDaily.TickVolume[index];
if (!high.Equals(low))
{
double clv = ((close - low) - (high - close)) / (high - low);
accDist[index] = accDist[index - 1] + volume * clv;
}
else
accDist[index] = accDist[index - 1];
}
protected override void Initialize()
{
seriesM1 = MarketData.GetSeries(TimeFrame.Minute);
seriesM5 = MarketData.GetSeries(TimeFrame.Minute5);
seriesM15 = MarketData.GetSeries(TimeFrame.Minute15);
seriesM30 = MarketData.GetSeries(TimeFrame.Minute30);
seriesH1 = MarketData.GetSeries(TimeFrame.Hour);
seriesH4 = MarketData.GetSeries(TimeFrame.Hour4);
seriesH12 = MarketData.GetSeries(TimeFrame.Hour12);
seriesD1 = MarketData.GetSeries(TimeFrame.Daily);
cloudM1 = Indicators.IchimokuKinkoHyo(seriesM1, 9, 26, 52);
cloudM5 = Indicators.IchimokuKinkoHyo(seriesM5, 9, 26, 52);
cloudM15 = Indicators.IchimokuKinkoHyo(seriesM15, 9, 26, 52);
cloudM30 = Indicators.IchimokuKinkoHyo(seriesM30, 9, 26, 52);
cloudH1 = Indicators.IchimokuKinkoHyo(seriesH1, 9, 26, 52);
cloudH4 = Indicators.IchimokuKinkoHyo(seriesH4, 9, 26, 52);
cloudH12 = Indicators.IchimokuKinkoHyo(seriesH12, 9, 26, 52);
cloudD1 = Indicators.IchimokuKinkoHyo(seriesD1, 9, 26, 52);
}
private void SendFirstOrder(int orderVolume, MarketSeries marketSeries, Symbol symbol)
{
int signal = GetStdIlanSignal(marketSeries);
if (!(signal < 0))
{
TradeResult result;
switch (signal)
{
case 0:
result = ExecuteMarketOrder(TradeType.Buy, symbol, orderVolume, RobotLabel, null, TakeProfit);
if (!result.IsSuccessful)
if (result.Error.Equals(ErrorCode.NoMoney) ||
result.Error.Equals(ErrorCode.BadVolume))
Stop();
break;
case 1:
result = ExecuteMarketOrder(TradeType.Sell, symbol, orderVolume, RobotLabel, null, TakeProfit);
if (!result.IsSuccessful)
if (result.Error.Equals(ErrorCode.NoMoney) ||
result.Error.Equals(ErrorCode.BadVolume))
Stop();
break;
}
}
}
protected override void Initialize()
{
value1 = value2 = 0;
series2 = MarketData.GetSeries(HighOrderTimeFrame);
}
protected override void Initialize()
{
dailySeries = MarketData.GetSeries(Symbol, TimeFrame.Daily);
}
private int GetDynamicPipstep(MarketSeries marketSeries, Symbol symbol)
{
const int countOfBars = 25;
int startBar = marketSeries.Close.Count - 2 - countOfBars;
int endBar = marketSeries.Close.Count - 2;
double highestPrice = marketSeries.High[startBar];
double lowestPrice = marketSeries.Low[startBar];
for (int i = startBar; i < endBar; i++)
{
if (marketSeries.High[i] > highestPrice)
highestPrice = marketSeries.High[i];
if (marketSeries.Low[i] < lowestPrice)
lowestPrice = marketSeries.Low[i];
}
return (int) ((highestPrice - lowestPrice)/symbol.PipSize/(MaxOrders - 1));
}
private int GetStdIlanSignal(MarketSeries marketSeries)
{
int lastBarIndex = marketSeries.Close.Count - 2;
int prevBarIndex = lastBarIndex - 1;
if (marketSeries.Close[lastBarIndex] > marketSeries.Open[lastBarIndex] &&
marketSeries.Close[prevBarIndex] > marketSeries.Open[prevBarIndex]) return 0;
if (marketSeries.Close[lastBarIndex] < marketSeries.Open[lastBarIndex] &&
marketSeries.Close[prevBarIndex] < marketSeries.Open[prevBarIndex]) return 1;
return -1;
}
private void InitializeSeries(string symbolCode)
{
_symbol2 = MarketData.GetSymbol(symbolCode);
_series2 = MarketData.GetSeries(_symbol2, TimeFrame);
}
private void ControlSeries(MarketSeries marketSeries, Symbol symbol)
{
int pipstep = PipStep == 0 ? GetDynamicPipstep(marketSeries, symbol) : PipStep;
Position[] positions = Positions.FindAll(RobotLabel, symbol);
if (positions.Length < MaxOrders)
{
int lotStep = LotStep == 0 ? (int) symbol.VolumeStep : LotStep;
var newVolume = (int) (Math.Truncate((double) ((FirstLot + FirstLot*positions.Length)/lotStep))*lotStep);
switch (GetPositionsSide(symbol))
{
case 0:
if (symbol.Ask < FindLastPrice(TradeType.Buy, symbol) - pipstep*symbol.PipSize)
{
if (!(newVolume < lotStep))
{
TradeResult result = ExecuteMarketOrder(TradeType.Buy, symbol, newVolume, RobotLabel,
null, TakeProfit);
if (!result.IsSuccessful)
if (result.Error.Equals(ErrorCode.NoMoney) ||
result.Error.Equals(ErrorCode.BadVolume))
Stop();
}
}
break;
case 1:
if (symbol.Bid > FindLastPrice(TradeType.Sell, symbol) + pipstep*symbol.PipSize)
{
if (!(newVolume < lotStep))
{
TradeResult result = ExecuteMarketOrder(TradeType.Sell, symbol, newVolume, RobotLabel,
null, TakeProfit);
if (!result.IsSuccessful)
if (result.Error.Equals(ErrorCode.NoMoney) ||
result.Error.Equals(ErrorCode.BadVolume))
Stop();
}
}
break;
}
}
}
protected override void Initialize()
{
series1 = MarketData.GetSeries(TF1);
series2 = MarketData.GetSeries(TF2);
series3 = MarketData.GetSeries(TF3);
series4 = MarketData.GetSeries(TF4);
series5 = MarketData.GetSeries(TF5);
series6 = MarketData.GetSeries(TF6);
series7 = MarketData.GetSeries(TF7);
series8 = MarketData.GetSeries(TF8);
cloud1 = Indicators.IchimokuKinkoHyo(series1, 9, 26, 52);
cloud2 = Indicators.IchimokuKinkoHyo(series2, 9, 26, 52);
cloud3 = Indicators.IchimokuKinkoHyo(series3, 9, 26, 52);
cloud4 = Indicators.IchimokuKinkoHyo(series4, 9, 26, 52);
cloud5 = Indicators.IchimokuKinkoHyo(series5, 9, 26, 52);
cloud6 = Indicators.IchimokuKinkoHyo(series6, 9, 26, 52);
cloud7 = Indicators.IchimokuKinkoHyo(series7, 9, 26, 52);
cloud8 = Indicators.IchimokuKinkoHyo(series8, 9, 26, 52);
}
protected override void Initialize()
{
M1 = MarketData.GetSeries(TimeFrame.Minute);
}
protected override void Initialize()
{
series1D = MarketData.GetSeries(TEMATimeframe);
TemaFast = Indicators.GetIndicator<TEMA>(series1D.Close, PeriodFast);
TemaSlow = Indicators.GetIndicator<TEMA>(series1D.Close, PeriodSlow);
}
