public static decimal BarSMA(BarList bl, BarInterval bi, int barsback)
{
if (!bl.Has(barsback))
{
return(bl.Get(bl.Last).Close);
}
decimal sum = 0;
for (int i = 0; i < barsback; i++)
{
try
{
sum += bl.Get(bl.Last - i, bi).Close;
}
catch (ArgumentOutOfRangeException)
{
// ArgumentOutOfRange is thrown when:
// (bars requested) > (bars you have)
// TO FIX:
// make sure you call bl.Has(NumOfBarsYouNeed)
// before you call bl.Get(BarNumIDontYetHave)
}
}
return(sum / barsback);
}
public void Chart_MouseUp(object sender, MouseEventArgs e)
{
if (e.Delta == 0)
{
return;
}
BarInterval old = bl.Int;
BarInterval [] v = (BarInterval [])Enum.GetValues(typeof(BarInterval));
int biord = 0;
for (int i = 0; i < v.Length; i++)
{
if (old == v[i])
{
biord = i;
}
}
if (e.Delta > 0)
{
bl.Int = (biord + 1 < v.Length) ? v[biord + 1] : v[0];
}
else
{
bl.Int = (biord - 1 < 0) ? v[v.Length - 1] : v[biord - 1];
}
if ((bl.Int != old) && bl.Has(1))
{
NewBarList(this.bl);
}
}
public Bollinger(decimal sds, BarInterval bi, int lookback)
{
this.sds = sds;
this.bi = bi;
this.lookback = lookback;
isbarcons = true;
}
public BarList this[BarInterval interval]
{
get
{
return(this[(int)interval]);
}
}
public override void Reset()
{
// enable prompting of system parameters to user,
// so they do not have to recompile to change things
ParamPrompt.Popup(this, true, _black);
Int32 numOfInterval = 1;
BarInterval[] intervaltypes = new BarInterval[numOfInterval];
Int32[] intervalValues = new Int32[numOfInterval];
for (Int32 i = 0; i < numOfInterval; i++)
{
intervaltypes[i] = BarType;
intervalValues[i] = NumItemPerBar;
}
_blt = new BarListTracker(intervalValues, intervaltypes);
_blt.GotNewBar += new SymBarIntervalDelegate(blt_GotNewBar);
GenericParamUpdateHelper.updateParam(this, GenericParameter, false);
Hashtable TD_combinationInputParamTmp = new Hashtable();
TD_combinationInputParamTmp["lookbackperiod"] = _barsback;
TD_combinationInputParamTmp["minmumsignallength"] = _barsback;
_TD_combinationFromATSGlobalIndicator = new ATSGlobalIndicatorPersonal.TD_combination();
_TD_combinationFromATSGlobalIndicator.Param = TD_combinationInputParamTmp;
_TD_combinationFromATSGlobalIndicator.Initializatin();
_isShutDown = false;
TotalProfit = 0m;
_pt.Clear();
}
/// <summary>
/// Example: to get 15 minute bars,
/// interval = ChartInterval.Minute
/// period = 15
/// </summary>
/// <param name="market"></param>
/// <param name="interval"></param>
/// <param name="period"></param>
/// <param name="startDate"></param>
/// <param name="endDate">Leave endDate = null for realtime (endDate = current date)</param>
static public EZChartDataSeries MakeChartData(EZInstrument instrument, ezBarInterval barInterval, DateTime startDate, DateTime?endDate = null)
{
Market market = APIMain.MarketFromInstrument(instrument);
// Load the data for the selected market.
BarInterval interval = new BarInterval(APIConvert.ToChartInterval(barInterval.Interval), barInterval.Period);
ChartDataSeries ctsChartData = new ChartDataSeries(market, interval, SessionTimeRange.Empty);
var session = new ezSessionTimeRange();
EZChartDataSeries chartData = new EZChartDataSeries(market.Description, barInterval, session);
var chartThread = new ChartDataThread(ctsChartData, chartData, startDate, endDate);
var thread = new Thread(new ThreadStart(chartThread.Run));
thread.Name = market.Description + ":" + barInterval;
thread.Start();
return(chartData);
//dataPoints = new List<ezBarDataPoint>();
/*foreach (HistoricalQuote hq in historical)
* {
* ezBarDataPoint dp = new ezBarDataPoint(hq.Open, hq.High, hq.Low, hq.Close, 0, hq.Volume);
* dataPoints.Add(dp);
* }*/
}
/// <summary>
/// gets a specific bar in specified interval
/// </summary>
/// <param name="barnumber"></param>
/// <param name="interval"></param>
/// <param name="size"></param>
/// <returns></returns>
public Bar this[int barnumber, BarInterval interval, int size] {
get { var idx = Gettypesizeidx(interval, size); if (idx < 0)
{
return(new BarImpl());
}
return(_intdata[idx].GetBar(barnumber, Symbol)); }
}
public void Chart_MouseUp(object sender, MouseEventArgs e)
{
if (e.Delta == 0)
{
return;
}
BarInterval old = bl.DefaultInterval;
BarInterval [] v = bl.Intervals;
int biord = 0;
for (int i = 0; i < v.Length; i++)
{
if (old == v[i])
{
biord = i;
}
}
if (e.Delta > 0)
{
bl.DefaultInterval = (biord + 1 < v.Length) ? v[biord + 1] : v[0];
}
else
{
bl.DefaultInterval = (biord - 1 < 0) ? v[v.Length - 1] : v[biord - 1];
}
if ((bl.DefaultInterval != old) && bl.Has(1, bl.DefaultInterval))
{
Bars = this.bl;
}
}
public void LoadHistoricalChartData(object chartIdentifier, DateTime startDate, DateTime endDate)
{
ChartIdentifier = chartIdentifier;
StartDate = startDate;
EndDate = endDate;
Market market = chartIdentifier as Market;
ezDateRange dateRangeRequested = new ezDateRange();
ezDateRange dateRangeProcessed = new ezDateRange();
// Start with an empty set of TradeBars.
chartData.TradeBars.Clear();
// Load the data for the selected market.
BarInterval interval = new BarInterval(APIConvert.ToChartInterval(BarInterval.Interval), BarInterval.Period);
ChartDataSeries ctsChartData = new ChartDataSeries(market, interval, SessionTimeRange.Empty);
var session = new ezSessionTimeRange();
/*EZChartDataSeries myChartData = new EZChartDataSeries(market.Description, BarInterval, session);
* myChartData.DataLoadComplete += myChartData_DataLoadComplete;
* myChartData.DataSeriesUpdated += myChartData_DataSeriesUpdated;*/
var chartThread = new ChartDataThread(ctsChartData, chartData, startDate, endDate);
var thread = new Thread(new ThreadStart(chartThread.Run));
thread.Name = market.Description + ":" + BarInterval;
thread.Start();
//if (DataLoadComplete != null) DataLoadComplete(this, new ezDataLoadCompleteEventArgs(zDataLoadStatus.Success, dateRangeRequested, dateRangeProcessed));
}
public override string ToString()
{
var r = string.Empty;
var niceinterval = BarInterval.ToString();
if (isCustomInterval)
{
niceinterval += "_" + CustomInterval.ToString("F0");
}
if (isExplictBarsBack)
{
if (isExplicitEnd)
{
r = symbol + " " + niceinterval + " " + EndDate + " -> " + BarsBackExplicit;
}
else
{
r = symbol + " " + niceinterval + " -> " + BarsBackExplicit;
}
}
else
{
r = symbol + " " + Interval + " " + StartDateTime + "->" + EndDateTime;
}
if (isIdValid)
{
r += " " + ID;
}
return(r);
}
public static int BarsBackFromDate(BarInterval interval, DateTime startdate, DateTime enddate)
{
double start2endseconds = enddate.Subtract(startdate).TotalSeconds;
int bars = (int)((double)start2endseconds / (int)interval);
return(bars);
}
/// <summary>
/// converts integer array of intervals to BarIntervals... supplying custom interval for any unrecognized interval types.
/// </summary>
/// <param name="intervals"></param>
/// <returns></returns>
public static BarInterval[] Int2BarInterval(int[] intervals)
{
List <BarInterval> o = new List <BarInterval>(); foreach (int i in intervals)
{
try { BarInterval bi = (BarInterval)i; o.Add(bi); } catch (Exception) { o.Add(BarInterval.CustomTime); }
}
return(o.ToArray());
}
public override void Reset()
{
// enable prompting of system parameters to user,
// so they do not have to recompile to change things
ParamPrompt.Popup(this, true, _black);
Int32 numOfInterval = 1;
BarInterval[] intervaltypes = new BarInterval[numOfInterval];
Int32[] intervalValues = new Int32[numOfInterval];
for (Int32 i = 0; i < numOfInterval; i++)
{
intervaltypes[i] = BarType;
intervalValues[i] = NumItemPerBar;
}
_blt = new BarListTracker(intervalValues, intervaltypes);
_blt.GotNewBar += new SymBarIntervalDelegate(blt_GotNewBar);
#region <在策略中实现从外部文件读取参数>
//传递优化参数或系统参数
GenericParamUpdateHelper.updateParam(this, GenericParameter, false);
if (File.Exists(SMAExternalParam))
{
DataTable paramTableInput = null;
StreamReader sr = new StreamReader(SMAExternalParam, Encoding.GetEncoding("GB18030"));
paramTableInput = CsvParser.Parse(sr, true);
sr.Close();
foreach (DataRow dr in paramTableInput.Rows)
{
if (paramTableInput.Columns.Contains("key") && paramTableInput.Columns.Contains("value"))
{
string tmpKey = dr["key"].ToString();
string tmpValue = dr["value"].ToString();
if (tmpKey == "genericparam")
{
GenericParameter = tmpValue;
}
//传递外部参数
GenericParamUpdateHelper.updateParam(this, GenericParameter, false);
}
}
}
#endregion
Hashtable SMAInputParamTmp = new Hashtable();
SMAInputParamTmp["lookbackperiod"] = _barsback;
SMAInputParamTmp["minmumsignallength"] = 1;
_SMAFromATSGlobalIndicator = new ATSGlobalIndicatorPersonal.SMA();
_SMAFromATSGlobalIndicator.Param = SMAInputParamTmp;
_SMAFromATSGlobalIndicator.Initializatin();
_isShutDown = false;
TotalProfit = 0m;
_pt.Clear();
}
public int IntervalCount(BarInterval interval)
{
var idx = Gettypesizeidx(interval, (int)interval);
if (idx < 0)
{
return(-1);
}
return(_intdata[idx].Count());
}
/// <summary>
/// returns true if barslist has at least minimum # of bars for specified interval
/// </summary>
/// <param name="minBars"></param>
/// <param name="interval"></param>
/// <returns></returns>
public bool Has(int minBars, BarInterval interval, int size)
{
var idx = Gettypesizeidx(interval, size);
if (idx < 0)
{
return(false);
}
return(_intdata[idx].Count() >= minBars);
}
/// <summary>
/// gets count for given bar interval
/// </summary>
/// <param name="interval"></param>
/// <returns></returns>
public int IntervalCount(BarInterval interval, int size)
{
var idx = Gettypesizeidx(interval, size);
// interval not in this tracker
if (idx < 0)
{
return(-1);
}
return(_intdata[idx].Count());
}
public override void Reset() //对于新的一天来计算的时候要进行重置
{
// enable prompting of system parameters to user,
// so they do not have to recompile to change things
ParamPrompt.Popup(this, true, _black);
Int32 numOfInterval = 1;
BarInterval[] intervaltypes = new BarInterval[numOfInterval];
Int32[] intervalValues = new Int32[numOfInterval];
for (Int32 i = 0; i < numOfInterval; i++)
{
intervaltypes[i] = BarType;
intervalValues[i] = NumItemPerBar;
}
_blt = new BarListTracker(intervalValues, intervaltypes);
_blt.GotNewBar += new SymBarIntervalDelegate(blt_GotNewBar);
GenericParamUpdateHelper.updateParam(this, GenericParameter, false);
Hashtable ShortSMAInputParamTmp = new Hashtable(); //对于SMA indicator进行更新，用今天重新计算的SMA，而不用昨天
Hashtable LongSMAInputParamTmp = new Hashtable();
ShortSMAInputParamTmp["lookbackperiod"] = _shortbarsback;
LongSMAInputParamTmp["lookbackperiod"] = _shortbarsback + _incrementbarsback;
ShortSMAInputParamTmp["minmumsignallength"] = _shortbarsback;
LongSMAInputParamTmp["minmumsignallength"] = _shortbarsback + _incrementbarsback;
_ShortSMAFromATSGlobalIndicator = new ATSGlobalIndicatorPersonal.SMA();
_LongSMAFromATSGlobalIndicator = new ATSGlobalIndicatorPersonal.SMA();
_ShortSMAFromATSGlobalIndicator.Param = ShortSMAInputParamTmp;
_LongSMAFromATSGlobalIndicator.Param = LongSMAInputParamTmp;
_ShortSMAFromATSGlobalIndicator.Initializatin();
_LongSMAFromATSGlobalIndicator.Initializatin();
// reset the parameters of ATR
Hashtable ATRInputParamTmp = new Hashtable();
ATRInputParamTmp["lookbackperiod"] = _shortbarsback;
ATRInputParamTmp["minmumsignallength"] = 14;
_ATRFromATSGlobalIndicator = new ATSGlobalIndicatorPersonal.ATR();
_ATRFromATSGlobalIndicator.Param = ATRInputParamTmp;
_ATRFromATSGlobalIndicator.Initializatin();
//---------------------------------------------------------
_isShutDown = false;
TotalProfit = 0m;
_pt.Clear();
if (_shortbarsback != 34 || _incrementbarsback != 84)
{
Console.WriteLine("yo hey");
}
}
/// <summary>
/// Adds the tick to the barlist, creates other bars if needed.
/// </summary>
/// <param name="t">The tick to add.</param>
public bool newTick(Tick t)
{
if ((t.sym != Symbol) && (Symbol == ""))
{
this.sym = t.sym; // if we have no symbol, take ticks symbol
}
else if ((t.sym != Symbol) && (Symbol != ""))
{
return(NewBar); //don't process ticks for other stocks
}
if (!t.isTrade)
{
return(NewBar); // don't process quotes
}
// if we have no bars, add bar with a tick
if (Count == 0)
{
minlist.Add(new Bar(BarInterval.Minute));
fivelist.Add(new Bar(BarInterval.FiveMin));
fifteenlist.Add(new Bar(BarInterval.FifteenMin));
hourlist.Add(new Bar(BarInterval.Hour));
daylist.Add(new Bar(BarInterval.Day));
minlist[minlist.Count - 1].newTick(t);
fivelist[fivelist.Count - 1].newTick(t);
fifteenlist[fifteenlist.Count - 1].newTick(t);
hourlist[hourlist.Count - 1].newTick(t);
daylist[daylist.Count - 1].newTick(t);
}
else
{
// if we have at least a bar, get most current bar
BarInterval saveint = Int;
foreach (BarInterval inv in Enum.GetValues(typeof(BarInterval)))
{
Int = inv;
Bar cbar = RecentBar;
// if tick fits in current bar, then we're done for this interval
if (cbar.newTick(t))
{
continue;
}
else
{
DefaultBar.Add(new Bar(Int)); // otherwise we need another bar in this interval
DefaultBar[DefaultBar.Count - 1].newTick(t);
}
}
Int = saveint;
}
return(NewBar);
}
public void AddInterval(int interval, BarInterval barIntervalType)
{
// set default interval to first one
if (_intdata.Count == 0)
{
_defaultint = (int)barIntervalType;
_defaultcustint = interval;
_curintervalidx = 0;
}
//Check if we are adding a known interval size, twice
if (_intdata.Count(x => x.IntSize == interval) > 0)
{
return;
}
//Item to add
IntervalData newstream;
// save index to this size for the interval
switch (barIntervalType)
{
case BarInterval.CustomTicks:
newstream = new TickIntervalData(interval);
break;
case BarInterval.CustomTime:
newstream = new TimeIntervalData(interval);
break;
default:
newstream = new TimeIntervalData(interval);
break;
}
//Add new item
_intdata.Add(newstream);
// subscribe to bar events
newstream.NewBar += BarListImpl_NewBar;
// index the pair
_typesize2Idx.addindex((int)barIntervalType + interval.ToString(), _intdata.Count - 1);
// add known interval
if (!_custintervals.Contains(interval))
{
_custintervals.Add(interval);
}
}
/// <summary>
/// find the bar # that matches a given time
/// </summary>
/// <param name="bl"></param>
/// <param name="time"></param>
/// <param name="bint"></param>
/// <returns></returns>
public static int GetNearestIntraBar(BarList bl, int time, BarInterval bint)
{
long barid = TimeIntervalData.getbarid(time, bl.RecentBar.Bardate, (int)bint);
BarListImpl bli = (BarListImpl)bl;
TimeIntervalData tid = (TimeIntervalData)bli._intdata[bli._intdataidx[(int)bint]];
for (int i = 0; i < tid.Count(); i++)
{
if (tid.ids[i] == barid)
{
return(i);
}
}
return(-1);
}
/// <summary>
/// Initialize "_blt", the bar list tracker
/// </summary>
void Initialize_blt()
{
Int32 numOfInterval = 1;
BarInterval[] intervaltypes = new BarInterval[numOfInterval];
Int32[] intervalValues = new Int32[numOfInterval];
for (Int32 i = 0; i < numOfInterval; i++)
{
intervaltypes[i] = BarType;
intervalValues[i] = NumItemPerBar;
}
_blt = new BarListTracker(intervalValues, intervaltypes);
// Delegate handler when we got new bar
_blt.GotNewBar += new SymBarIntervalDelegate(blt_GotNewBar);
}
/// <summary>
/// Gets the specified bar number, with the specified bar interval.
/// </summary>
/// <param name="i">The barnumber.</param>
/// <param name="barinterval">The barinterval.</param>
/// <returns></returns>
public Bar Get(int i, BarInterval barinterval)
{
List <Bar> bars = new List <Bar>();
switch (barinterval)
{
case BarInterval.FiveMin: bars = fivelist; break;
case BarInterval.Minute: bars = minlist; break;
case BarInterval.FifteenMin: bars = fifteenlist; break;
case BarInterval.Hour: bars = hourlist; break;
case BarInterval.Day: bars = daylist; break;
}
return(bars[i]);
}
public Image DrawBarList(BarListImpl bl, BarInterval bi,Color up, Color down)
{
bl.DefaultInterval = bi;
Bitmap sl = new Bitmap(w, h);
Graphics g = Graphics.FromImage(sl);
high = Calc.HH(bl);
low = Calc.LL(bl);
decimal range = high - low;
int pixperdollar = range != 0 ? (int)(h / range) : 0;
int pixperbar = bl.Count != 0 ? (int)(w / (decimal)bl.Count) : 0;
for (int i = 0; i< bl.Count; i++)
{
Bar b = bl[i,bi];
Pen p = new Pen(b.Close>=b.Open ? up : down);
g.DrawLine(p, i * pixperbar, h-(int)((b.Low - low) * pixperdollar), i * pixperbar, h-(int)((b.High - low) * pixperdollar));
}
return sl;
}
public Image DrawBarList(BarListImpl bl, BarInterval bi, Color up, Color down)
{
bl.DefaultInterval = bi;
Bitmap sl = new Bitmap(w, h);
Graphics g = Graphics.FromImage(sl);
high = Calc.HH(bl);
low = Calc.LL(bl);
decimal range = high - low;
int pixperdollar = range != 0 ? (int)(h / range) : 0;
int pixperbar = bl.Count != 0 ? (int)(w / (decimal)bl.Count) : 0;
for (int i = 0; i < bl.Count; i++)
{
Bar b = bl[i, bi];
Pen p = new Pen(b.Close >= b.Open ? up : down);
g.DrawLine(p, i * pixperbar, h - (int)((b.Low - low) * pixperdollar), i * pixperbar, h - (int)((b.High - low) * pixperdollar));
}
return(sl);
}
/// <summary>
/// creates a barlist with array of custom intervals
/// </summary>
/// <param name="symbol"></param>
/// <param name="intervals"></param>
public BarListImpl(string symbol, int[] intervals, BarInterval[] types)
{ // set symbol
_sym = symbol;
// set intervals requested
_availint = intervals;
// size length of interval data to # of requested intervals
_intdata = new IntervalData[intervals.Length];
// create interval data object for each interval
for (int i = 0; i < intervals.Length; i++)
{
try
{
// save index to this data for the interval
_intdataidx.Add(intervals[i], i);
}
// if key was already present, already had this interval
catch (Exception) { continue; }
// set default interval to first one
if (i == 0)
_defaultint = intervals[0];
// create data object appropriate for type of interval
switch (types[i])
{
case BarInterval.CustomTicks:
_intdata[i] = new TickIntervalData(intervals[i]);
break;
case BarInterval.CustomVol:
_intdata[i] = new VolIntervalData(intervals[i]);
break;
default:
_intdata[i] = new TimeIntervalData(intervals[i]);
break;
}
// subscribe to bar events
_intdata[i].NewBar += new SymBarIntervalDelegate(BarListImpl_NewBar);
}
}
public static int GetNearestIntraBar(BarList bl, int time, BarInterval bint, DebugDelegate debug)
{
try
{
long barid = TimeIntervalData.getbarid(time, bl.RecentBar.Bardate, (int)bint);
BarListImpl bli = (BarListImpl)bl;
TimeIntervalData tid = (TimeIntervalData)bli._intdata[bli._intdataidx[(int)bint]];
for (int i = 0; i < tid.Count(); i++)
{
if (tid.ids[i] == barid)
{
return(i);
}
}
}
catch (Exception ex)
{
if (debug != null)
{
debug("error getting nearest bar from: " + bl.Symbol + " at: " + time + " for: " + bint + " error: " + ex.Message + ex.StackTrace);
}
}
return(-1);
}
public bool SetDefaultInterval(BarInterval type, int size)
{
bool found = false;
for (int i = 0; i < _intervaltypes.Length; i++)
{
var it = (BarInterval)_intervaltypes[i];
for (int x = 0; x < _custintervals.Count; x++)
{
var ints = _custintervals[x];
if ((it == type) && (size == ints))
{
_curintervalidx = x;
return(true);
}
}
}
//interval size is unkown thus add it
AddInterval(size, type);
//Return false
return(found);
}
/// <summary>
/// creates a barlist with requested interval. symbol will be defined by first tick received
/// </summary>
/// <param name="interval"></param>
public BarListImpl(BarInterval interval)
: this(string.Empty, new BarInterval[] { interval })
{
}
/// <summary>
/// creates a barlist with custom interval and a custom type (tick/vol)
/// </summary>
/// <param name="symbol"></param>
/// <param name="interval"></param>
/// <param name="type"></param>
public BarListImpl(string symbol, int interval, BarInterval type)
: this(symbol, new int[] { interval }, new BarInterval[] { type })
{
}
public static int BarsBackFromDate(BarInterval interval, int startdate, int enddate) { return BarsBackFromDate(interval, Util.ToDateTime(startdate, 0), Util.ToDateTime(enddate,Util.ToTLTime())); }
public static int BarsBackFromDate(BarInterval interval, int startdate, int enddate)
{
return(BarsBackFromDate(interval, Util.ToDateTime(startdate, 0), Util.ToDateTime(enddate, Util.ToTLTime())));
}
public static DateTime DateFromBarsBack(int barsback, BarInterval intv, DateTime enddate)
{
return(DateFromBarsBack(barsback, (int)intv, enddate));
}
/// <summary>
/// bar request for symbol and interval from previous date through present time
/// </summary>
/// <param name="symbol"></param>
/// <param name="interval"></param>
/// <param name="startdate"></param>
/// <returns></returns>
public static string BuildBarRequest(string symbol, BarInterval interval, int startdate)
{
return(BuildBarRequest(new BarRequest(symbol, (int)interval, startdate, 0, Util.ToTLDate(), Util.ToTLTime(), string.Empty)));
}
/// <summary>
/// find the bar # that matches a given time
/// </summary>
/// <param name="bl"></param>
/// <param name="time"></param>
/// <param name="bint"></param>
/// <returns></returns>
public static int GetNearestIntraBar(BarList bl, int time, BarInterval bint) { return GetNearestIntraBar(bl, time, bint, null); }
public int GetBarNumber(BarList bl, BarInterval bint)
{
return BarListImpl.GetNearestIntraBar(bl, Time, bint);
}
public int[] Date(BarInterval interval)
{
return _intdata[_intdataidx[(int)interval]].date().ToArray();
}
public BarImpl(BarInterval tu)
{
units = (int)tu;
}
public Image DrawBarListBlack(BarListImpl bl, BarInterval bi) { return DrawBarList(bl, bi, Color.Black,Color.Black); }
public decimal[] High(BarInterval interval)
{
return _intdata[_intdataidx[(int)interval]].high().ToArray();
}
public static int GetNearestIntraBar(BarList bl, int time, BarInterval bint,DebugDelegate debug)
{
try
{
long barid = TimeIntervalData.getbarid(time, bl.RecentBar.Bardate, (int)bint);
BarListImpl bli = (BarListImpl)bl;
TimeIntervalData tid = (TimeIntervalData)bli._intdata[bli._intdataidx[(int)bint]];
for (int i = 0; i < tid.Count(); i++)
if (tid.ids[i] == barid)
return i;
}
catch (Exception ex)
{
if (debug != null)
debug("error getting nearest bar from: " + bl.Symbol + " at: " + time + " for: " + bint + " error: " + ex.Message + ex.StackTrace);
}
return -1;
}
public decimal[] Close(BarInterval interval)
{
return _intdata[_intdataidx[(int)interval]].close().ToArray();
}
public static int BarsBackFromDate(BarInterval interval, DateTime startdate, DateTime enddate)
{
double start2endseconds = enddate.Subtract(startdate).TotalSeconds;
int bars = (int)((double)start2endseconds / (int)interval);
return bars;
}
/// <summary>
/// gets count of bars in specified interval
/// </summary>
/// <param name="interval"></param>
/// <returns></returns>
public int CountInterval(BarInterval interval)
{
return _intdata[_intdataidx[(int)interval]].Count();
}
public static DateTime DateFromBarsBack(int barsback, BarInterval intv, DateTime enddate) { return DateFromBarsBack(barsback, (int)intv, enddate); }
/// <summary>
/// returns true if barslist has at least minimum # of bars for specified interval
/// </summary>
/// <param name="minBars"></param>
/// <param name="interval"></param>
/// <returns></returns>
public bool Has(int minBars, BarInterval interval)
{
return minBars<=CountInterval(interval);
}
/// <summary>
/// gets most recent bar from specified interval
/// </summary>
/// <param name="interval"></param>
/// <returns></returns>
public Bar RecentBarInterval(BarInterval interval)
{
return this[LastInterval(interval), interval];
}
/// <summary>
/// gets a specific bar in specified interval
/// </summary>
/// <param name="barnumber"></param>
/// <param name="interval"></param>
/// <returns></returns>
public Bar this[int barnumber, BarInterval interval]
{
get { return _intdata[_intdataidx[(int)interval]].GetBar(barnumber,Symbol); }
}
/// <summary>
/// converts array of BarIntervals to integer intervals.
/// </summary>
/// <param name="ints"></param>
/// <returns></returns>
public static int[] BarInterval2Int(BarInterval[] ints)
{
List<int> o = new List<int>(); foreach (BarInterval bi in ints) o.Add((int)bi); return o.ToArray();
}
public Bollinger(decimal sds, BarInterval bi, int lookback)
{ this.sds = sds;
this.bi = bi;
this.lookback = lookback;
isbarcons = true;
}
/// <summary>
/// creates a barlist with requested interval and defined symbol
/// </summary>
/// <param name="interval"></param>
/// <param name="symbol"></param>
public BarListImpl(BarInterval interval, string symbol)
: this(symbol, new BarInterval[] { interval })
{
}
public static DateTime DateFromBarsBack(int barsback, BarInterval intv)
{
return(DateFromBarsBack(barsback, intv, DateTime.Now));
}
/// <summary>
/// create barlist from a tik file using given intervals/types
/// </summary>
/// <param name="filename"></param>
/// <param name="uselast"></param>
/// <param name="usebid"></param>
/// <param name="intervals"></param>
/// <param name="types"></param>
/// <returns></returns>
public static BarList FromTIK(string filename, bool uselast, bool usebid, int[] intervals, BarInterval[] types)
{
_uselast = uselast;
_usebid = usebid;
SecurityImpl s = SecurityImpl.FromTIK(filename);
s.HistSource.gotTick += new TickDelegate(HistSource_gotTick);
_fromepf = new BarListImpl(s.Symbol,intervals,types);
while (s.HistSource.NextTick()) ;
return _fromepf;
}
public static int BarsBackFromDate(BarInterval interval, int startdate)
{
return(BarsBackFromDate(interval, startdate, Util.ToTLDate()));
}
/// <summary>
/// find the bar # that matches a given time
/// </summary>
/// <param name="bl"></param>
/// <param name="time"></param>
/// <param name="bint"></param>
/// <returns></returns>
public static int GetNearestIntraBar(BarList bl, int time, BarInterval bint)
{
long barid = TimeIntervalData.getbarid(time, bl.RecentBar.Bardate, (int)bint);
BarListImpl bli = (BarListImpl)bl;
TimeIntervalData tid = (TimeIntervalData)bli._intdata[bli._intdataidx[(int)bint]];
for (int i = 0; i < tid.Count(); i++)
if (tid.ids[i] == barid)
return i;
return -1;
}
/// <summary>
/// creates barlist with specified symbol and requested intervals
/// </summary>
/// <param name="symbol"></param>
/// <param name="intervals"></param>
public BarListImpl(string symbol, BarInterval[] intervals)
: this(symbol,BarInterval2Int(intervals), intervals)
{
}
public static int BarsBackFromDate(BarInterval interval, int startdate) { return BarsBackFromDate(interval, startdate, Util.ToTLDate()); }
public Image DrawBarList(BarListImpl bl, BarInterval bi) { return DrawBarList(bl, bi, Color.Green, Color.Red); }
public decimal[] Low(BarInterval interval)
{
return _intdata[_intdataidx[(int)interval]].low().ToArray();
}
/// <summary>
/// gets the last bar in specified interval
/// </summary>
/// <param name="interval"></param>
/// <returns></returns>
public int LastInterval(BarInterval interval)
{
return _intdata[_intdataidx[(int)interval]].Last();
}
public decimal[] Open(BarInterval interval)
{
return _intdata[_intdataidx[(int)interval]].open().ToArray();
}
