/// <summary>
/// Attempts to exactly match the specified positions to this strategy definition with as much quantity as possible.
/// </summary>
public bool TryMatch(IReadOnlyList <OptionPosition> positions, out OptionStrategy strategy)
{
if (positions.Count == 0 || Legs.Count != positions.Count)
{
strategy = null;
return(false);
}
var underlying = positions[0].Symbol;
if (underlying.SecurityType == SecurityType.Option)
{
underlying = underlying.Underlying;
}
var quantityMultiplier = int.MaxValue;
var matches = new List <OptionStrategy.LegData>();
for (int i = 0; i < Legs.Count; i++)
{
var leg = Legs[i];
var position = positions[i];
OptionStrategy.LegData match;
if (!leg.TryMatch(position, out match))
{
strategy = null;
return(false);
}
matches.Add(match);
var multiple = match.Quantity / leg.Quantity;
quantityMultiplier = Math.Min(multiple, quantityMultiplier);
}
// separate matches into option/underlying legs and resize according to smallest quantity multipler
var optionLegs = new List <OptionStrategy.OptionLegData>();
var underlyingLegs = new List <OptionStrategy.UnderlyingLegData>();
for (var i = 0; i < matches.Count; i++)
{
var match = matches[i];
match.Invoke(underlyingLegs.Add, optionLegs.Add);
match.Quantity = Legs[i].Quantity * quantityMultiplier;
}
strategy = new OptionStrategy
{
Name = Name,
OptionLegs = optionLegs,
Underlying = underlying,
UnderlyingLegs = underlyingLegs
};
return(true);
}
/// <summary>
/// Creates the <see cref="OptionStrategy"/> instance this match represents
/// </summary>
public OptionStrategy CreateStrategy()
{
var legs = Legs.Select(leg => leg.CreateOptionStrategyLeg(Multiplier));
var strategy = new OptionStrategy {
Name = Definition.Name, Underlying = Legs[0].Position.Underlying
};
foreach (var leg in legs)
{
leg.Invoke(strategy.UnderlyingLegs.Add, strategy.OptionLegs.Add);
}
return(strategy);
}
public string GetStrategyControl(OptionStrategy strategy)
{
string controlID = string.Empty;
switch (strategy)
{
case OptionStrategy.CallPut:
controlID = "OptionTicket_code_1";
break;
case OptionStrategy.Butterfly:
controlID = "OptionTicket_code_2";
break;
case OptionStrategy.Calendar:
controlID = "OptionTicket_code_3";
break;
case OptionStrategy.Collar:
controlID = "OptionTicket_code_13";
break;
case OptionStrategy.Condor:
controlID = "OptionTicket_code_4";
break;
case OptionStrategy.Covered:
controlID = "OptionTicket_code_5";
break;
case OptionStrategy.IronButterfly:
controlID = "OptionTicket_code_6";
break;
case OptionStrategy.IronCondor:
controlID = "OptionTicket_code_7";
break;
case OptionStrategy.Ratio:
controlID = "OptionTicket_code_9";
break;
case OptionStrategy.Spread:
controlID = "OptionTicket_code_10";
break;
case OptionStrategy.Straddle:
controlID = "OptionTicket_code_11";
break;
case OptionStrategy.Strangle:
controlID = "OptionTicket_code_12";
break;
default:
break;
}
return controlID;
}
/// <summary>
/// Creates the <see cref="OptionStrategy"/> instance using this definition and the provided leg matches
/// </summary>
public OptionStrategy CreateStrategy(IReadOnlyList <OptionStrategyLegDefinitionMatch> legs)
{
var underlying = legs[0].Position.Symbol;
if (underlying.HasUnderlying)
{
underlying = underlying.Underlying;
}
var strategy = new OptionStrategy {
Name = Name, Underlying = underlying
};
for (int i = 0; i < Math.Min(Legs.Count, legs.Count); i++)
{
var leg = Legs[i].CreateLegData(legs[i]);
leg.Invoke(strategy.UnderlyingLegs.Add, strategy.OptionLegs.Add);
}
return(strategy);
}
/// <summary>
/// Creates the <see cref="OptionStrategy"/> instance this match represents
/// </summary>
public OptionStrategy CreateStrategy()
{
var legs = Legs.Select(leg => leg.CreateOptionStrategyLeg(Multiplier));
var strategy = new OptionStrategy {
Name = Definition.Name,
Underlying = Legs[0].Position.Underlying
};
foreach (var optionLeg in legs)
{
optionLeg.Invoke(strategy.UnderlyingLegs.Add, strategy.OptionLegs.Add);
}
if (Definition.UnderlyingLots != 0)
{
strategy.UnderlyingLegs = new List <OptionStrategy.UnderlyingLegData>
{
OptionStrategy.UnderlyingLegData.Create(Definition.UnderlyingLots * Multiplier, Legs[0].Position.Underlying)
};
}
return(strategy);
}
private IEnumerable <OrderTicket> GenerateOrders(OptionStrategy strategy, int strategyQuantity)
{
var orders = new List <OrderTicket>();
// setting up the tag text for all orders of one strategy
var strategyTag = strategy.Name + " (" + strategyQuantity.ToString() + ")";
// walking through all option legs and issuing orders
if (strategy.OptionLegs != null)
{
foreach (var optionLeg in strategy.OptionLegs)
{
var optionSeq = Securities.Where(kv => kv.Key.Underlying == strategy.Underlying &&
kv.Key.ID.OptionRight == optionLeg.Right &&
kv.Key.ID.Date == optionLeg.Expiration &&
kv.Key.ID.StrikePrice == optionLeg.Strike);
if (optionSeq.Count() != 1)
{
var error = string.Format("Couldn't find the option contract in algorithm securities list. Underlying: {0}, option {1}, strike {2}, expiration: {3}",
strategy.Underlying.ToString(), optionLeg.Right.ToString(), optionLeg.Strike.ToString(), optionLeg.Expiration.ToString());
throw new InvalidOperationException(error);
}
var option = optionSeq.First().Key;
switch (optionLeg.OrderType)
{
case OrderType.Market:
var marketOrder = MarketOrder(option, optionLeg.Quantity * strategyQuantity, tag: strategyTag);
orders.Add(marketOrder);
break;
case OrderType.Limit:
var limitOrder = LimitOrder(option, optionLeg.Quantity * strategyQuantity, optionLeg.OrderPrice, tag: strategyTag);
orders.Add(limitOrder);
break;
default:
throw new InvalidOperationException("Order type is not supported in option strategy: " + optionLeg.OrderType.ToString());
}
}
}
// walking through all underlying legs and issuing orders
if (strategy.UnderlyingLegs != null)
{
foreach (var underlyingLeg in strategy.UnderlyingLegs)
{
if (!Securities.ContainsKey(strategy.Underlying))
{
var error = string.Format("Couldn't find the option contract underlying in algorithm securities list. Underlying: {0}", strategy.Underlying.ToString());
throw new InvalidOperationException(error);
}
switch (underlyingLeg.OrderType)
{
case OrderType.Market:
var marketOrder = MarketOrder(strategy.Underlying, underlyingLeg.Quantity * strategyQuantity, tag: strategyTag);
orders.Add(marketOrder);
break;
case OrderType.Limit:
var limitOrder = LimitOrder(strategy.Underlying, underlyingLeg.Quantity * strategyQuantity, underlyingLeg.OrderPrice, tag: strategyTag);
orders.Add(limitOrder);
break;
default:
throw new InvalidOperationException("Order type is not supported in option strategy: " + underlyingLeg.OrderType.ToString());
}
}
}
return(orders);
}
/// <summary>
/// Issue an order/trade for buying/selling an option strategy
/// </summary>
/// <param name="strategy">Specification of the strategy to trade</param>
/// <param name="quantity">Quantity of the strategy to trade</param>
/// <returns>Sequence of order ids</returns>
public IEnumerable <OrderTicket> Order(OptionStrategy strategy, int quantity)
{
return(GenerateOrders(strategy, quantity));
}
/// <summary>
/// Sell Option Strategy (alias of Order)
/// </summary>
/// <param name="strategy">Specification of the strategy to trade</param>
/// <param name="quantity">Quantity of the strategy to trade</param>
/// <returns>Sequence of order ids</returns>
public IEnumerable <OrderTicket> Sell(OptionStrategy strategy, int quantity)
{
return(Order(strategy, Math.Abs(quantity) * -1));
}
public void GetOptionInfo(OptionStrategy optionStrategy)
{
throw new NotImplementedException();
}
// Support for option strategies trading
/// <summary>
/// Buy Option Strategy (Alias of Order)
/// </summary>
/// <param name="strategy">Specification of the strategy to trade</param>
/// <param name="quantity">Quantity of the strategy to trade</param>
/// <returns>Sequence of order ids</returns>
public IEnumerable<OrderTicket> Buy(OptionStrategy strategy, int quantity)
{
return Order(strategy, Math.Abs(quantity));
}
private void getRealtimeSystemResultsFromDatabase()
{
try
{
eodConflictList.Clear();
eodConflictList.Columns.Add("Rule Type", 75, HorizontalAlignment.Left);
eodConflictList.Columns.Add("Realtime Rule", 200, HorizontalAlignment.Left);
eodConflictList.Columns.Add("EOD Rule", 200, HorizontalAlignment.Left);
eodConflictList.Columns.Add("strategy", 50, HorizontalAlignment.Left);
eodConflictList.Columns.Add("instrument", 50, HorizontalAlignment.Left);
int stratListOfIds = 0;
int realtime = 1;
int eod = 2;
DataRow[][] systemResultsComparison = optionSpreadManager.readRealtimeSystemResultsFromDatabase();
Dictionary <int, DataRow> intradayRows = new Dictionary <int, DataRow>();
for (int i = 0; i < systemResultsComparison[realtime].Length; i++)
{
if (!intradayRows.ContainsKey(Convert.ToInt32(systemResultsComparison[realtime][i]["idstrategy"])))
{
intradayRows.Add(Convert.ToInt32(systemResultsComparison[realtime][i]["idstrategy"]),
systemResultsComparison[realtime][i]);
}
}
Dictionary <int, DataRow> eodRows = new Dictionary <int, DataRow>();
for (int i = 0; i < systemResultsComparison[eod].Length; i++)
{
if (!eodRows.ContainsKey(Convert.ToInt32(systemResultsComparison[eod][i]["idstrategy"])))
{
eodRows.Add(Convert.ToInt32(systemResultsComparison[eod][i]["idstrategy"]),
systemResultsComparison[eod][i]);
}
}
OptionStrategy[] optionStrategies = optionSpreadManager.getOptionStrategies;
Dictionary <int, OptionStrategy> optionStrategiesHashTable = new Dictionary <int, OptionStrategy>();
for (int i = 0; i < optionStrategies.Length; i++)
{
if (!optionStrategiesHashTable.ContainsKey(optionStrategies[i].idStrategy))
{
optionStrategiesHashTable.Add(optionStrategies[i].idStrategy,
optionStrategies[i]);
}
}
for (int i = 0; i < systemResultsComparison[stratListOfIds].Length; i++)
{
int idstrategy = Convert.ToInt32(systemResultsComparison[stratListOfIds][i]["idstrategy"]);
if (intradayRows.ContainsKey(idstrategy) && eodRows.ContainsKey(idstrategy))
{
DataRow realtimeRow = intradayRows[idstrategy];
DataRow eod_1_Row = eodRows[idstrategy];
OptionStrategy optionStrategy = optionStrategiesHashTable[idstrategy];
//TSErrorCatch.debugWriteOut(realtimeRow["entryrule"].ToString());
//TSErrorCatch.debugWriteOut(eod_1_Row["entryrule"].ToString());
string realtimeEntry = realtimeRow["entryrule"].ToString();
string eodEntry = eod_1_Row["entryrule"].ToString();
string realtimeExit = realtimeRow["exitrule"].ToString();
string eodExit = eod_1_Row["exitrule"].ToString();
bool entryConflict = true;
if (realtimeEntry.Length > 4 && eodEntry.Length > 4 &&
realtimeEntry.Substring(realtimeEntry.Length - 4).CompareTo(
eodEntry.Substring(eodEntry.Length - 4)) == 0)
{
entryConflict = false;
}
if (entryConflict)
{
//StringBuilder entry = new StringBuilder();
//entry.Append(realtimeEntry);
//entry.Append("\n");
//entry.Append(eodEntry);
ListViewItem item = new ListViewItem("Entry Conflict");
item.BackColor = Color.LawnGreen;
item.ForeColor = Color.Black;
item.UseItemStyleForSubItems = false;
eodConflictList.Items.Add(item);
item.SubItems.Add(realtimeEntry,
Color.Black, Color.LightGreen, item.Font);
item.SubItems.Add(eodEntry,
Color.Black, Color.LightGreen, item.Font);
item.SubItems.Add(idstrategy.ToString(),
Color.Black, Color.LightGreen, item.Font);
item.SubItems.Add(optionStrategy.instrument.exchangeSymbol,
Color.Black, Color.LightGreen, item.Font);
//item.SubItems.Add(instrumentAcct.Value,
// Color.Black, Color.LawnGreen, item.Font);
//item.SubItems.Add(optionSpreadManager.portfolioGroupAllocation[groupAllocCnt].multiple.ToString(),
// Color.Black, Color.LawnGreen, item.Font);
}
bool exitConflict = true;
if (realtimeExit.Length > 4 && eodExit.Length > 4 &&
realtimeExit.Substring(realtimeExit.Length - 4).CompareTo(
eodExit.Substring(eodExit.Length - 4)) == 0)
{
exitConflict = false;
}
if (exitConflict)
{
//StringBuilder entry = new StringBuilder();
//entry.Append(realtimeEntry);
//entry.Append("\n");
//entry.Append(eodEntry);
ListViewItem item = new ListViewItem("Exit Conflict");
item.BackColor = Color.Red;
item.ForeColor = Color.White;
item.UseItemStyleForSubItems = false;
eodConflictList.Items.Add(item);
item.SubItems.Add(realtimeExit,
Color.Black, Color.LightPink, item.Font);
item.SubItems.Add(eodExit,
Color.Black, Color.LightPink, item.Font);
item.SubItems.Add(idstrategy.ToString(),
Color.Black, Color.LightPink, item.Font);
item.SubItems.Add(optionStrategy.instrument.exchangeSymbol,
Color.Black, Color.LightPink, item.Font);
//item.SubItems.Add(instrumentAcct.Value,
// Color.Black, Color.LawnGreen, item.Font);
//item.SubItems.Add(optionSpreadManager.portfolioGroupAllocation[groupAllocCnt].multiple.ToString(),
// Color.Black, Color.LawnGreen, item.Font);
}
}
}
}
catch (Exception ex)
{
TSErrorCatch.errorCatchOut(Convert.ToString(this), ex);
}
}
