// constructor used to create a duplicate a state using a new timestamp
public MarketState(Security security, MarketState previousMktState, DateTime timeStamp)
{
TimeStamp = DateTime.MinValue;
VolumeTdy = 0;
OrderFlowTdy = 0;
VolAtBidTdy = 0;
VolAtAskTdy = 0;
_securityObj = security;
if (security == null)
{
throw new ArgumentException("security object must not be null", "security");
}
if (previousMktState == null)
{
throw new ArgumentException("Previous MarketState object must not be null", "previousMktState");
}
if (timeStamp == null)
{
throw new ArgumentException("timeStamp must not be null", "timeStamp");
}
TimeStamp = timeStamp;
FirstOfInterval = true;
StateType = MktStateType.Duplicate;
CopyPrevState(previousMktState, FirstOfInterval);
}
private void CopyPrevState(MarketState previous, bool isFirstOfInterval)
{
Bid = previous.Bid;
BidVol = previous.BidVol;
Ask = previous.Ask;
AskVol = previous.AskVol;
PrevBid = previous.PrevBid;
PrevBidVol = previous.PrevBidVol;
PrevAsk = previous.PrevAsk;
PrevAskVol = previous.PrevAskVol;
Mid = previous.Mid;
MidScaled = previous.MidScaled;
if (!isFirstOfInterval)
{
BidOpen = previous.BidOpen;
BidVolOpen = previous.BidVolOpen;
AskOpen = previous.AskOpen;
AskVolOpen = previous.AskVolOpen;
MidOpen = previous.MidOpen;
MidScaledOpen = previous.MidScaledOpen;
LastPriceOpn = previous.LastPriceOpn;
VolAtBid = previous.VolAtBid;
VolAtAsk = previous.VolAtAsk;
TrdCntBid = previous.TrdCntBid;
TrdCntAsk = previous.TrdCntAsk;
BidVolChgSum = previous.BidVolChgSum;
BidVolChgCnt = previous.BidVolChgCnt;
AskVolChgSum = previous.AskVolChgSum;
AskVolChgCnt = previous.AskVolChgCnt;
if (StateType != MktStateType.Duplicate)
{
TrdsAtPrice = previous.TrdsAtPrice;
}
//BinCnt++;
}
else
{
BidOpen = previous.Bid;
BidVolOpen = previous.BidVol;
AskOpen = previous.Ask;
AskVolOpen = previous.AskVol;
MidOpen = previous.Mid;
MidScaledOpen = previous.MidScaled;
LastPriceOpn = previous.LastTrdPrice;
}
}
public TradesAtPrice(double price, MarketState state)
{
Price = price;
TradeCount++;
if (price == state.Bid)
{
CntAtBid++;
}
else
if (price == state.Ask)
{
CntAtAsk++;
}
}
private void SetBidVolChg(MarketState prevMktState)
{
if (_securityObj.HasQuoteSize)
{
if ((Bid == prevMktState.Bid))
{
BidVolChg = (int)(BidVol - prevMktState.BidVol);
BidVolChgSum += BidVolChg;
SetBidVolChgCnt(BidVolChg);
}
else
{
if ((Bid == prevMktState.Ask)) // just ticked up
{
BidVolChg = (int)(BidVol + prevMktState.AskVol);
BidVolChgSum += BidVolChg;
SetBidVolChgCnt(BidVolChg);
//Console.WriteLine(SecurityObj.Name + " went Bid @" + timeStamp.ToLongTimeString());
}
else
{
if ((Bid == prevMktState.PrevAsk)) // just ticked up, but need to look two data points back
{
BidVolChg = (int)(BidVol + prevMktState.PrevAskVol);
BidVolChgSum += BidVolChg;
SetBidVolChgCnt(BidVolChg);
//Console.WriteLine(SecurityObj.Name + " went Bid @" + timeStamp.ToLongTimeString());
}
else
{
if ((Bid < PrevBid)) // just ticked down
{
BidVolChg = -(int)(PrevBidVol);
BidVolChgSum += BidVolChg;
SetBidVolChgCnt(BidVolChg);
//Console.WriteLine("{0} went offered @ {1} {2} {3} {4} {5}",
// Name, TimeStamp.ToLongTimeString(), Bid.ToString(), PrevBid.ToString(), BidVolChg.ToString(), BidVolChgSum.ToString());
}
}
}
}
}
}
public void NewTradeAtPrice(uint volume, MarketState state)
{
TotalVolume += volume;
TradeCount++;
if (Price == state.Bid)
{
VolAtBid += volume;
CntAtBid++;
}
else
{
if (Price == state.Ask)
{
VolAtAsk += volume;
CntAtAsk++;
}
}
}
public TradesAtPrice(double price, uint volume, MarketState state)
{
Price = price;
TotalVolume = volume;
TradeCount++;
if (price == state.Bid)
{
VolAtBid += volume;
CntAtBid++;
}
else
{
if (price == state.Ask)
{
VolAtAsk += volume;
CntAtAsk++;
}
}
}
private void SetAskVolChg(MarketState prevMktState)
{
if (_securityObj.HasQuoteSize)
{
if (Ask == prevMktState.Ask)
{
AskVolChg = (int)(AskVol - prevMktState.AskVol);
AskVolChgSum += AskVolChg;
SetAskVolChgCnt(AskVolChg);
}
else
{
if (Ask == prevMktState.Bid) // just ticked down
{
AskVolChg = (int)(AskVol + prevMktState.BidVol);
AskVolChgSum += AskVolChg;
SetAskVolChgCnt(AskVolChg);
//Console.WriteLine(SecurityObj.Name + " went offered @" + timeStamp.ToLongTimeString());
}
else
{
if (Ask == prevMktState.PrevBid) // just ticked down, but we need to look two data points back for price/volume
{
AskVolChg = (int)(AskVol + prevMktState.PrevBidVol);
AskVolChgSum += AskVolChg;
SetAskVolChgCnt(AskVolChg);
//Console.WriteLine(SecurityObj.Name + " went offered @" + timeStamp.ToLongTimeString());
}
else
{
if ((Ask > PrevAsk)) // just ticked up
{
AskVolChg = -(int)(PrevAsk);
AskVolChgSum += AskVolChg;
SetAskVolChgCnt(AskVolChg);
}
}
}
}
}
}
// constructor used for each successive data event after the initial market summary event
public MarketState(Security security, MarketState previousMktState, TickData tickData)
{
VolumeTdy = 0;
OrderFlowTdy = 0;
VolAtBidTdy = 0;
VolAtAskTdy = 0;
_securityObj = security;
if (previousMktState == null)
{
throw new ArgumentException("Previous MarketState object must not be null", "previousMktState");
}
if (tickData.TimeStamp == null)
{
throw new ArgumentException("tickData.TimeStamp must not be null", "tickData.TimeStamp");
}
TimeStamp = tickData.TimeStamp;
FirstOfInterval = (tickData.TimeStamp.Subtract(previousMktState.TimeStamp).TotalSeconds > 0);
CopyPrevState(previousMktState, FirstOfInterval);
switch (tickData.Type)
{
case Type.Ask:
StateType = MktStateType.Ask;
OnAskQuote(tickData);
SetAskVolChg(previousMktState);
SetMid();
if (FirstOfInterval)
{
SetAskOpen(tickData);
SetMidOpen();
}
break;
case Type.Bid:
StateType = MktStateType.Bid;
OnBidQuote(tickData);
SetBidVolChg(previousMktState);
SetMid();
if (FirstOfInterval)
{
SetBidOpen(tickData);
SetMidOpen();
}
break;
case Type.Trade:
StateType = MktStateType.Trade;
OnTrade(tickData);
if (FirstOfInterval)
{
SetTradeOpn(tickData);
}
break;
default:
throw new ArgumentException("TickData's 'Type' parameter must be of enum of type TickData.Type", "tickData");
}
if ((FirstOfInterval) || (Codes == null))
{
Codes = tickData.Codes;
}
else
{
if (tickData.Codes != null)
{
if (tickData.Codes.Count > 0)
{
foreach (var code in tickData.Codes)
{
if (!Codes.ContainsKey(code.Key))
{
Codes.Add(code.Key, code.Value);
}
}
}
}
}
}
