/// <summary>
/// this must be called once per position tracker, for each position update.
/// if you are using your own position tracker with this trailing stop(eg from offset tracker, or somewhere else)
/// you MUST call TrailTrackers Adjust and NOT call your position tracker's adjust
/// </summary>
/// <param name="fill"></param>
public void Adjust(Trade fill)
{
// get index for symbol
int idx = symidx(fill.FullSymbol);
// only do following if we're tracking trail for this symbol
if (idx != NOSYM)
{
// get current position size
int psize = _pt[fill.FullSymbol].UnsignedSize;
// get trailing information
OffsetInfo trail = _trail[idx];
// get actual position size after change
int asize = psize - fill.UnsignedSize;
// if expected and actual match, mark pending as false
if (esize[fill.FullSymbol] == asize)
{
D(fill.FullSymbol + " trailing stop completely filled with: " + fill.ToString());
_pendingfill[idx] = false;
}
else
v(fill.FullSymbol + " trail partial fill: " + fill.ToString() + " e: " + esize[fill.FullSymbol] + " != a: " + asize);
}
else
v(fill.FullSymbol + " fill: " + fill.ToString() + " ignored while trail disabled.");
_pt.Adjust(fill);
// if we're flat now, make sure ref price is reset
if (_pt[fill.FullSymbol].isFlat)
{
_ref[idx] = 0;
v(fill.FullSymbol + " flat, reset trail reference price.");
}
}
public static string Serialize(OffsetInfo oi)
{
string m =
string.Format("{0},{1},{2},{3},{4},{5}", oi.ProfitDist, oi.StopDist, oi.ProfitPercent, oi.StopPercent, oi.NormalizeSize, oi.MinimumLotSize);
return m;
}
OffsetInfo GetOffset(string sym)
{
// see if we have a custom offset
int idx = getindex(sym);
OffsetInfo oi = null;
if (idx >= 0)
{
oi = base[idx];
// verify it's valid
if (oi == null)
{
idx = -1;
}
}
// if we don't have a custom but we're adding one, add from default
if (AddCustom && (idx < 0))
{
idx = addindex(sym, DefaultOffset);
}
else if (oi == null) // otherwise use default
{
return(DefaultOffset);
}
// return custom
return(oi);
}
public static string Serialize(OffsetInfo oi)
{
string m =
string.Format("{0},{1},{2},{3},{4},{5}", oi.ProfitDist, oi.StopDist, oi.ProfitPercent, oi.StopPercent, oi.NormalizeSize, oi.MinimumLotSize);
return(m);
}
void SetOffset(string sym, OffsetInfo off)
{
// check for index
int idx = addindex(sym, off);
if (_verbdebug)
{
debug(sym + " set offset: " + off.ToString(DebugDecimals));
}
}
void SetOffset(string sym, OffsetInfo off)
{
// check for index
if (_trackedOffsetInfos.ContainsKey(sym))
{
_trackedOffsetInfos[sym] = off;
}
else
{
_trackedOffsetInfos.Add(sym, off);
}
if (_verbdebug)
{
debug(sym + " set offset: " + off.ToString(DebugDecimals));
}
}
/// <summary>
/// must send new positions here (eg from GotPosition on Response)
/// </summary>
/// <param name="p"></param>
public void Adjust(Position p)
{
// did position exist?
bool exists = !_pt[p.FullSymbol].isFlat;
if (exists)
{
debug(p.FullSymbol + " re-initialization of existing position");
}
if (exists && ShutdownOnReinit)
{
// get offset
OffsetInfo oi = GetOffset(p.FullSymbol);
// disable it
oi.ProfitPercent = 0;
oi.StopPercent = 0;
// save it
SetOffset(p.FullSymbol, oi);
// cancel existing orders
CancelAll(p.FullSymbol);
// stop processing
return;
}
// update position
_pt.Adjust(p);
// if we're flat, nothing to do
if (_pt[p.FullSymbol].isFlat)
{
debug(p.FullSymbol + " initialized to flat.");
// cancel pending offsets
CancelAll(p.FullSymbol);
// reset offset state but not configuration
SetOffset(p.FullSymbol, new OffsetInfo(this[p.FullSymbol]));
return;
}
// do we have events?
if (!HasEvents())
{
return;
}
// do update
doupdate(p.FullSymbol);
}
OffsetInfo GetOffset(string sym)
{
// see if we have a custom offset
OffsetInfo oi = null;
if (_trackedOffsetInfos.ContainsKey(sym))
{
oi = _trackedOffsetInfos[sym];
if (oi == null)
{
_trackedOffsetInfos[sym] = DefaultOffset;
oi = DefaultOffset;
}
}
else
{
oi = DefaultOffset;
_trackedOffsetInfos.Add(sym, oi);
}
return(oi);
}
void cancel(OffsetInfo offset)
{
bool hit = false;
string ids = string.Empty;
if (offset.hasProfit)
{
hit |= true;
ids += offset.ProfitId + " ";
cancel(offset.ProfitId);
}
if (offset.hasStop)
{
hit |= true;
ids += offset.StopId + " ";
cancel(offset.StopId);
}
if (hit)
{
debug("canceling offsets: " + ids);
}
}
/// <summary>
/// clear single custom offset
/// </summary>
/// <param name="sym"></param>
public void ClearCustom(string sym)
{
this[sym] = IgnoreDefault ? OffsetInfo.DISABLEOFFSET() : DefaultOffset;
}
/// <summary>
/// copy an existing offset to this one
/// </summary>
/// <param name="copy"></param>
public OffsetInfo(OffsetInfo copy) : this(copy.ProfitDist, copy.StopDist, copy.ProfitPercent, copy.StopPercent, copy.NormalizeSize, copy.MinimumLotSize)
{
}
/// <summary>
/// get a stop order for a position given offset information
/// </summary>
/// <param name="p"></param>
/// <param name="offset"></param>
/// <returns></returns>
public static Order PositionStop(Position p, OffsetInfo offset)
{
return(PositionStop(p, offset.StopDist, offset.StopPercent, offset.NormalizeSize, offset.MinimumLotSize));
}
/// <summary>
/// get profit order for given position given offset information
/// </summary>
/// <param name="p"></param>
/// <param name="offset"></param>
/// <returns></returns>
public static Order PositionProfit(Position p, OffsetInfo offset)
{
return(PositionProfit(p, offset.ProfitDist, offset.ProfitPercent, offset.NormalizeSize, offset.MinimumLotSize));
}
void SetOffset(string sym, OffsetInfo off)
{
// check for index
if (_trackedOffsetInfos.ContainsKey(sym))
_trackedOffsetInfos[sym] = off;
else
_trackedOffsetInfos.Add(sym, off);
if (_verbdebug)
debug(sym + " set offset: " + off.ToString(DebugDecimals));
}
/// <summary>
/// get profit order for given position given offset information
/// </summary>
/// <param name="p"></param>
/// <param name="offset"></param>
/// <returns></returns>
public static Order PositionProfit(Position p, OffsetInfo offset) { return PositionProfit(p, offset.ProfitDist, offset.ProfitPercent, offset.NormalizeSize, offset.MinimumLotSize); }
/// <summary>
/// pass arbitrary price to use for trail reference price
/// </summary>
/// <param name="symbol"></param>
/// <param name="p"></param>
public void newPoint(string symbol, decimal p)
{
// get index for symbol
int idx = symidx(symbol);
// setup parameters
OffsetInfo trail = null;
decimal refp = 0;
// see if we trail this symbol
if ((idx == NOSYM) && _trailbydefault)
{
// get parameters
idx = _trail.Count;
refp = p;
trail = new OffsetInfo(_defaulttrail);
// save them
_symidx.Add(symbol, idx);
_ref.Add(refp);
_pendingfill.Add(false);
firecount.Add(symbol, 0);
esize.Add(symbol, pt[symbol].UnsignedSize);
// just in case user is modifying on seperate thread
lock (_trail)
{
_trail.Add(trail);
}
D(symbol + " trail tracking modified: " + trail.ToString());
}
else if ((idx == NOSYM) && !_trailbydefault)
{
return;
}
else
{
// get parameters
refp = _ref[idx];
// in case tracker started after trail stop should have been broken.
if (refp == 0 && _pt[symbol].isValid)
{
refp = _pt[symbol].AvgPrice;
}
// just in case user tries to modify on seperate thread
lock (_trail)
{
trail = _trail[idx];
}
}
// see if we need to update ref price
if ((refp == 0)
|| (_pt[symbol].isLong && (refp < p))
|| (_pt[symbol].isShort && (refp > p)))
{
// update
refp = p;
// save it
_ref[idx] = refp;
// notify
v(symbol + " new reference price: " + p);
}
// see if we broke our trail
var testdist = Math.Abs(refp - p);
var trailtest = testdist > trail.StopDist;
if (!_pendingfill[idx] && (trail.StopDist != 0) && trailtest && (MaxFireCount > firecount[symbol]))
{
// notify
D(symbol + " hit trailing stop at: " + p.ToString("F2"));
// mark pending order
_pendingfill[idx] = true;
// get order
Order flat = new MarketOrderFlat(_pt[symbol], trail.StopPercent, trail.NormalizeSize, trail.MinimumLotSize);
// get order id
flat.id = _id.AssignId;
// adjust expectation
esize[symbol] -= flat.UnsignedSize;
// count fire
firecount[symbol]++;
// send flat order
SendOrder(flat);
// notify
D(symbol + " enforcing trail with: " + flat.ToString() + " esize: " + esize[symbol] + " count: " + firecount[symbol]);
if (HitOffset != null)
HitOffset(symbol, flat.id, p);
}
else if (!_noverb)
{
if (_pendingfill[idx])
v(symbol + " waiting for trail fill.");
else if (trail.StopDist == 0)
v(symbol + " trail has been disabled.");
else if (!trailtest)
{
v(symbol + " trail not hit, current dist: " + testdist + " trailamt: " + trail.StopDist);
}
else if (MaxFireCount > firecount[symbol])
{
v(symbol + " trail max fire reached at: " + firecount[symbol] + " max: " + MaxFireCount);
}
}
}
void doupdate(string sym)
{
// is update ignored?
if (IgnoreUpdate(sym))
{
return;
}
// wait till next tick if we send cancels
bool sentcancel = false;
// get our offset values
OffsetInfo off = GetOffset(sym);
// get position
Position p = new Position(_pt[sym]);
// if we're flat, nothign to do
if (p.isFlat)
{
return;
}
// see whats current
bool cprofit = off.isProfitCurrent(p);
bool cstop = off.isStopCurrent(p);
// if not current, mark for update
bool updateprofit = !cprofit;
bool updatestop = !cstop;
// if we're up to date then quit
if (!updatestop && !updateprofit)
{
return;
}
// see if we have stop update
if ((updatestop && off.hasStop && !CancelOnce) ||
(updatestop && off.hasStop && CancelOnce && !off.StopcancelPending))
{
// notify
if (!off.StopcancelPending)
{
debug(string.Format("attempting stop cancel: {0} {1}", sym, off.StopId));
}
// cancel existing stops
cancel(off.StopId);
// mark cancel pending
off.StopcancelPending = true;
// mark as sent
sentcancel |= true;
}
// see if we have profit update
if ((updateprofit && off.hasProfit && AllowSimulatenousCancels) ||
(updateprofit && off.hasProfit && AllowSimulatenousCancels && !sentcancel))
{
if (!CancelOnce || (CancelOnce && !off.ProfitcancelPending))
{
// notify
if (!off.ProfitcancelPending)
{
debug(string.Format("attempting profit cancel: {0} {1}", sym, off.ProfitId));
}
// cancel existing profits
cancel(off.ProfitId);
// mark cancel pending
off.ProfitcancelPending = true;
// mark as sent
sentcancel |= true;
}
}
// wait till next tick if we sent cancel
if (sentcancel && WaitAfterCancel)
{
return;
}
bool sentorder = false;
// send stop first
if (!off.hasStop)
{
// since we have no stop, it's cancel can't be pending
off.StopcancelPending = false;
// get new stop
Order stop = Calc.PositionStop(p, off.StopDist, off.StopPercent, off.NormalizeSize, off.MinimumLotSize);
// mark size
off.SentStopSize = stop.OrderSize;
// if it's valid, send and track
if (stop.IsValid)
{
stop.Id = Ids.NextOrderId;
off.StopId = stop.Id;
SendOrderEvent(stop);
// notify
debug(string.Format("sent new stop: {0} {1}", stop.Id, stop.ToString(DebugDecimals)));
sentorder = true;
}
else if (_verbdebug)
{
debug(sym + " invalid stop: " + stop.ToString(DebugDecimals));
}
}
if ((!off.hasProfit && AllowSimulatenousOrders) || (!off.hasProfit && !AllowSimulatenousOrders && !sentorder))
{
// since we have no stop, it's cancel can't be pending
off.ProfitcancelPending = false;
// get new profit
Order profit = Calc.PositionProfit(p, off.ProfitDist, off.ProfitPercent, off.NormalizeSize, off.MinimumLotSize);
// mark size
off.SentProfitSize = profit.OrderSize;
// if it's valid, send and track it
if (profit.IsValid)
{
profit.Id = Ids.NextOrderId;
off.ProfitId = profit.Id;
SendOrderEvent(profit);
// notify
debug(string.Format("sent new profit: {0} {1}", profit.Id, profit.ToString(DebugDecimals)));
sentorder = true;
}
else if (_verbdebug)
{
debug(sym + " invalid profit: " + profit.ToString(DebugDecimals));
}
}
// make sure new offset info is reflected
SetOffset(sym, off);
}
/// <summary>
/// get a stop order for a position given offset information
/// </summary>
/// <param name="p"></param>
/// <param name="offset"></param>
/// <returns></returns>
public static Order PositionStop(Position p, OffsetInfo offset) { return PositionStop(p, offset.StopDist, offset.StopPercent, offset.NormalizeSize, offset.MinimumLotSize); }
void cancel(OffsetInfo offset)
{
bool hit = false;
string ids = string.Empty;
if (offset.hasProfit)
{
hit |= true;
ids += offset.ProfitId + " ";
cancel(offset.ProfitId);
}
if (offset.hasStop)
{
hit |= true;
ids += offset.StopId + " ";
cancel(offset.StopId);
}
if (hit)
debug("canceling offsets: " + ids);
}
/// <summary>
/// must send new fills here (eg call from Response.GotFill)
/// </summary>
/// <param name="t"></param>
public void Adjust(Trade t)
{
// get original size
int osize = _pt[t.FullSymbol].Size;
// update position
_pt.Adjust(t);
// see if it's our order
OffsetInfo oi = GetOffset(t.FullSymbol);
// see what was hit
bool hp = (t.Id != 0) && (oi.ProfitId == t.Id);
bool hs = (t.Id != 0) && (oi.StopId == t.Id);
// if we hit something
if (hp || hs)
{
// notify
debug(t.FullSymbol + " hit " + (hp ? "profit" : "stop") + ": " + t.Id);
// see if we should clear offset
if (hp && (oi.SentProfitSize == t.TradeSize))
{
debug(t.FullSymbol + " profit closed: " + t.Id);
oi.ProfitId = 0;
}
else if (hp)
{
oi.SentProfitSize -= t.TradeSize;
}
if (hs && (oi.SentStopSize == t.TradeSize))
{
debug(t.FullSymbol + " stop closed: " + t.Id);
oi.StopId = 0;
}
else if (hs)
{
oi.SentStopSize -= t.TradeSize;
}
if (HitOffset != null)
{
HitOffset(t.FullSymbol, t.Id, t.TradePrice);
}
}
// if we're flat, nothing to do (or if we switched sides)
Position p = _pt[t.FullSymbol];
if (p.isFlat || (osize * p.Size < -1))
{
if (p.isFlat)
{
debug(t.FullSymbol + " now flat.");
}
else
{
debug(t.FullSymbol + " reversed: " + osize + " -> " + p.Size);
}
CancelAll(t.FullSymbol);
// reset offset state but not configuration
SetOffset(t.FullSymbol, new OffsetInfo(this[t.FullSymbol]));
}
else // save offset
{
SetOffset(t.FullSymbol, oi);
}
// do we have events?
if (!HasEvents())
{
return;
}
// do update
doupdate(t.FullSymbol);
}
void SetOffset(string sym, OffsetInfo off)
{
// check for index
int idx = addindex(sym, off);
if (_verbdebug)
debug(sym + " set offset: " + off.ToString(DebugDecimals));
}
/// <summary>
/// copy an existing offset to this one
/// </summary>
/// <param name="copy"></param>
public OffsetInfo(OffsetInfo copy) : this(copy.ProfitDist, copy.StopDist, copy.ProfitPercent, copy.StopPercent, copy.NormalizeSize, copy.MinimumLotSize) { }
