private static string GetFormattedMessage(string source, Instrument instrument, string message)
{
string prefix = string.Format("[{0} | {1}]", instrument.Symbol.ToUpper(), source.ToUpper());
string datePart = string.Format("[{0:dd-MMM-yyyy hh:mm:ss.fff tt}]", DateTime.Now);
const string formattedString = "{0} -- {1} -- {2}";
return string.Format(formattedString, prefix, datePart, message);
}
///<summary>
/// Returns bar series by instrument
///</summary>
public BarSeries this [Instrument instrument]
{
get
{
return new BarSeries(FreeQuant.Instruments.DataManager.Bars[Map.OQ_FQ_Instrument[(object)instrument] as FreeQuant.Instruments.Instrument]);
}
}
///<summary>
/// Gets bar series by instrument, bar type and bar size
///</summary>
public BarSeries this [Instrument instrument, BarType barType, long barSize]
{
get
{
return new BarSeries(FreeQuant.Instruments.DataManager.Bars[Map.OQ_FQ_Instrument[(object)instrument] as FreeQuant.Instruments.Instrument, EnumConverter.Convert(barType), barSize]);
}
}
internal static void WriteTraceLog(this Logger log, string source, Instrument instrument, string message)
{
if (!log.IsTraceEnabled)
return;
log.Trace(GetFormattedMessage(source, instrument, message));
}
public BarSeries this[Instrument instrument]
{
get
{
SmartQuant.Instruments.Instrument instrument2 = Map.OQ_SQ_Instrument[instrument] as SmartQuant.Instruments.Instrument;
return new BarSeries(SmartQuant.Instruments.DataManager.Bars[instrument2]);
}
}
public BarSeries this[Instrument instrument, BarType barType, long barSize]
{
get
{
SmartQuant.Instruments.Instrument instrument2 = Map.OQ_SQ_Instrument[instrument] as SmartQuant.Instruments.Instrument;
return new BarSeries(SmartQuant.Instruments.DataManager.Bars[instrument2, EnumConverter.Convert(barType), barSize]);
}
}
public static BarSeries GetHistoricalBars(Instrument instrument, DateTime begin, DateTime end, BarType barType, long barSize)
{
FreeQuant.Instruments.Instrument instrument1 = Map.OQ_FQ_Instrument[(object)instrument] as FreeQuant.Instruments.Instrument;
if (barSize == 86400)
return new BarSeries((FreeQuant.Series.BarSeries)FreeQuant.Instruments.DataManager.GetDailySeries(instrument1, begin, end));
else
return new BarSeries(FreeQuant.Instruments.DataManager.GetBarSeries(instrument1, begin, end, EnumConverter.Convert(barType), barSize));
}
public static BarSeries GetHistoricalBars(Instrument instrument, DateTime begin, DateTime end, BarType barType, long barSize)
{
SmartQuant.Instruments.Instrument instrument2 = Map.OQ_SQ_Instrument[instrument] as SmartQuant.Instruments.Instrument;
if (barSize == 86400L)
{
return new BarSeries(SmartQuant.Instruments.DataManager.GetDailySeries(instrument2, begin, end));
}
return new BarSeries(SmartQuant.Instruments.DataManager.GetBarSeries(instrument2, begin, end, EnumConverter.Convert(barType), barSize));
}
public static TradeSeries GetHistoricalTrades(string provider, Instrument instrument, DateTime begin, DateTime end)
{
TradeSeries tradeSeries = new TradeSeries();
if (FreeQuant.Providers.ProviderManager.HistoricalDataProviders.Contains(provider))
{
foreach (FreeQuant.Data.Trade trade in (DataArray) FreeQuant.Instruments.DataManager.GetHistoricalTrades(FreeQuant.Providers.ProviderManager.HistoricalDataProviders[provider], instrument.instrument, begin, end))
tradeSeries.series.Add((IDataObject)trade);
}
return tradeSeries;
}
public static QuoteSeries GetHistoricalQuotes(string provider, Instrument instrument, DateTime begin, DateTime end)
{
QuoteSeries quoteSeries = new QuoteSeries();
if (FreeQuant.Providers.ProviderManager.HistoricalDataProviders.Contains(provider))
{
foreach (FreeQuant.Data.Quote quote in (DataArray) FreeQuant.Instruments.DataManager.GetHistoricalQuotes(FreeQuant.Providers.ProviderManager.HistoricalDataProviders[provider], instrument.instrument, begin, end))
quoteSeries.series.Add((IDataObject)quote);
}
return quoteSeries;
}
public Position this[Instrument instrument]
{
get
{
FreeQuant.Instruments.Position position = this.positionList[instrument.instrument];
if (position != null)
return new Position(position);
else
return (Position) null;
}
}
public static BarSeries GetHistoricalBars(string provider, Instrument instrument, DateTime begin, DateTime end, int size)
{
BarSeries barSeries = new BarSeries();
if (FreeQuant.Providers.ProviderManager.HistoricalDataProviders.Contains(provider))
{
IHistoricalDataProvider provider1 = FreeQuant.Providers.ProviderManager.HistoricalDataProviders[provider];
foreach (FreeQuant.Data.Bar bar in size != 86400 ? (FreeQuant.Series.TimeSeries) FreeQuant.Instruments.DataManager.GetHistoricalBars(provider1, instrument.instrument, begin, end, (long) size) : (FreeQuant.Series.TimeSeries) FreeQuant.Instruments.DataManager.GetHistoricalDailies(provider1, instrument.instrument, begin, end))
barSeries.series.Add(bar);
}
return barSeries;
}
public Position this[Instrument instrument]
{
get
{
SmartQuant.Instruments.Position position = this.positionList[instrument.instrument];
if (position != null)
{
return new Position(position);
}
return null;
}
}
public static QuoteSeries GetHistoricalQuotes(string provider, Instrument instrument, DateTime begin, DateTime end)
{
QuoteSeries quoteSeries = new QuoteSeries();
if (SmartQuant.Providers.ProviderManager.HistoricalDataProviders.Contains(provider))
{
QuoteArray historicalQuotes = SmartQuant.Instruments.DataManager.GetHistoricalQuotes(SmartQuant.Providers.ProviderManager.HistoricalDataProviders[provider], instrument.instrument, begin, end);
foreach (SmartQuant.Data.Quote obj in historicalQuotes)
{
quoteSeries.series.Add(obj);
}
}
return quoteSeries;
}
public QuantityTradeLeg(int idx, Instrument instrument, OrderSide orderSide, double qty)
: base(idx, instrument, orderSide)
{
this.QuantityToFill = qty;
this.LegName = string.Format("Q{0}.{1}.{2}.{3}",
this.Index,
this.Instrument.Symbol.ToUpper(),
this.OrderSide,
this.QuantityToFill);
Log.WriteInfoLog(LegName,
this.Instrument,
string.Format("Quantity leg generated to {0} {1:N2} units", this.OrderSide.ToString().ToUpper(), this.QuantityToFill));
}
public AmountTradeLeg(int idx, Instrument instrument, OrderSide orderSide, double amt)
: base(idx, instrument, orderSide)
{
this.AmountToFill = amt;
this.LegName = string.Format("A{0}.{1}.{2}.{3:c}",
this.Index,
this.Instrument.Symbol.ToUpper(),
this.OrderSide,
this.AmountToFill);
Log.WriteInfoLog(LegName,
this.Instrument,
string.Format("Amount leg generated to {0} {1:c2}", this.OrderSide.ToString().ToUpper(), this.AmountToFill));
}
private double GetAmount(Instrument instrument, double amount)
{
if (instrument.Quote.DateTime != DateTime.MinValue)
{
return (instrument.Quote.Ask + instrument.Quote.Bid) / 2.0;
}
if (instrument.Trade.DateTime != DateTime.MinValue && instrument.Trade.DateTime >= instrument.Bar.DateTime)
{
return instrument.Trade.Price;
}
if (instrument.Bar.DateTime != DateTime.MinValue)
{
return instrument.Bar.Close;
}
return 1.0;
}
public override void OnStrategyStart()
{
if (Instrument1 == null)
{
Instrument1 = Instrument;
}
else if (Instrument2 == null)
{
Instrument2 = Instrument;
}
barSize = long.MaxValue;
foreach (BarRequest barRequest in DataRequests.BarRequests)
{
barSize = Math.Min(barSize, barRequest.BarSize);
}
Console.WriteLine("barSize = {0}", barSize);
}
/// <summary>
///
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
private double GetPriceStep(double input, Instrument instrument)
{
double retValue = 0.01;
if (instrument.Type == InstrumentType.Futures)
{
if (string.Compare(instrument.Symbol, "ES", true) == 0)
{
retValue = 0.25;
}
}
else if (instrument.Type == InstrumentType.Stock)
{
if (input < 1)
retValue = 0.001;
}
return retValue;
}
public void Add(DateTime datetime, TransactionSide side, double qty, Instrument instrument, double price, string text)
{
Side side2;
switch (side)
{
case TransactionSide.Buy:
side2 = Side.Buy;
break;
case TransactionSide.Sell:
side2 = Side.Sell;
break;
default:
throw new ArgumentException(string.Format("Unknown TransactionSide - {0} ", side));
}
SmartQuant.Instruments.Transaction transaction = new SmartQuant.Instruments.Transaction(datetime, side2, qty, instrument.instrument, price);
transaction.Currency = CurrencyManager.Currencies[instrument.instrument.Currency];
if (text != null)
{
transaction.Text = text;
}
this.portfolio.Add(transaction);
}
public static BarSeries GetHistoricalBars(string provider, Instrument instrument, DateTime begin, DateTime end, int size)
{
BarSeries barSeries = new BarSeries();
if (SmartQuant.Providers.ProviderManager.HistoricalDataProviders.Contains(provider))
{
IHistoricalDataProvider provider2 = SmartQuant.Providers.ProviderManager.HistoricalDataProviders[provider];
SmartQuant.Series.BarSeries barSeries2;
if (size == 86400)
{
barSeries2 = SmartQuant.Instruments.DataManager.GetHistoricalDailies(provider2, instrument.instrument, begin, end);
}
else
{
barSeries2 = SmartQuant.Instruments.DataManager.GetHistoricalBars(provider2, instrument.instrument, begin, end, (long)size);
}
foreach (SmartQuant.Data.Bar bar in barSeries2)
{
barSeries.series.Add(bar);
}
}
return barSeries;
}
internal static void WriteHorizontalBreak(this Logger log, string source, Instrument instrument)
{
WriteInfoLog(log, source, instrument, "----------------------------");
}
protected ATR GetAtr(Instrument instrument, int period)
{
BarSeries dailyBarSeries = null;
string instId = instrument.ToIdentifier();
dailyBarSeriesDictionary.TryGetValue(instId, out dailyBarSeries);
if (dailyBarSeries == null || dailyBarSeries.Count <= 0)
throw new ApplicationException("Daily bar series has not been initialized");
string atrId = string.Format("{0}:{1}", instId, period);
if (!atrDictionary.ContainsKey(atrId))
{
lock (LockObject)
{
if (!atrDictionary.ContainsKey(atrId))
{
ATR atr = new ATR(dailyBarSeries, period);
atrDictionary.Add(atrId, atr);
}
}
}
return atrDictionary[atrId];
}
internal void Remove(Instrument instrument)
{
this.list.Remove(instrument.Symbol);
}
private void AttachInstrument(Project prj, string symbol)
{
if (string.IsNullOrEmpty(symbol))
return;
string trimmedSymbol = symbol.Trim();
string normalizedSymbol = string.Empty;
if (trimmedSymbol.Length > 0)
{
normalizedSymbol = trimmedSymbol.Replace(".", "");
Instrument currentIns = InstrumentManager.Instruments[normalizedSymbol];
if (null == currentIns || currentIns.Type != InstrumentType.Stock)
{
Console.WriteLine("ADDING SYMBOL -- " + trimmedSymbol);
Instrument newInstrument = new Instrument(InstrumentType.Stock, normalizedSymbol);
newInstrument.Currency = defaultCurrency;
newInstrument.Exchange = defaultExchange;
int dotIdx = trimmedSymbol.IndexOf('.');
if (dotIdx > -1)
{
AltIDGroup ibAltIdGroup = newInstrument.AltIDGroups.Add("IB");
ibAltIdGroup.AltSource = "IB";
ibAltIdGroup.AltSymbol = trimmedSymbol.Replace(".", " ");
}
}
currentIns = InstrumentManager.Instruments[normalizedSymbol];
if (null != currentIns)
prj.AddInstrument(currentIns);
}
}
/// <summary>
///
/// </summary>
/// <param name="instrument"></param>
/// <param name="atrPeriod"></param>
/// <param name="triggerTime"></param>
/// <returns></returns>
protected double GetAtrValue(Instrument instrument, int atrPeriod, DateTime triggerTime)
{
ATR atr = GetAtr(instrument, atrPeriod);
double returnValue = 0;
int idx = atr.Count - 1;
bool found = false;
while (!found && idx >= 0)
{
if (atr.GetDateTime(idx) < triggerTime)
{
found = true;
returnValue = atr[idx];
break;
}
idx--;
}
if (!found || returnValue <= 0)
throw new ApplicationException(string.Format("Count not retrieve an ATR for {0} before bar {1}", instrument.Symbol, triggerTime));
LoggingUtility.WriteInfo(LoggingConfig, string.Format("Found ATR value of {0:c} as of {1}", returnValue, atr.GetDateTime(idx)));
return returnValue;
}
private void PreLoadDailyDataImpl(Instrument instrument, BarDuration duration)
{
BarSeries series = null;
string id = instrument.ToIdentifier();
Dictionary<string, BarSeries> dictionaryToUse = null;
if (duration == BarDuration.Daily)
dictionaryToUse = dailyBarSeriesDictionary;
else if (duration == BarDuration.Minutely)
dictionaryToUse = minutelyBarSeriesDictionary;
else
throw new ArgumentOutOfRangeException("duration", duration, "Incorrect value for duration");
dictionaryToUse.TryGetValue(id, out series);
if (null != series && series.Count >= 1)
return;
DateTime start = DateTime.Now;
if (duration == BarDuration.Daily)
series = GetHistoricalBars("IB", Instrument, DateTime.Now.AddDays(-60), DateTime.Now, PeriodConstants.PERIOD_DAILY);
else if (duration == BarDuration.Minutely)
series = GetHistoricalBars("IB", instrument, DateTime.Now.AddDays(-5), DateTime.Now, PeriodConstants.PERIOD_MINUTE);
DateTime end = DateTime.Now;
LoggingUtility.WriteDebug(LoggingConfig, string.Format("Took {0}ms to retrieve data from IB for {1} data", end.Subtract(start).TotalMilliseconds, duration));
dictionaryToUse[id] = series;
start = DateTime.Now;
foreach (Bar currentBar in series)
{
Bars.Add(currentBar);
if (PersistHistoricalData)
DataManager.Add(Instrument, currentBar);
}
end = DateTime.Now;
LoggingUtility.WriteDebug(LoggingConfig, string.Format("Took {0}ms to load data into memory for {1} data", end.Subtract(start).TotalMilliseconds, duration));
}
/// <summary>
///
/// </summary>
/// <param name="instrument"></param>
protected void PreLoadBarData(Instrument instrument)
{
PreLoadDailyDataImpl(instrument, BarDuration.Minutely);
PreLoadDailyDataImpl(instrument, BarDuration.Daily);
}
protected Bar GetPreviousDayBar(Instrument instrument)
{
Bar retVal = null;
string instId = instrument.ToIdentifier();
BarSeries barsToUse = dailyBarSeriesDictionary[instId];
if (barsToUse.Count > 0)
{
int idx = 0;
bool found = false;
while (!found && idx <= barsToUse.Count - 1)
{
Bar prevBar = barsToUse.Ago(idx);
if (prevBar.EndTime.Date <= DateTime.Today)
{
if (prevBar.IsWithinRegularTradingHours(Instrument.Type))
{
found = DateTime.Today.Subtract(prevBar.BeginTime.Date).TotalDays >= 1;
if (!found && DateTime.Now.IsPastRegularTradingHours(Instrument.Type))
found = DateTime.Today.Subtract(prevBar.BeginTime.Date).TotalDays >= 0;
}
}
if (found)
retVal = prevBar;
else
idx++;
}
}
if (retVal == null)
throw new ApplicationException(string.Format("Count not retreive a daily bar prior to {0}", DateTime.Today));
LoggingUtility.WriteDebug(LoggingConfig, string.Format("Previous closing bar was {0}", retVal));
return retVal;
}
/// <summary>
///
/// </summary>
/// <param name="bar"></param>
/// <returns></returns>
protected Bar GetPreviousBar(Instrument instrument, Bar bar, int period)
{
Bar retVal = null;
BarSeries barsToUse = null;
string instId = instrument.ToIdentifier();
Dictionary<string, BarSeries> dictionaryToUse = null;
bool isSessionOpenBar = bar.IsSessionOpenBar(Instrument.Type);
bool isDailyPeriod = period == PeriodConstants.PERIOD_DAILY;
if (isDailyPeriod) // || isSessionOpenBar
dictionaryToUse = dailyBarSeriesDictionary;
else
dictionaryToUse = minutelyBarSeriesDictionary;
barsToUse = dictionaryToUse[instId];
if (barsToUse.Count > 0)
{
int idx = 0;
bool found = false;
while (!found && idx <= barsToUse.Count - 1)
{
Bar prevBar = barsToUse.Ago(idx);
if ((prevBar.EndTime <= bar.BeginTime) && prevBar.IsWithinRegularTradingHours(Instrument.Type))
{
if (isSessionOpenBar || isDailyPeriod)
{
found = DateTime.Today.Subtract(prevBar.BeginTime.Date).TotalDays >= 1;
if (!found && DateTime.Now.IsPastRegularTradingHours(Instrument.Type))
found = DateTime.Today.Subtract(prevBar.BeginTime.Date).TotalDays >= 0;
}
else
{
found = true;
}
}
if (found)
retVal = prevBar;
else
idx++;
}
}
if (retVal == null)
throw new ApplicationException(string.Format("Count not retreive a period {0} bar to {1}", period, bar));
LoggingUtility.WriteDebug(LoggingConfig, string.Format("Previous closing bar was {0}", retVal));
return retVal;
}
/// <summary>
///
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public double RoundPrice(double input, Instrument instrument)
{
double step = GetPriceStep(input, instrument);
return Math.Round(input / step) * step;
}
internal void Add(string symbol, Instrument instrument)
{
this.list.Add(symbol, instrument);
}
