void GotNewBar(string symbol, int interval) { // get index for symbol int idx = indicatorcross2.addindex(symbol); // get current barlist for this symbol+interval BarList bl = blt[symbol, interval]; // check for first cross on first interval if (interval == (int)BarInterval.Minute) { // update the cross state indicatorcross1[symbol] = bl.RecentBar.Close > Calc.Avg(bl.Close()); } // check second cross if (interval == (int)BarInterval.FiveMin) { // update the cross state indicatorcross2[symbol] = bl.RecentBar.Close > Calc.Avg(bl.Close()); } // update first1then2 if (first1then2ok[symbol] && indicatorcross2[symbol] && !indicatorcross1[symbol]) { first1then2ok[symbol] = false; } // send order if everything looks good (also showed failed rules) if (gt.rulepasses(idx, "sequential buy entry", senddebug, true, first1then2ok, indicatorcross2, indicatorcross1)) { sendorder(new BuyMarket(symbol, 100)); } }
void track_symbols_NewTxt(string txt, int idx) { // index all the trackers we're using track_positions.addindex(txt); track_sma_slow.addindex(txt, new List <decimal>()); track_sma_fast.addindex(txt, new List <decimal>()); }
public static GenericTracker <Screener> fetchscreen(string url, DebugDelegate deb) { // get raw list string[][] raw = fetchrawlist(url, deb); debug("beginning screen indexing of " + raw.GetLength(0) + " screens."); GenericTracker <Screener> ss = new GenericTracker <Screener>(raw.GetLength(0), "SCREENS", new Screener()); int l = 0; foreach (string[] r in raw) { l++; Screener s = getscreen_qdl(r); if (s.isValid) { ss.addindex(s.symbol, s); } else { /* * if (r!=null) * debug("ignoring invalid screen line#"+l.ToString("N0")+" with data: " + Util.join(r)); * else * debug("ignoring invalid screen line#" + l.ToString("N0") + " with no data."); */ } } debug("completed index of " + ss.Count + " screens."); return(ss); }
public override void GotTick(Tick tick) //数据进来,先进gottick,如果需要对成交价等进行更改,在gottick里进行 { // keep track of time from tick _time = tick.time; if (_date > tick.date) { // this is important for consistency between runs for ATSTestBench and ATSTestBenchBatch Reset(); } _date = tick.date; // ensure response is active if (!isValid) { return; } // ensure we are tracking active status for this symbol int idx = _active.addindex(tick.symbol, true); // if we're not active, quit if (!_active[idx]) { return; } // check for shutdown time // apply bar tracking to all ticks that enter _kt.newTick(tick); _blt.newTick(tick); // ignore anything that is not a trade if (!tick.isTrade) { return; //如果没有trade,这个数据是用不到的 } }
public void Basics() { // reset count newtxt = 0; // track something GenericTracker <object> gt = new GenericTracker <object>(); // count new items gt.NewTxt += new TextIdxDelegate(gt_NewTxt); // get some symbols string[] syms = new string[] { "IBM", "LVS", "IBM", "WAG", "GOOG" }; // add them foreach (string sym in syms) { gt.addindex(sym, sym == "IBM" ? null : new object()); } // ensure we have them Assert.AreEqual(4, newtxt); Assert.AreNotEqual(gt.Count, syms.Length); // test fetching by label Assert.IsNull(gt["IBM"]); Assert.IsNotNull(gt["GOOG"]); Assert.AreEqual(0, gt.getindex("IBM")); // get label from index Assert.AreEqual("GOOG", gt.getlabel(3)); }
/// <summary> /// This function will be delegated in "Reset" method /// and will be called whenever the system got a new bar /// The stratege should be contained in this method /// </summary> /// <param name="symbol"></param> /// <param name="interval"></param> void blt_GotNewBar(string symbol, int interval) { BarList myBars = _blt[symbol, interval]; // If we only get one bar, exit if (myBars.Count <= 1) { return; } // make sure the lastBar is full _lastBar = myBars[myBars.Count - 2]; // Update lastBars if (_lastBars.getindex(symbol) < 0) { _lastBars.addindex(symbol); } _lastBars[symbol] = _lastBar; // Update indicators ComputeSignal(); string[] indicators = GetDisplayIndicators(); sendindicators(indicators); // Buy or sell // Strategy based on computed ATR indicator //DoStrategy(symbol, signal); DoStrategy(); }
protected override List <ResponseModel> getmodels() { List <ResponseModel> mods = new List <ResponseModel>(); if (!isValid) { debug("Can't add models when response is not loaded."); symbols2add = new string[0]; return(mods); } var indcount = mygvi.Count; foreach (var sym in symbols2add) { // get index var idx = sym2modidx.getindex(sym); // skip if already have it if (idx >= 0) { continue; } dynamic mod = new ResponseModel(indcount); mod.symbol = sym; mod.responseowner = ResponseName; mods.Add(mod); idx = sym2modidx.addindex(sym, models.Count); sym2lastupdatetime.addindex(sym, -1); } return(mods); }
public override void GotTick(Tick tick) { // track order ids _orderid.addindex(tick.symbol, 0); // track ticks _kt.newTick(tick); // see if we need to send an order if (_orderid[tick.symbol] == 0) { // get complete last tick for this symbol Tick k = _kt[tick.symbol]; // see if we have proper info to place order if ((Side && k.hasBid) || (!Side && k.hasAsk)) { _orderid[tick.symbol] = _idt.NextId; D(tick.symbol + " sending limit order: " + _orderid[tick.symbol]); sendorder(new LimitOrder(tick.symbol, Side, Ordersize, Side ? k.bid - Distance : k.ask + Distance, _idt.AssignId)); } } else // otherwise increment counter { _tickcounter[tick.symbol]++; } // see if we need to cancel if (_tickcounter[tick.symbol] > Frequency) { D(tick.symbol + " hit frequency, canceling: " + _orderid[tick.symbol]); sendcancel(_orderid[tick.symbol]); } }
/// <summary> /// takes all or part of quandl object and converts it into GT /// </summary> /// <param name="ro"></param> /// <param name="datecol"></param> /// <param name="valcol"></param> /// <param name="startrow"></param> /// <param name="endrow"></param> /// <returns></returns> public static GenericTracker<decimal> Qdl2GT(RootObject ro, string datecol, string valcol, int startrow, int endrow, DebugDelegate d) { // get columns var datecolidx = GetQdlColidx(ro,datecol); var valcolidx = GetQdlColidx(ro,valcol); // slice out the data var subset = GetAllRows(ro, startrow, endrow, d); // get date column var dates = QdlCol2Dates( GetColumn(subset, datecolidx)); var vals =QdlCol2Vals( GetColumn(subset, valcolidx)); // populate GT GenericTracker<decimal> gt = new GenericTracker<decimal>(dates.Count); for (int i = 0; i < dates.Count; i++) { var val = vals[i]; var dt = dates[i]; if (val == qh.ERROR_VALUE) continue; if (dt == qh.ERROR_DATE) continue; var tldate = Util.ToTLDate(dt); gt.addindex(tldate.ToString("F0"), val); } return gt; }
void PRIMARY_NewTxt(string txt, int idx) { // index all the trackers we're using pt.addindex(txt); expectedsize.addindex(txt); entryok.addindex(txt); pt.addindex(txt); indicatorcross1.addindex(txt); indicatorcross2.addindex(txt); }
public override void GotTick(Tick k) { // get index from symbol, add if it doesn't exist int idx = PRIMARY.addindex(k.symbol, k.symbol); // build bars blt.newTick(k); // update whether entries are allowed entryok[idx] = expectedsize[idx] == pt[idx].Size; }
/// <summary> /// Called whenever we got a tick signal /// </summary> /// <param name="k"></param> public override void GotTick(Tick k) { // Sync symbols if (_symbols.getindex(k.symbol) < 0) { _symbols.addindex(k.symbol, k.symbol); } SyncDateTime(k); // ensure response is active if (!isValid) { return; } // ensure we are tracking active status for this symbol int idx = _active.addindex(k.symbol, true); // if we're not active, quit if (!_active[idx]) { return; } //// check for shutdown time //if (k.time > Shutdown) //{ // // if so, shutdown the system // if (!_isShutDown) // { // shutdown(); // } // // and quit // return; //} //else //{ // // make sure the flag is on // _isShutDown = false; //} // apply bar tracking to all ticks that enter _kt.newTick(k); _blt.newTick(k); // ignore anything that is not a trade if (!k.isTrade) { return; } }
// Don't forget to add trackers to index automatically into following f-n. // Note: some trackers, like 'tick' and 'position' don't need to be here) // // link all the generic trackers together so we create // proper default values for each whenever we add symbol to one void track_symbols_NewTxt(string txt, int idx) { track_exitsignals.addindex(txt, false); // add other trackers here... // in LessonGenericTrackers.cs //we index this: // PositionTracker pt = new PositionTracker(); //, but we don't index this: // BarListTracker blt = new BarListTracker(new BarInterval[] { BarInterval.FiveMin, BarInterval.Minute }); //how do I know which trackers should/must be indexed and which are not? }
public static GenericTracker <Screener> fetchscreen(string url, DebugDelegate deb) { // get raw list string[][] raw = fetchrawlist(url, deb); debug("beginning screen indexing of " + raw.GetLength(0) + " screens."); GenericTracker <Screener> ss = new GenericTracker <Screener>(raw.GetLength(0), "SCREENS"); foreach (string[] r in raw) { Screener s = getscreen(r); ss.addindex(s.symbol, s); } debug("completed index of " + ss.Count + " screens."); return(ss); }
/* * // turn on bar tracking * BarListTracker blt = new BarListTracker(); * // turn on position tracking * PositionTracker pt = new PositionTracker(); * // keep track of time for use in other functions * int time = 0; */ // got tick is called whenever this strategy receives a tick public override void GotTick(Tick tick) { _iTick++; // keep track of time from tick time = tick.time; // ensure response is active if (!isValid) { return; } // ensure we are tracking active status for this symbol int idx = _active.addindex(tick.symbol, true); // if we're not active, quit if (!_active[idx]) { return; } // check for shutdown time if (tick.time > Shutdown) { // if so shutdown shutdown(); // and quit return; } // apply bar tracking to all ticks that enter blt.newTick(tick); // ignore anything that is not a trade if (!tick.isTrade) { return; } // if we made it here, we have enough bars and we have a trade. // exits are processed first, lets see if we have our total profit if (Calc.OpenPL(tick.trade, pt[tick.symbol]) + pt[tick.symbol].ClosedPL > TotalProfitTarget) { // if we hit our target, shutdown trading on this symbol shutdown(tick.symbol); // don't process anything else after this (entries, etc) return; } }
static GenericTracker <List <Token> > getstublessftable(GenericTracker <List <Token> > function2functoks) { var tmp = function2functoks.ToArray(); var stubtokens = new GenericTracker <List <Token> >(tmp.Length); for (int i = 0; i < tmp.Length; i++) { stubtokens.addindex(function2functoks.getlabel(i), function2functoks[i]); } // now process every function stub for (int i = 0; i < function2functoks.Count; i++) { // always pass in the stubs var stubless = getstublessfunction(i, stubtokens); // update the primary list with the stubless result function2functoks[i] = stubless; } return(function2functoks); }
int getindex(string iname) { var idx = iname2validx.getindex(iname); // build index first time if (idx < 0) { var inds = getgvi().itemnames; for (int i = 0; i < inds.Count; i++) { var tmpiname = inds[i]; if (tmpiname == iname) { idx = i; } iname2validx.addindex(tmpiname, i); } } return(idx); }
// GotTick is called everytime a new quote or trade occurs public override void GotTick(TradeLink.API.Tick tick) { // tmp workaround for "how to show debug messages from response constructor" if (debug_message_from_constructor.Length > 0) { D(debug_message_from_constructor); debug_message_from_constructor = ""; } // keep track of time from tick time = tick.time; // safe tick to files //_ta.newTick(tick); // ignore quotes if (!tick.isTrade) { return; } // ignore ticks with timestamp prior to 9:30:00am if (tick.time < 93000) { return; } // ensure we track this symbol, all the other trackers will be indexed inside track_symbols_NewTxt() track_symbols.addindex(tick.symbol, false); // track tick track_ticks.newTick(tick); track_barlists.newTick(tick); // dimon: give any ticks (trades) to this symbol and tracker will create barlists automatically // if we don't have enough bars, wait for more ticks if (!track_barlists[tick.symbol].Has(_slow_ma_bar)) { return; } }
void client_gotUnknownMessage(MessageTypes type, long source, long dest, long msgid, string request, ref string response) { if (type == MessageTypes.BARRESPONSE) { lastbarraw = response; var b = BarImpl.Deserialize(response); var label = b.Symbol + b.Interval.ToString() + b.CustomInterval.ToString(); var symintidx = symintcount.getindex(label); if (symintidx < 0) { symintidx = symintcount.addindex(label, new List <Bar>()); g.d("got new symbol/interval: " + b.Symbol + " " + b.Interval + b.CustomInterval + " bar:" + b.ToString()); } symintcount[symintidx].Add(b); if (!recvsyms.Contains(b.Symbol)) { recvsyms.Add(b.Symbol); } recvbarcount++; } else if (type == MessageTypes.BARRESPONSE_FINAL) { var br = BarRequest.Deserialize(response); reccomplete++; g.d("completed: " + br.symbol + " " + br.Interval + " " + br.ID); } else { g.d("got unknown message: " + type + request + response); } var ok = mt.GotMessage(type, source, dest, msgid, request, ref response); if (!ok) { g.d("error processing: " + type + " request: " + request + " response: " + response); } msgok &= ok; }
public void Basics() { // reset count newtxt = 0; // track something GenericTracker<object> gt = new GenericTracker<object>(); // count new items gt.NewTxt += new TextIdxDelegate(gt_NewTxt); // get some symbols string[] syms = new string[] { "IBM", "LVS", "IBM", "WAG", "GOOG" }; // add them foreach (string sym in syms) gt.addindex(sym, sym == "IBM" ? null : new object()); // ensure we have them Assert.AreEqual(4, newtxt); Assert.AreNotEqual(gt.Count, syms.Length); // test fetching by label Assert.IsNull(gt["IBM"]); Assert.IsNotNull(gt["GOOG"]); Assert.AreEqual(0, gt.getindex("IBM")); // get label from index Assert.AreEqual("GOOG", gt.getlabel(3)); }
protected override List <Quote> getmodels() { // add them var mods = new List <Quote>(); foreach (var sym in symbols2add) { // skip if we already have the symbol var idx = symidx.getindex(sym); if (idx < 0) { Quote q = new Quote(); q.symbol = sym; mods.Add(q); idx = symidx.addindex(sym, mods.Count - 1); sym2lasttime.addindex(sym, -1); debug(sym + " added quote."); } } return(mods); }
// GotTick is called everytime a new quote or trade occurs public override void GotTick(TradeLink.API.Tick tick) { // store tick tick_archiver.newTick(tick); return; // for now only track/store ticks here... // ignore quotes if (!tick.isTrade) { return; } // ensure we track this symbol, all the other trackers will be indexed inside track_symbols_NewTxt() track_symbols.addindex(tick.symbol, false); // track tick track_ticks.newTick(tick); // another "track tick" :) // // For now we track tick in 2 different trackers: // TickTracker // and // BarListTracker (connected with MessageTracker) // // todo: Read more on topic of TickTracker vs BarListTracker. And eventually get rid of one of them. // TickTracker - seems have more functionality, but // BarListTracker - can build bars with any interval (we can mix diff. bar size in one strategy easily using this!) // track_barlists.newTick(tick); // dimon: give any ticks (trades) to this symbol and tracker will create barlists automatically // if we don't have enough bars, wait for more ticks //if (!track_barlists[tick.symbol].Has(BarsBack)) return; // get current position Position pos = track_positions[tick.symbol]; // if we're flat and haven't seen this symbol yet, then... if (pos.isFlat && !track_symbols[tick.symbol]) { // strart tracking it (other trackers will be updated accordingly, see track_symbols_NewTxt() track_symbols[tick.symbol] = true; D(tick.symbol + ": entering long"); O(new MarketOrder(tick.symbol, EntrySize)); } else if (!pos.isFlat && !track_exitsignals[tick.symbol]) { // get most recent tick data Tick k = track_ticks[tick.symbol]; // estimate our exit price decimal exitprice = UseQuotes ? (k.hasAsk && pos.isLong ? k.ask : (k.hasBid && pos.isShort ? k.bid : 0)) : (k.isTrade ? k.trade : 0); // assuming we could estimate an exit, see if our exit would hit our target if ((exitprice != 0) && (Calc.OpenPT(exitprice, pos) > ProfitTarget)) { track_exitsignals[tick.symbol] = true; D("hit profit target"); O(new MarketOrderFlat(pos)); } } // -------------------------------------------- // // this is a grey box that manages exits, so wait until we have a position //if (!pt[tick.symbol].isFlat) return; // //// calculate the MA from closing bars //decimal MA = Calc.Avg(Calc.Closes(track_barlists[tick.symbol], BarsBack)); //// if we're short, a cross is when market moves above MA //// if we're long, cross is when market goes below MA //bool cross = pt[tick.symbol].isShort ? (tick.trade > MA) : (tick.trade < MA); //// if we have a cross, then flat us for the requested size //if (cross) // sendorder(new MarketOrderFlat(pt[tick.symbol], exitpercent)); //// notify gauntlet and kadina about our moving average and cross //sendindicators(new string[] { MA.ToString(), cross.ToString() }); // -------------------------------------------- }
void gt_NewTxt2(string txt, int idx) { price1.addindex(txt, 0); price2.addindex(txt, 0); special.addindex(txt, true); }
public static bool PlayHistoricalTicks(Response r, GenericTracker<string> symbols, DateTime start, DateTime endexclusive, int expecteddays, DebugDelegate deb) { bool skipexpected = expecteddays == 0; // prepare to track actual days for each symbol GenericTracker<int> actualdays = new GenericTracker<int>(); foreach (string sym in symbols) actualdays.addindex(sym, 0); // prepare to track all tickfiles Dictionary<string, List<string>> files = new Dictionary<string, List<string>>(); // get all required tickfiles for each symbol on each date DateTime now = new DateTime(start.Ticks); int tfc = 0; while (now < endexclusive) { // get the tick files List<string> allfiles = TikUtil.GetFilesFromDate(Util.TLTickDir, Util.ToTLDate(now)); // go through them all and see if we find expected number foreach (string fn in allfiles) { // get security SecurityImpl sec = SecurityImpl.FromTIK(fn); // see if we want this symbol int idx = symbols.getindex(sec.HistSource.RealSymbol); if (idx < 0) idx = symbols.getindex(sec.Symbol); sec.HistSource.Close(); // skip if we don't if (idx < 0) continue; string sym = symbols.getlabel(idx); // if we have it, count actual day actualdays[idx]++; // save file and symbol if (!files.ContainsKey(sym)) files.Add(sym, new List<string>()); files[sym].Add(fn); // count files tfc++; } // add one day now = now.AddDays(1); } // notify if (deb != null) { deb("found " + tfc + " tick files matching dates: " + Util.ToTLDate(start) + "->" + Util.ToTLDate(endexclusive) + " for: " + string.Join(",", symbols.ToArray())); } // playback when actual meets expected bool allok = true; foreach (string sym in symbols) { if (skipexpected || (actualdays[sym] >= expecteddays)) { // get tick files string[] tf = files[sym].ToArray(); // notify if (deb != null) { deb(sym + " playing back " + tf.Length + " tick files."); } // playback HistSim h = new SingleSimImpl(tf); h.GotTick += new TickDelegate(r.GotTick); h.PlayTo(MultiSimImpl.ENDSIM); h.Stop(); // notify if (deb != null) { deb(sym + " completed playback. "); } } else allok = false; } return allok; }
void tl_newRegisterSymbols(string client, string symbols) { D("got subscribe request: " + client + ": " + symbols); // ensure new symbols are added Basket newb = tl.AllClientBasket; // ensure we have an id foreach (string sym in newb.ToSymArray()) { Security sec = SecurityImpl.Parse(sym); char p; if (sec.Type == SecurityType.STK) { p = 'e'; } else if (sec.Type == SecurityType.BND) { p = 'b'; } else if (sec.Type == SecurityType.FUT) { p = 'f'; } else if (sec.Type == SecurityType.IDX) { p = 'i'; } else if (sec.Type == SecurityType.OPT) { p = 'o'; } else if (sec.Type == SecurityType.CASH) { p = 'c'; } else if (sec.Type == SecurityType.FOP) { p = 'p'; } else { p = 'e'; } string nxsym = p + sec.symbol; int idx = _nxsyms.addindex(nxsym, true); _realsym2nxidx.addindex(sec.symbol, idx); } // ensure old symbols are removed if (old.Count > 0) { Basket rem = BasketImpl.Subtract(old, newb); foreach (Security s in rem) { int idx = _realsym2nxidx.getindex(s.symbol); if (idx < 0) { debug("Unable to locate subscription for: " + s.symbol); continue; } _nxsyms[idx] = false; } } // save new as old old = newb; }
// GotTick is called everytime a new quote or trade occurs public override void GotTick(TradeLink.API.Tick tick) { base.GotTick(tick); // keep track of time from tick time = tick.time; // ignore quotes if (!tick.isTrade) { return; } // ignore ticks with timestamp prior to 9:30:00am if (tick.time < 93000) { return; } // --------------------------------------------------- rabbitmq begin ----------- log_file.WriteLine(JsonConvert.SerializeObject(tick, Formatting.Indented)); // write all ticks into external file (to get a feeling on size) if (tick.time == 93205) { ; } if (false) { if (tick.time > 93000 && tick.time < 93500) { string rabbit_serverAddress = "amqp://localhost/"; string rabbit_exchange = "exch"; string rabbit_exchangeType = "fanout"; string rabbit_routingKey = "rout"; string rabbit_message = JsonConvert.SerializeObject(tick, Formatting.Indented); ConnectionFactory rabbit_cf = new ConnectionFactory(); rabbit_cf.Uri = rabbit_serverAddress; IConnection rabbit_conn = rabbit_cf.CreateConnection(); IModel rabbit_ch = rabbit_conn.CreateModel(); rabbit_ch.ExchangeDeclare(rabbit_exchange, rabbit_exchangeType); IBasicProperties msg_props = rabbit_ch.CreateBasicProperties(); msg_props.ContentType = "text/plain"; rabbit_ch.BasicPublish(rabbit_exchange, rabbit_routingKey, msg_props, Encoding.UTF8.GetBytes(rabbit_message)); // or Encoding.UTF8.GetBytes(); - we convert message into a byte array } } // --------------------------------------------------- rabbitmq end ----------- // ensure we track this symbol, all the other trackers will be indexed inside track_symbols_NewTxt() track_symbols.addindex(tick.symbol, false); // track tick track_ticks.newTick(tick); // track (custom) bars track_barlists.newTick(tick); // dimon: give any ticks (trades) to this symbol and tracker will create barlists automatically // check if need to exit position: log_file.WriteLine("check if need to exit position: track_positions[tick.symbol].isLong=" + track_positions[tick.symbol].isLong.ToString()); if (!track_positions[tick.symbol].isLong) // isFlat) - we sell only if we have long positions { // should exit long position due to hit target? if (track_positions[tick.symbol].isLong) { // time to exit long position? bool should_exit = track_positions[tick.symbol].AvgPrice * (decimal)_target_price_k <= tick.trade; if (should_exit) { string comment = "exit long position due to hit target"; sendorder(new SellMarket(tick.symbol, EntrySize, comment)); log_file.WriteLine("close position: " + comment); return; } } // should exit short position due to hit target? if (track_positions[tick.symbol].isShort) { bool should_exit = track_positions[tick.symbol].AvgPrice * (decimal)_target_price_k >= tick.trade; if (should_exit) { string comment = "exit short position due to hit target"; sendorder(new BuyMarket(tick.symbol, EntrySize, comment)); log_file.WriteLine("close position: " + comment); return; } } // should exit long position due to hit stop? if (track_positions[tick.symbol].isLong) { bool should_exit = track_positions[tick.symbol].AvgPrice * (decimal)_stop_k >= tick.trade; if (should_exit) { string comment = "exit long position due to hit stop"; sendorder(new SellMarket(tick.symbol, EntrySize, comment)); log_file.WriteLine("close position: " + comment); return; } } // should exit short position due to hit stop? if (track_positions[tick.symbol].isShort) { bool should_exit = track_positions[tick.symbol].AvgPrice * (decimal)_target_price_k >= tick.trade; if (should_exit) { string comment = "exit short position due to hit stop"; sendorder(new BuyMarket(tick.symbol, EntrySize, comment)); log_file.WriteLine("close position: " + comment); return; } } } }
// link all the generic trackers together so we create // proper default values for each whenever we add symbol to one void _entrysignal_NewTxt(string txt, int idx) { _exitsignal.addindex(txt, false); }
void MA_NewTxt(string txt, int idx) { // use a default lookback of 3 LOOKBACK.addindex(txt, 3); }
public static GenericTracker<Screener> fetchscreen(string url, DebugDelegate deb) { // get raw list string[][] raw = fetchrawlist(url,deb); debug("beginning screen indexing of "+raw.GetLength(0)+" screens."); GenericTracker<Screener> ss = new GenericTracker<Screener>(raw.GetLength(0), "SCREENS", new Screener()); int l = 0; foreach (string[] r in raw) { l++; Screener s = getscreen_qdl(r); if (s.isValid) ss.addindex(s.symbol, s); else { /* if (r!=null) debug("ignoring invalid screen line#"+l.ToString("N0")+" with data: " + Util.join(r)); else debug("ignoring invalid screen line#" + l.ToString("N0") + " with no data."); */ } } debug("completed index of "+ss.Count+" screens."); return ss; }
void indicatorcross1_NewTxt(string txt, int idx) { indicatorcross1.addindex(txt); indicatorcross2.addindex(txt); first1then2ok.addindex(txt); }
void _active_NewTxt(string txt, int idx) { // go ahead and notify any other trackers about this symbol _wait.addindex(txt, false); }
internal static bool transform_assist_helpers(List <string> sourcetypes, GenericTracker <Token[]> const2tokens, ref GenericTracker <List <Token> > function2functoks) { // get destination class symbols var templateclasssym = RD_AssistTemplate.GetClassSymbols(); // process every token for (int i = 0; i < tokstream.Count; i++) { // get our building blocks var tok = tokstream[i]; // look for symbols if (!tok.isSymbol) { continue; } // ignore constructors if (sourcetypes.Contains(tok.data)) { continue; } // skip methods we have overridden in destination class (eg GetSymbolDecimal) if (templateclasssym.Contains(tok.data)) { continue; } // get previous token symbol var ptok = getprevioussymbol(tok); // verify we return an assist if (ptok.data != "AssistI") { continue; } // update other states //bool isvoidmethod = issymbolvoidargumentmethod(tok); //if (isvoidmethod) // continue; bool ismethod = issymbolmethod(tok); // take the non-void static methods which return assists and place them as helpers if (ismethod) { // get name of function var fname = tok.data; // get function tokens including the argument list (but not the static token) var allfunction = new List <Token>(); // save this name var ftokens = getfunctiontokens(i); // get the constants used by this helper var consttoks = gethelperconstants(ftokens, const2tokens); // build entire function starting with return arguments allfunction.Add(new Token(tokentype.symbol, "AssistI")); allfunction.Add(new Token(tokentype.space, " ")); // name allfunction.Add(tok); // arguments allfunction.AddRange(getfunctionarguments(i)); // re-write any functions not present in destination //var rewrittenbody = rewrite_nonlocalsymbols(ftokens, sourcetype); // body allfunction.Add(new Token(tokentype.line, h.line())); allfunction.Add(new Token(tokentype.block_start, "{")); allfunction.Add(new Token(tokentype.line, h.line())); // constants allfunction.AddRange(consttoks); // code allfunction.AddRange(ftokens); // end body allfunction.Add(new Token(tokentype.line, h.line())); allfunction.Add(new Token(tokentype.block_end, "}")); allfunction.Add(new Token(tokentype.line, h.line())); // get code from these modified tokens //var bodycode = gettokencode(allfunction.ToArray()); // see if we have some code already int tokencodeidx = function2functoks.getindex(tok.data); // if not, save it if (tokencodeidx < 0) { tokencodeidx = function2functoks.addindex(tok.data, allfunction); } else // otherwise it's an overload, append it { function2functoks[tokencodeidx].AddRange(allfunction); } } } return(true); }
public static bool PlayHistoricalTicks(Response r, string symbol, int currentdate, int daysback, int expecteddays, DebugDelegate deb) { GenericTracker<string> symbols = new GenericTracker<string>(); symbols.addindex(symbol, symbol); // calculate stop date DateTime stop = Util.ToDateTime(currentdate, 0); // calculate start date DateTime start = stop.Subtract(new TimeSpan(daysback, 0, 0, 0)); // return results return PlayHistoricalTicks(r, symbols, start, stop, expecteddays, deb); }
internal static GenericTracker <Token[]> getcodeconstants() { GenericTracker <Token[]> constname2consttoks = new GenericTracker <Token[]>(); // keep track of block level int blocklevel = 0; const int classglobal = 2; // go through every token for (int i = 0; i < tokstream.Count; i++) { // get token var t = tokstream[i]; // ignore quoted strings if (t.type == tokentype.quotedstring) { continue; } // ignore new lines if (t.isLine) { continue; } // count blocks if (t.type == tokentype.block_end) { blocklevel--; } else if (t.type == tokentype.block_start) { blocklevel++; } // only look for constants at class level if (blocklevel == classglobal) { // ignore non symbols if (!t.isSymbol) { continue; } // look for any constant if (t.data != "const") { continue; } // ensure it's an access modifier //if (ptok.data != "public") // continue; // get next token for the name var n = getnextsymbol(t, 2); // ensure it's an assignment if (!issymbolassignment(n)) { continue; } // save tokens until the end of the constant var ctoks = readtofirstof(t.id, tokentype.statement); // save it constname2consttoks.addindex(n.data, ctoks.ToArray()); // advance the pointer i += (ctoks.Count - (i - t.id)); //var lasttoks = getlasttokens(i, 70); //Console.WriteLine(n.ToString() + "\t" + lasttoks.Length); } } return(constname2consttoks); }
public static GenericTracker<Screener> fetchscreen(string url, DebugDelegate deb) { // get raw list string[][] raw = fetchrawlist(url,deb); debug("beginning screen indexing of "+raw.GetLength(0)+" screens."); GenericTracker<Screener> ss = new GenericTracker<Screener>(raw.GetLength(0), "SCREENS", new Screener()); foreach (string[] r in raw) { Screener s = getscreen(r); ss.addindex(s.symbol, s); } debug("completed index of "+ss.Count+" screens."); return ss; }
void _orderid_NewTxt(string txt, int idx) { _kt.addindex(txt); _tickcounter.addindex(txt, 0); }