protected override void OnStart()
{
bb=Indicators.BollingerBands(MarketSeries.Close,bbperiod,bbotcl, MovingAverageType.Simple);
rsi=Indicators.RelativeStrengthIndex(MarketSeries.Close,rsiperiod);
psar=Indicators.ParabolicSAR(SARstep,SARmax);
frc=Indicators.FractalChaosBands(5);
}
public override bool InitIndicatorsAsync()
{
string directoryName = Path.GetDirectoryName(Assembly.GetEntryAssembly()?.Location);
string env = TestMode ? "test" : "live";
string coinbaseRSIFile = Path.Combine(directoryName, $"data\\coinbase_{env}");
Product product = Products.FirstOrDefault(x => x.BaseCurrency == "BTC" && x.QuoteCurrency == "EUR");
RelativeStrengthIndex relativeStrengthIndex = new RelativeStrengthIndex(coinbaseRSIFile, product);
if (product != null)
{
relativeStrengthIndex.TechnicalIndicatorInformationBroadcast +=
delegate(Dictionary <string, string> input)
{
TechnicalIndicatorInformationBroadcast?.Invoke(ApplicationName, input);
};
relativeStrengthIndex.ProcessLogBroadcast += delegate(MessageType messageType, string message)
{
ProcessLogBroadcast?.Invoke(ApplicationName, messageType, message);
};
relativeStrengthIndex.UpdateProductHistoricCandles += UpdateProductHistoricCandlesAsync;
relativeStrengthIndex.EnableRelativeStrengthIndexUpdater();
return(true);
}
return(false);
}
protected override void Initialize()
{
STO_RSI = CreateDataSeries();
RSI = Indicators.RelativeStrengthIndex(MarketSeries.Close, Rsi_Period);
MA_SK = Indicators.MovingAverage(STO_RSI, PeriodSK, MA_Type);
MA_SD = Indicators.MovingAverage(MA_SK.Result, PeriodSD, MA_Type);
}
public Worker(ILogger <Worker> logger, IHubContext <ExchangeHub, IExchangeHub> exchangeHub, IExchangeService exchangeService)
{
_logger = logger;
_exchangeHub = exchangeHub;
_exchangeService = exchangeService;
_relativeStrengthIndexIndicator = new RelativeStrengthIndex(exchangeService);
}
public void TestBullishSignalTriggered()
{
var startDate = new DateTime(2017, 1, 3);
RelativeStrengthIndex rsi = new RelativeStrengthIndex("AAPL", 14, MovingAverageType.Simple);
RSIBullBearIndicator indicator = new RSIBullBearIndicator("AAPL", rsi);
IndicatorDataPoint dataPoint = new IndicatorDataPoint(startDate, Convert.ToDecimal(GetRandomNumber(127.8, 398.6)));
Assert.False(indicator.BullishSignalTriggered());
//prime up indicator with lots of data points
for (int i = 0; i < 250; i++)
{
rsi.Update(dataPoint);
indicator.Update(dataPoint);
Assert.False(indicator.BullishSignalTriggered());
dataPoint = new IndicatorDataPoint(startDate = startDate.AddDays(1), Convert.ToDecimal(GetRandomNumber(127.8, 398.6)));
}
dataPoint = new IndicatorDataPoint(startDate = startDate.AddDays(1), Decimal.Add(dataPoint.Value, Convert.ToDecimal(249.8)));
rsi.Update(dataPoint);
indicator.Update(dataPoint);
dataPoint = new IndicatorDataPoint(startDate = startDate.AddDays(1), Decimal.Subtract(dataPoint.Value, Convert.ToDecimal(121.8)));
rsi.Update(dataPoint);
indicator.Update(dataPoint);
Assert.True(indicator.BullishSignalTriggered());
}
//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);
}
protected override void Initialize()
{
_rsi = Indicators.RelativeStrengthIndex(Source, RsiPeriod);
_bollingerBands = Indicators.BollingerBands(_rsi.Result, Volatility, StDev, MovingAverageType.Simple);
_price = Indicators.MovingAverage(_rsi.Result, PricePeriod, PriceMaType);
_signal = Indicators.MovingAverage(_rsi.Result, SignalPeriod, SignalMaType);
}
public FuzzySignal(RelativeStrengthIndex rsi, SecurityHolding securityHolding)
{
_rsi = rsi;
_securityHolding = securityHolding;
_engine = new FuzzyEngine();
}
/// <summary>
/// Determines the new state. This is basically cross-over detection logic that
/// includes considerations for bouncing using the configured bounce tolerance.
/// </summary>
private State GetState(RelativeStrengthIndex rsi, State previous)
{
if (rsi > 70m)
{
return(State.TrippedHigh);
}
if (rsi < 30m)
{
return(State.TrippedLow);
}
if (previous == State.TrippedLow)
{
if (rsi > 35m)
{
return(State.Middle);
}
}
if (previous == State.TrippedHigh)
{
if (rsi < 65m)
{
return(State.Middle);
}
}
return(previous);
}
//******************************************
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);
}
public RelativeStrengthIndex CreateRelativeStrengthIndexIndicator(int period, MovingAverageType movingAverageType)
{
RelativeStrengthIndex indicator = new RelativeStrengthIndex(period, movingAverageType);
Indicators.Add(indicator);
return(indicator);
}
/// <summary>
/// Determines the new state. This is basically cross-over detection logic that
/// includes considerations for bouncing using the configured bounce tolerance.
/// </summary>
private State GetState(RelativeStrengthIndex rsi, State previous)
{
if (rsi > _parameters.UpperRsiBound)
{
return(State.TrippedHigh);
}
if (rsi < _parameters.LowerRsiBound)
{
return(State.TrippedLow);
}
if (previous == State.TrippedLow)
{
if (rsi > _parameters.LowerRsiBound + _parameters.BounceTolerance)
{
return(State.Middle);
}
}
if (previous == State.TrippedHigh)
{
if (rsi < _parameters.UpperRsiBound - _parameters.BounceTolerance)
{
return(State.Middle);
}
}
return(previous);
}
protected override void OnStart()
{
i_Moving_Average_200MA = Indicators.SimpleMovingAverage(MarketSeries.Close, (int)_Slow_SMA);
i_Relative_Strength_Index = Indicators.RelativeStrengthIndex(MarketSeries.Close, (int)_RSI_Period);
i_Relative_Strength_Index_2 = Indicators.RelativeStrengthIndex(MarketSeries.Close, (int)_RSI_Period);
i_Moving_Average_5MA = Indicators.SimpleMovingAverage(MarketSeries.Close, (int)_Fast_SMA);
}
protected override void OnStart()
{
bb = Indicators.BollingerBands(MarketSeries.Close, bbperiod, bbotcl, MovingAverageType.Simple);
rsi = Indicators.RelativeStrengthIndex(MarketSeries.Close, rsiperiod);
psar = Indicators.ParabolicSAR(SARstep, SARmax);
frc = Indicators.FractalChaosBands(5);
}
protected override void Initialize()
{
_rsi = Indicators.RelativeStrengthIndex(Source, RsiPeriod);
_bollingerBands = Indicators.BollingerBands(_rsi.Result, Volatility, StDev, MovingAverageType.Simple);
_price = Indicators.MovingAverage(_rsi.Result, PricePeriod, PriceMaType);
_signal = Indicators.MovingAverage(_rsi.Result, SignalPeriod, SignalMaType);
}
public override void Initialize()
{
SetCash(100000);
symbols.Add("SPY");
SetStartDate(1998, 1, 1);
SetEndDate(2014, 12, 1);
//Present Social Media Stocks:
// symbols.Add("FB");symbols.Add("LNKD");symbols.Add("GRPN");symbols.Add("TWTR");
// SetStartDate(2011, 1, 1);
// SetEndDate(2014, 12, 1);
//2008 Financials:
// symbols.Add("C");symbols.Add("AIG");symbols.Add("BAC");symbols.Add("HBOS");
// SetStartDate(2003, 1, 1);
// SetEndDate(2011, 1, 1);
//2000 Dot.com:
// symbols.Add("IPET");symbols.Add("WBVN");symbols.Add("GCTY");
// SetStartDate(1998, 1, 1);
// SetEndDate(2000, 1, 1);
//CAPE data
AddData <CAPE>("CAPE");
foreach (string stock in symbols)
{
AddSecurity(SecurityType.Equity, stock, Resolution.Minute);
macd = MACD(stock, 12, 26, 9, MovingAverageType.Exponential, Resolution.Daily);
macdDic.Add(stock, macd);
rsi = RSI(stock, 14, MovingAverageType.Exponential, Resolution.Daily);
rsiDic.Add(stock, rsi);
}
}
protected override void OnStart()
{
i_Moving_Average_200MA = Indicators.SimpleMovingAverage(MarketSeries.Close, (int)_Slow_SMA);
i_Relative_Strength_Index = Indicators.RelativeStrengthIndex(MarketSeries.Close, (int)_RSI_Period);
i_Moving_Average_5MA = Indicators.SimpleMovingAverage(MarketSeries.Close, (int)_Fast_SMA);
}
/// <summary>
/// Initializes a new instance of the <see cref="CrossEMAStrategy"/> class.
/// </summary>
/// <param name="Price">The injected price indicator.</param>
/// <param name="SlowEMAPeriod">The slow EMA period.</param>
/// <param name="FastEMAPeriod">The fast EMA period.</param>
public RSIStrategy(Indicator Price, int RSIPeriod = 40, decimal Threshold = 20)
{
// Initialize fields.
_threshold = Threshold;
_price = Price;
ActualSignal = OrderSignal.doNothing;
Position = StockState.noInvested;
EntryPrice = null;
rsi = new RelativeStrengthIndex(RSIPeriod).Of(_price);
// Fill the RSI rolling windows at every new RSI update. Once the
// rolling windows is ready, at every indicator update the CheckSignal method will be called.
rsi.Updated += (object sender, IndicatorDataPoint updated) =>
{
if (rsi.IsReady)
{
rsiRW.Add(rsi);
}
if (rsiRW.IsReady)
{
CheckSignal();
}
};
}
protected override void OnStart()
{
i_Relative_Strength_Index = Indicators.RelativeStrengthIndex(MarketSeries.Close, 2);
i_Moving_Average_200MA = Indicators.SimpleMovingAverage(MarketSeries.Close, 200);
i_Moving_Average_5MA = Indicators.SimpleMovingAverage(MarketSeries.Close, 5);
}
public RSISignal(RelativeStrengthIndex rsi,
ExponentialMovingAverage ema,
SecurityHolding securityHolding)
{
_rsi = rsi;
_ema = ema;
_securityHolding = securityHolding;
}
/// <summary>
/// Creates a new RelativeStrengthIndex indicator. This will produce an oscillator that ranges from 0 to 100 based
/// on the ratio of average gains to average losses over the specified period.
/// </summary>
/// <param name="symbol">The symbol whose RSI we want</param>
/// <param name="period">The period over which to compute the RSI</param>
/// <param name="movingAverageType">The type of moving average to use in computing the average gain/loss values</param>
/// <param name="resolution">The resolution</param>
/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>
/// <returns>The RelativeStrengthIndex indicator for the requested symbol over the specified period</returns>
public RelativeStrengthIndex RSI(string symbol, int period, MovingAverageType movingAverageType = MovingAverageType.Simple, Resolution?resolution = null, Func <BaseData, decimal> selector = null)
{
var name = CreateIndicatorName(symbol, "RSI" + period, resolution);
var rsi = new RelativeStrengthIndex(name, period, movingAverageType);
RegisterIndicator(symbol, rsi, resolution, selector);
return(rsi);
}
protected override void Initialize()
{
_cyclePrice = CreateDataSeries();
_zeroLag = CreateDataSeries();
_ma = Indicators.MovingAverage(MarketSeries.Close, PriceActionFilter, MaType);
_rsi = Indicators.RelativeStrengthIndex(_cyclePrice, 14);
_useCycleFilter = UseCycleFilter == 1;
}
private void rsiParameterNext_Click(object sender, EventArgs e)
{
rsiResultTitle.Text = Code + " için Relative Strength Index sonucu";
RSIPeriod = (int)rsiPeriod.Value;
rsiDataResultChart.Series.Clear();
rsiIndicatorResultChart.Series.Clear();
var closeSeries = new Series
{
Name = "Kapanış",
Color = System.Drawing.Color.Black,
ChartType = SeriesChartType.Line
};
var rsiSeries = new Series
{
Name = "Relative Strength Index",
Color = System.Drawing.Color.Blue,
ChartType = SeriesChartType.Line
};
rsiDataResultChart.Series.Add(closeSeries);
rsiIndicatorResultChart.Series.Add(rsiSeries);
var closeData = IndicatorService.GetData(Code, TargetDate, new string[] { "Tarih", "Kapanis" }, NumberOfData);
double[] rsi;
if (MapReduceAllowed)
{
rsi = RelativeStrengthIndex.RsiMR(Code, TargetDate, RSIPeriod, NumberOfData);
}
else
{
rsi = RelativeStrengthIndex.Rsi(Code, TargetDate, RSIPeriod, NumberOfData);
}
DateTime date;
for (int i = 0; i < rsi.Length; i++)
{
var close = closeData.ElementAt(i);
date = close.GetElement("Tarih").Value.AsBsonDateTime.ToLocalTime();
closeSeries.Points.AddXY(date, close.GetElement("Kapanis").Value.ToDouble());
rsiSeries.Points.AddXY(date, rsi[i]);
}
rsiDataResultChart.ChartAreas[0].AxisY.Minimum = Math.Floor(closeData.Select(p => p.GetElement("Kapanis").Value.ToDouble()).Min());
rsiDataResultChart.ChartAreas[0].AxisY.Maximum = Math.Ceiling(closeData.Select(p => p.GetElement("Kapanis").Value.ToDouble()).Max());
rsiIndicatorResultChart.ChartAreas[0].AxisY.Minimum = 0;
rsiIndicatorResultChart.ChartAreas[0].AxisY.Maximum = 100;
rsiDataResultChart.Invalidate();
rsiIndicatorResultChart.Invalidate();
rsiResultPanel.BringToFront();
}
public override void Initialize()
{
// backtest parameters
// we have data for these dates locally
var start = new DateTime(2020, 01, 01, 09, 30, 0);
SetStartDate(start);
SetEndDate(start.AddDays(30));
SetCash(100000);
// set security and option universe for tradebar
_spy = AddEquity("SPY", Resolution.Minute);
var option = AddOption("SPY", Resolution.Minute);
// set filter on option universe
_optionSymbol = option.Symbol;
option.SetFilter(universe =>
from symbol in universe
.WeeklysOnly().Expiration(TimeSpan.Zero, TimeSpan.FromDays(10))
where symbol.ID.OptionRight != OptionRight.Put
select symbol);
// use the underlying equity as the benchmark
SetBenchmark("SPY");
// Creates a Rolling Window indicator to hold 2 TradeBars
_window = new RollingWindow <TradeBar>(2);
// Creates a Rolling Window indicator to hold 1 option contract
_optionWindow = new RollingWindow <OptionContract>(1);
// create RSI indicator
fast = new RelativeStrengthIndex("SPY", 14, MovingAverageType.Wilders);
// Create a Rolling Window to keep two Indicator Data Points
_rsiLag = new RollingWindow <IndicatorDataPoint>(2);
// define our 5 minute trade bar consolidator. we can access the 5 minute bar
// from the DataConsolidated events
var minConsolidator = new TradeBarConsolidator(TimeSpan.FromMinutes(5));
// attach our event handler. the event handler is a function that will be called each time we produce
// a new consolidated piece of data.
minConsolidator.DataConsolidated += OnFiveMinutes;
// this call adds our daily consolidator to the manager to receive updates from the engine
SubscriptionManager.AddConsolidator("SPY", minConsolidator);
// we need to manually register these indicators for automatic updates
RegisterIndicator("SPY", fast, minConsolidator);
Schedule.On(DateRules.EveryDay(), TimeRules.BeforeMarketClose(_spy.Symbol, 4), () =>
{
CloseOpenPositions(_spy);
});
SetWarmUp(TimeSpan.FromDays(100));
}
/// <summary>
/// Viene generato all'avvio dell'indicatore, si inizializza l'indicatore
/// </summary>
protected override void Initialize()
{
// --> Stampo nei log la versione corrente
Print("{0} : {1}", NAME, VERSION);
_ma = Indicators.MovingAverage(Source, MAPeriods, MaType);
_rsi = Indicators.RelativeStrengthIndex(_ma.Result, RSIPeriods);
_ema = Indicators.ExponentialMovingAverage(_rsi.Result, TPeriods);
}
protected override void OnStart()
{
i_TrendMovingAverage = Indicators.SimpleMovingAverage(MarketSeries.Close, (int)_TrendSMA);
i_Intermediate_SMA = Indicators.SimpleMovingAverage(MarketData.GetSeries(TimeFrame.Hour4).Close, (int)_DailyIntermediateTrend_SMA);
i_RSI_StopLoss = Indicators.RelativeStrengthIndex(MarketSeries.Close, (int)_wRSI_StopLossMA);
i_TriggerMovingAverage = Indicators.SimpleMovingAverage(MarketSeries.Close, (int)_SlowSMATrigger);
i_Average_True_Range = Indicators.AverageTrueRange((int)_ATR_MA, MovingAverageType.Simple);
i_RSI = Indicators.RelativeStrengthIndex(MarketSeries.Close, (int)_cRSI_MA);
}
public async Task TestRsiAsync()
{
var equity = await ImportEquityAsync();
var indicator = new RelativeStrengthIndex(equity, 14);
var result = indicator.ComputeByIndex(equity.Count - 1);
Assert.IsTrue(73.03m.IsApproximatelyEquals(result.Rsi.Value));
}
protected override void OnStart()
{
rsi = Indicators.RelativeStrengthIndex(Source, Periods);
_equity = Account.Balance;
Print("ScalpingWithRSI.OnStart() equity: ", _equity.ToString());
MakeBuySellOrder(Volume);
}
protected override void OnStart()
{
Positions.Closed += OnPositionsClosed;
rsi = Indicators.RelativeStrengthIndex(MarketData.GetSeries(TimeFrame.Hour).Close, 14);
sma = Indicators.SimpleMovingAverage(MarketData.GetSeries(TimeFrame.Minute5).Close, 800);
currentVolume = InitialVolume;
balance = Account.Balance;
Timer.Start(1);
}
protected override void OnStart()
{
_hmaslow = Indicators.GetIndicator <HMAslow>(SlowPeriod);
_macd = Indicators.MacdHistogram(LongCycle, ShortCycle, Period);
rsi = Indicators.RelativeStrengthIndex(Source, Periods);
Positions.Opened += PositionsOnOpened;
Positions.Closed += PositionsOnClosed;
}
protected override void OnStart()
{
rsi = Indicators.RelativeStrengthIndex(Source, Period0);
bol = Indicators.BollingerBands(Source, Period1, stdev, MovingAverageType.Simple);
//obtain high and low of initial start bar
double max = MarketSeries.High.LastValue;
double min = MarketSeries.Low.LastValue;
}
public async Task TestRsiAsync()
{
var candles = await ImportCandlesAsync();
var indicator = new RelativeStrengthIndex(candles, 14);
var result = indicator[candles.Count - 1];
Assert.IsTrue(73.03m.IsApproximatelyEquals(result.Value));
}
protected override void OnStart()
{
rsi = Indicators.RelativeStrengthIndex(Source, Period0);
bol = Indicators.BollingerBands(Source, Period1, stdev, MovingAverageType.Simple);
//obtain high and low of initial start bar
double max = MarketSeries.High.LastValue;
double min = MarketSeries.Low.LastValue;
}
public override void Initialize()
{
SetStartDate(1998, 1, 1);
SetEndDate(DateTime.Now);
SetCash(10000);
AddSecurity(SecurityType.Equity, Symbol, Resolution.Daily);
_rsi = new RelativeStrengthIndex(Symbol, 3, MovingAverageType.Simple);
}
public void ComparesAgainstExternalData()
{
var rsiSimple = new RelativeStrengthIndex("rsi", 14, MovingAverageType.Simple);
TestHelper.TestIndicator(rsiSimple, "RSI 14");
var rsiWilder = new RelativeStrengthIndex("rsi", 14, MovingAverageType.Wilders);
TestHelper.TestIndicator(rsiWilder, "RSI 14 Wilder");
}
protected override void OnStart()
{
currentVolume = InitialVolume;
Positions.Closed += OnPositionsClosed;
Timer.Start(60);
var marketSeriesMin10 = MarketData.GetSeries(TimeFrame.Minute10);
rsiMin10 = Indicators.RelativeStrengthIndex(marketSeriesMin10.Close, 14);
rsi = Indicators.RelativeStrengthIndex(MarketSeries.Close, 14);
}
protected override void Initialize()
{
_atrRsi = CreateDataSeries();
CreateDataSeries();
_wildersPeriod = Period * 2 - 1;
_startBar = _wildersPeriod < SF ? SF : _wildersPeriod;
_rsi = Indicators.RelativeStrengthIndex(MarketSeries.Close, Period);
_emaRsi = Indicators.ExponentialMovingAverage(_rsi.Result, SF);
_emaAtr = Indicators.ExponentialMovingAverage(_atrRsi, _wildersPeriod);
_ema = Indicators.ExponentialMovingAverage(_emaAtr.Result, _wildersPeriod);
}
protected override void Initialize()
{
DataSeries ds;
ds = MarketSeries.Typical;
if (is_typic)
{
ds = MarketSeries.Typical;
}
if (is_wclose)
{
ds = MarketSeries.WeightedClose;
}
if (is_median)
{
ds = MarketSeries.Median;
}
rsi = Indicators.RelativeStrengthIndex(ds, Period);
}
protected override void Initialize()
{
rsi = Indicators.RelativeStrengthIndex(Source, Period);
bbands = Indicators.BollingerBands(rsi.Result, Period, stdDev, MAType);
}
protected override void Initialize()
{
// Initialize and create nested indicators
macdCrossOver = Indicators.MacdCrossOver(source, longCycle, shortCycle, Periods);
rsi = Indicators.RelativeStrengthIndex(source, Periods);
}
protected override void OnStart()
{
rsi = Indicators.RelativeStrengthIndex(Source, Periods);
ma = Indicators.MovingAverage(Source, MAPeriod, MAType);
}
// func()
protected override void OnStart()
{
// demonstrate using indicators easier to compute in pre-build cAlgo
// code than to compute in the external system.
//rsiBase = Indicators.RelativeStrengthIndex(DataSeries, RSIPeriod);
rsi = Indicators.RelativeStrengthIndex(Source, RSIPeriod);
stdDev = Indicators.StandardDeviation(Source, RSIPeriod, MovingAverageType.Simple);
var ticktype = MarketSeries.TimeFrame.ToString();
fiName = DataDir + "\\" + "exp-" + Symbol.Code + "-" + ticktype + "-rsi" + RSIPeriod + "-stddev" + StdDevPeriod + "-bars.csv";
Print("fiName=" + fiName);
if (System.IO.Directory.Exists(DataDir) == false)
{
System.IO.Directory.CreateDirectory(DataDir);
}
if (System.IO.File.Exists(fiName) == false)
{
// generate new file with CSV header only if
// one does not already exist.
System.IO.File.WriteAllText(fiName, csvhead);
}
else
{
maxDate = get_most_recent_date(fiName);
}
Print("maxDate=" + maxDate);
// had to open file this way to prevent .net from locking it and preventing
// access by other processes when using to download live ticks.
fstream = File.Open(fiName, FileMode.Open, FileAccess.Write, FileShare.ReadWrite);
// setup to append to end of file
Print("File is Open");
fstream.Seek(0, SeekOrigin.End);
// write stream has to be created after seek due to .net wierdness
// creating with 0 prevents buffering since we want tick data
// to be available to consumers right away.
fwriter = new System.IO.StreamWriter(fstream, System.Text.Encoding.UTF8, 1);
// QUESTION: How to tell when in Backtest mode so we
// can create the stream with a large buffer and turn off
// auto flush to improve IO performance.
Print("Fwriter is created");
fwriter.AutoFlush = true;
// with autoflush true will autocleanup
// since we can not close since we may run forever
Print("done onStart()");
}
protected override void OnStart()
{
_botName = ToString();
_instanceLabel = string.Format("{0}-{1}-{2}-{3}", _botName, _botVersion, Symbol.Code, TimeFrame.ToString());
rsi = Indicators.RelativeStrengthIndex(RsiSource, RsiPeriod);
pipsATR = Indicators.GetIndicator<PipsATRIndicator>(TimeFrame, AtrPeriod, AtrMaType);
minPipsATR = pipsATR.Result.Minimum(pipsATR.Result.Count);
maxPipsATR = pipsATR.Result.Maximum(pipsATR.Result.Count);
}
protected override void Initialize()
{
rsi = Indicators.RelativeStrengthIndex(Source, rsiperiods);
sma = Indicators.SimpleMovingAverage(Source, smaperiods);
}
protected override void OnStart()
{
_SOC = Indicators.StochasticOscillator(KPeriods, KSlowing, DPeriods, MovingAverageType.Simple);
_MACD = Indicators.MacdCrossOver(LongCycle, ShortCycle, MACDPeriod);
_RSI = Indicators.RelativeStrengthIndex(MarketSeries.Close, RSIPeriods);
fastMa = Indicators.ExponentialMovingAverage(MarketSeries.Close, FastPeriods);
slowMa = Indicators.ExponentialMovingAverage(MarketSeries.Close, SlowPeriods);
TakeProfit = TakeProfit * 10;
PipStart = PipStep / 10;
PipStep = PipStep * 10;
PipMulti = PipStep / 100;
}
protected override void OnStart()
{
rsi = Indicators.RelativeStrengthIndex(Source, Periods);
}
protected override void Initialize()
{
_cyclePrice = CreateDataSeries();
_zeroLag = CreateDataSeries();
_ma = Indicators.MovingAverage(MarketSeries.Close, PriceActionFilter, MaType);
_rsi = Indicators.RelativeStrengthIndex(_cyclePrice, 14);
_useCycleFilter = UseCycleFilter == 1;
}
protected override void Initialize()
{
rsi = Indicators.RelativeStrengthIndex(DataSource, Period);
value1 = CreateDataSeries();
}
protected override void Initialize()
{
_fastEma = Indicators.ExponentialMovingAverage(MarketSeries.Close, FastEMA);
_slowEma = Indicators.ExponentialMovingAverage(MarketSeries.Close, SlowEMA);
iRSI = Indicators.RelativeStrengthIndex(MarketSeries.Close, RSIPeriod);
}
protected override void Initialize()
{
_weightedMovingAverage = Indicators.WeightedMovingAverage(MarketSeries.Close, 21);
_averageTrueRange = Indicators.GetIndicator<AverageTrueRange>(100);
_relativeStrengthIndex = Indicators.RelativeStrengthIndex(TMA, rsiPeriod);
}
protected override void Initialize()
{
rsi = Indicators.RelativeStrengthIndex(MarketSeries.Close, Period);
}
