public static PositionManagerOutput GetFuturesButterflyPosition(string alias, DateTime asOfDate, MySqlConnection conn)
{
DataTable StrategyPosition = TA.Strategy.GetNetPosition(alias: alias, conn: conn, asOfDate: asOfDate);
StrategyUtilities.PositionManagerOutput PositionManagerOut = new StrategyUtilities.PositionManagerOutput();
if (StrategyPosition.Rows.Count == 0)
{
return(PositionManagerOut);
}
StrategyPosition.Columns.Add("TickerHead", typeof(string));
StrategyPosition.Columns.Add("SortIndex", typeof(int));
foreach (DataRow Row in StrategyPosition.Rows)
{
ContractUtilities.ContractSpecs Cs = ContractUtilities.ContractMetaInfo.GetContractSpecs(ticker: Row.Field <string>("Ticker"));
Row["TickerHead"] = Cs.tickerHead;
Row["SortIndex"] = Cs.contINDX;
}
StrategyPosition = DataAnalysis.DataTableFunctions.Sort(dataTableInput: StrategyPosition, columnList: new string[] { "SortIndex" });
bool CorrectPositionQ = false;
if ((StrategyPosition.Rows.Count == 3) &&
(Math.Sign(StrategyPosition.Rows[0].Field <double>("Qty"))) == Math.Sign(StrategyPosition.Rows[2].Field <double>("Qty")) &&
(StrategyPosition.AsEnumerable().Sum(x => x.Field <double>("Qty")) == 0))
{
CorrectPositionQ = true;
}
PositionManagerOut.SortedPosition = StrategyPosition;
PositionManagerOut.Scale = StrategyPosition.Rows[0].Field <double>("Qty");
PositionManagerOut.CorrectPositionQ = CorrectPositionQ;
return(PositionManagerOut);
}
DataTable GenerateHedgeTable(MySqlConnection conn)
{
string DeltaStrategy = HedgeStrategies.GetDeltaStrategyList(conn: conn).Last();
//string DeltaStrategy = HedgeStrategies.GetDeltaStrategyList(conn: conn).First();
DataTable DeltaNetPosition = TA.Strategy.GetNetPosition(alias: DeltaStrategy, conn: conn);
DeltaNetPosition.Columns.Add("TickerHead", typeof(string));
DeltaNetPosition.Columns.Add("TickerClass", typeof(string));
DeltaNetPosition.Columns.Add("ContINDX", typeof(int));
for (int i = 0; i < DeltaNetPosition.Rows.Count; i++)
{
ContractUtilities.ContractSpecs Cs = ContractUtilities.ContractMetaInfo.GetContractSpecs(ticker: DeltaNetPosition.Rows[i].Field <string>("Ticker"));
DeltaNetPosition.Rows[i]["TickerHead"] = Cs.tickerHead;
DeltaNetPosition.Rows[i]["TickerClass"] = Cs.tickerClass;
DeltaNetPosition.Rows[i]["ContINDX"] = Cs.contINDX;
}
DataRow[] FlatCurvePositions = (from x in DeltaNetPosition.AsEnumerable()
where Underlying.FlatCurveTickerClassList.Any(b => x.Field <string>("TickerClass").Contains(b))
select x).ToArray();
DataRow[] NonFlatCurvePositions = (from x in DeltaNetPosition.AsEnumerable()
where !Underlying.FlatCurveTickerClassList.Any(b => x.Field <string>("TickerClass").Contains(b))
select x).ToArray();
DataTable FlatCurveHedgeTable = new DataTable();
FlatCurveHedgeTable.Columns.Add("Ticker", typeof(string));
FlatCurveHedgeTable.Columns.Add("TickerHead", typeof(string));
FlatCurveHedgeTable.Columns.Add("IsSpreadQ", typeof(bool));
FlatCurveHedgeTable.Columns.Add("Hedge", typeof(int));
DataTable NonFlatCurveHedgeTable = new DataTable();
NonFlatCurveHedgeTable.Columns.Add("Ticker", typeof(string));
NonFlatCurveHedgeTable.Columns.Add("TickerHead", typeof(string));
NonFlatCurveHedgeTable.Columns.Add("IsSpreadQ", typeof(bool));
NonFlatCurveHedgeTable.Columns.Add("Hedge", typeof(int));
if (FlatCurvePositions.Count() > 0)
{
DataTable FlatCurveTable = FlatCurvePositions.CopyToDataTable();
ContractUtilities.ContractList liquidContractList = new ContractUtilities.ContractList(FlatCurveTable.AsEnumerable().Select(s => s.Field <string>("TickerHead")).Distinct().ToArray());
Dictionary <string, string> LiquidContractDictionary = new Dictionary <string, string>();
foreach (string item in liquidContractList.dbTickerList)
{
LiquidContractDictionary.Add(ContractUtilities.ContractMetaInfo.GetContractSpecs(item).tickerHead, item);
}
var grouped = FlatCurveTable.AsEnumerable().GroupBy(r => r["TickerHead"]).Select(w => new
{
TickerHead = w.Key.ToString(),
Qty = w.Sum(r => decimal.Parse(r["Qty"].ToString())),
}).ToList();
for (int i = 0; i < grouped.Count; i++)
{
FlatCurveHedgeTable.Rows.Add();
FlatCurveHedgeTable.Rows[i]["Ticker"] = LiquidContractDictionary[grouped[i].TickerHead];
FlatCurveHedgeTable.Rows[i]["TickerHead"] = grouped[i].TickerHead;
FlatCurveHedgeTable.Rows[i]["IsSpreadQ"] = false;
FlatCurveHedgeTable.Rows[i]["Hedge"] = Math.Round(-grouped[i].Qty);
}
}
if (NonFlatCurvePositions.Count() > 0)
{
DataTable SortedNonFlatCurvePositions = NonFlatCurvePositions.AsEnumerable()
.OrderBy(r => r.Field <string>("TickerHead"))
.ThenBy(r => r.Field <int>("contINDX"))
.CopyToDataTable();
List <string> TickerHeadList = SortedNonFlatCurvePositions.AsEnumerable().Select(s => s.Field <string>("TickerHead")).Distinct().ToList();
for (int i = 0; i < TickerHeadList.Count(); i++)
{
DataTable TickerHeadPositions = SortedNonFlatCurvePositions.Select("TickerHead='" + TickerHeadList[i] + "'").CopyToDataTable();
if (TickerHeadPositions.Rows.Count == 1)
{
DataRow Row = NonFlatCurveHedgeTable.NewRow();
NonFlatCurveHedgeTable.Rows.Add();
Row["Ticker"] = TickerHeadPositions.Rows[0].Field <string>("Ticker");
Row["TickerHead"] = TickerHeadList[i];
Row["IsSpreadQ"] = false;
Row["Hedge"] = Math.Round(-TickerHeadPositions.Rows[0].Field <double>("Qty"));
NonFlatCurveHedgeTable.Rows.Add(Row);
continue;
}
int sum = (int)Math.Round(-TickerHeadPositions.AsEnumerable().Sum(x => x.Field <double>("Qty")));
int MaxIndex = TickerHeadPositions.Rows.IndexOf(TickerHeadPositions.Select("Qty = MAX(Qty)")[0]);
int MinIndex = TickerHeadPositions.Rows.IndexOf(TickerHeadPositions.Select("Qty = MIN(Qty)")[0]);
if (sum > 0)
{
DataRow Row = NonFlatCurveHedgeTable.NewRow();
Row["Ticker"] = TickerHeadPositions.Rows[MinIndex].Field <string>("Ticker");
Row["TickerHead"] = TickerHeadList[i];
Row["IsSpreadQ"] = false;
Row["Hedge"] = sum;
NonFlatCurveHedgeTable.Rows.Add(Row);
TickerHeadPositions.Rows[MinIndex]["Qty"] = TickerHeadPositions.Rows[MinIndex].Field <double>("Qty") + sum;
}
else if (sum < 0)
{
DataRow Row = NonFlatCurveHedgeTable.NewRow();
Row["Ticker"] = TickerHeadPositions.Rows[MaxIndex].Field <string>("Ticker");
Row["TickerHead"] = TickerHeadList[i];
Row["IsSpreadQ"] = false;
Row["Hedge"] = sum;
NonFlatCurveHedgeTable.Rows.Add(Row);
TickerHeadPositions.Rows[MaxIndex]["Qty"] = TickerHeadPositions.Rows[MaxIndex].Field <double>("Qty") + sum;
}
bool PositionCleanedQ = false;
while (!PositionCleanedQ)
{
var OrderedRows = TickerHeadPositions.AsEnumerable().OrderByDescending(x => x["Qty"]);
MaxIndex = TickerHeadPositions.Rows.IndexOf(OrderedRows.First());
MinIndex = TickerHeadPositions.Rows.IndexOf(OrderedRows.Last());
PositionCleanedQ = !((TickerHeadPositions.Rows[MaxIndex].Field <double>("Qty") > 0.5) & (TickerHeadPositions.Rows[MinIndex].Field <double>("Qty") < -0.5));
if (PositionCleanedQ)
{
break;
}
int qty = -(int)Math.Round(Math.Min(TickerHeadPositions.Rows[MaxIndex].Field <double>("Qty"), -TickerHeadPositions.Rows[MinIndex].Field <double>("Qty")));
string SpreadTicker;
int HedgeQty;
if (TickerHeadPositions.Rows[MaxIndex].Field <int>("ContINDX") < TickerHeadPositions.Rows[MinIndex].Field <int>("ContINDX"))
{
SpreadTicker = TickerHeadPositions.Rows[MaxIndex].Field <string>("Ticker") + "-" + TickerHeadPositions.Rows[MinIndex].Field <string>("Ticker");
HedgeQty = qty;
}
else
{
HedgeQty = -qty;
SpreadTicker = TickerHeadPositions.Rows[MinIndex].Field <string>("Ticker") + "-" + TickerHeadPositions.Rows[MaxIndex].Field <string>("Ticker");
}
DataRow Row = NonFlatCurveHedgeTable.NewRow();
Row["Ticker"] = SpreadTicker;
Row["TickerHead"] = TickerHeadList[i];
Row["IsSpreadQ"] = true;
Row["Hedge"] = HedgeQty;
NonFlatCurveHedgeTable.Rows.Add(Row);
TickerHeadPositions.Rows[MaxIndex]["Qty"] = TickerHeadPositions.Rows[MaxIndex].Field <double>("Qty") + qty;
TickerHeadPositions.Rows[MinIndex]["Qty"] = TickerHeadPositions.Rows[MinIndex].Field <double>("Qty") - qty;
}
}
}
FlatCurveHedgeTable.Merge(NonFlatCurveHedgeTable);
return(FlatCurveHedgeTable);
}
public static List <string> GetThemeList4Position(List <string> tickerList, double direction)
{
List <string> ThemeList = new List <string>();
ContractUtilities.ContractSpecs Cs1 = ContractUtilities.ContractMetaInfo.GetContractSpecs(tickerList[0]);
ContractUtilities.ContractSpecs Cs2 = ContractUtilities.ContractMetaInfo.GetContractSpecs(tickerList[1]);
ContractUtilities.ContractSpecs Cs3 = ContractUtilities.ContractMetaInfo.GetContractSpecs(tickerList[2]);
string TickerHead = Cs1.tickerHead;
if ((TickerHead == "LC") && (Cs1.tickerMonthNum < 8) && (Cs2.tickerMonthNum == 8))
{
if (direction < 0)
{
ThemeList.Add("Cattle_ShortSpringAgainstSummer");
}
else if (direction > 0)
{
ThemeList.Add("Cattle_LongSpringAgainstSummer");
}
}
if ((TickerHead == "LC") && (Cs2.tickerMonthNum == 4))
{
if (direction > 0)
{
ThemeList.Add("Cattle_ShortSpringAgainstSummer");
}
else if (direction < 0)
{
ThemeList.Add("Cattle_LongSpringAgainstSummer");
}
}
if ((TickerHead == "FC") && (Cs2.tickerMonthNum == 3))
{
if (direction < 0)
{
ThemeList.Add("Cattle_ShortSpringAgainstSummer");
}
else if (direction > 0)
{
ThemeList.Add("Cattle_LongSpringAgainstSummer");
}
}
if (SoyTickerHeadGroup.Contains(TickerHead))
{
if (direction < 0)
{
ThemeList.Add("Soy_Short");
}
else if (direction > 0)
{
ThemeList.Add("Soy_Long");
}
}
if (WheatTickerHeadGroup.Contains(TickerHead))
{
if (direction < 0)
{
ThemeList.Add("Wheat_Short");
}
else if (direction > 0)
{
ThemeList.Add("Wheat_Long");
}
}
if ((WtiCrudeOilTickerHeadGroup.Contains(TickerHead)) && (direction > 0))
{
ThemeList.Add("WtiCrudeOil_Long");
}
if ((WtiCrudeOilTickerHeadGroup.Contains(TickerHead)) && (direction < 0))
{
ThemeList.Add("WtiCrudeOil_Short");
}
if ((CrudeOilTickerHeadGroup.Contains(TickerHead)) && (Cs1.contINDX < ContIndx1YearOut) && (direction > 0))
{
ThemeList.Add("CrudeOilShortDated_Long");
}
if ((CrudeOilTickerHeadGroup.Contains(TickerHead)) && (Cs1.contINDX < ContIndx1YearOut) && (direction < 0))
{
ThemeList.Add("CrudeOilShortDated_Short");
}
if ((TickerHead == "RB") && ((Cs2.tickerMonthNum == 5) || (Cs2.tickerMonthNum == 4)))
{
if (direction < 0)
{
ThemeList.Add("RB_LongSummer");
}
else if (direction > 0)
{
ThemeList.Add("RB_ShortSummer");
}
}
if ((TickerHead == "RB") && (Cs2.tickerMonthNum == 10))
{
if (direction < 0)
{
ThemeList.Add("RB_ShortSummer");
}
else if (direction > 0)
{
ThemeList.Add("RB_LongSummer");
}
}
if ((TickerHead == "NG") && (Cs2.tickerMonthNum == 7))
{
if (direction > 0)
{
ThemeList.Add("NG_ShortWinter");
}
else if (direction < 0)
{
ThemeList.Add("NG_LongWinter");
}
}
if ((TickerHead == "NG") && (Cs2.tickerMonthNum == 11))
{
if (direction < 0)
{
ThemeList.Add("NG_ShortWinter");
}
else if (direction > 0)
{
ThemeList.Add("NG_LongWinter");
}
}
return(ThemeList);
}
public static DataTable GetUnderlying2QueryTable(MySqlConnection conn)
{
List <string> StrategyList = HedgeStrategies.GetStrategyList2Hedge(conn: conn);
StrategyList.Add(HedgeStrategies.GetActiveDeltaStrategy(conn: conn));
DataTable MergedPosition = null;
for (int i = 0; i < StrategyList.Count; i++)
{
if (i == 0)
{
MergedPosition = TA.Strategy.GetNetPosition(alias: StrategyList[i], conn: conn);
}
else
{
MergedPosition.Merge(TA.Strategy.GetNetPosition(alias: StrategyList[i], conn: conn));
}
}
DataTable FuturesPosition = MergedPosition.Select("Instrument='F'").CopyToDataTable();
DataTable OptionsPosition = MergedPosition.Select("Instrument='O'").CopyToDataTable();
List <string> OptionTickerList = OptionsPosition.AsEnumerable()
.Select(r => r.Field <string>("Ticker")).Distinct()
.ToList();
List <string> FuturesTickerList = FuturesPosition.AsEnumerable()
.Select(r => r.Field <string>("Ticker")).Distinct()
.ToList();
List <string> UnderlyingTickerList = new List <string>();
foreach (string item in OptionTickerList)
{
UnderlyingTickerList.Add(OptionModels.Utils.GetOptionUnderlying(ticker: item));
}
List <string> UniqueList = UnderlyingTickerList.Union(FuturesTickerList).ToList();
DataTable UnderlyingTable = new DataTable();
UnderlyingTable.Columns.Add("Ticker", typeof(string));
UnderlyingTable.Columns.Add("TickerHead", typeof(string));
UnderlyingTable.Columns.Add("TickerClass", typeof(string));
UnderlyingTable.Columns.Add("ContINDX", typeof(int));
for (int i = 0; i < UniqueList.Count; i++)
{
DataRow UnderlyingRow = UnderlyingTable.NewRow();
UnderlyingRow["Ticker"] = UniqueList[i];
ContractUtilities.ContractSpecs Cs = ContractUtilities.ContractMetaInfo.GetContractSpecs(ticker: UniqueList[i]);
UnderlyingRow["TickerHead"] = Cs.tickerHead;
UnderlyingRow["TickerClass"] = Cs.tickerClass;
UnderlyingRow["ContINDX"] = Cs.contINDX;
UnderlyingTable.Rows.Add(UnderlyingRow);
}
DataRow[] FlatCurveUnderlyings = (from x in UnderlyingTable.AsEnumerable()
where FlatCurveTickerClassList.Any(b => x.Field <string>("TickerClass").Contains(b))
select x).ToArray();
DataRow[] NonFlatCurveUnderlyings = (from x in UnderlyingTable.AsEnumerable()
where !FlatCurveTickerClassList.Any(b => x.Field <string>("TickerClass").Contains(b))
select x).ToArray();
DataTable FlatCurveQueryTable = new DataTable();
FlatCurveQueryTable.Columns.Add("Ticker", typeof(string));
FlatCurveQueryTable.Columns.Add("TickerHead", typeof(string));
FlatCurveQueryTable.Columns.Add("TickerClass", typeof(string));
FlatCurveQueryTable.Columns.Add("ContINDX", typeof(int));
FlatCurveQueryTable.Columns.Add("IsSpreadQ", typeof(bool));
DataTable NonFlatCurveQueryTable = new DataTable();
NonFlatCurveQueryTable.Columns.Add("Ticker", typeof(string));
NonFlatCurveQueryTable.Columns.Add("TickerHead", typeof(string));
NonFlatCurveQueryTable.Columns.Add("TickerClass", typeof(string));
NonFlatCurveQueryTable.Columns.Add("ContINDX", typeof(int));
NonFlatCurveQueryTable.Columns.Add("IsSpreadQ", typeof(bool));
if (FlatCurveUnderlyings.Count() > 0)
{
DataTable FlatCurveUnderlyingTable = FlatCurveUnderlyings.CopyToDataTable();
ContractUtilities.ContractList liquidContractList = new ContractUtilities.ContractList(FlatCurveUnderlyingTable.AsEnumerable().Select(s => s.Field <string>("TickerHead")).Distinct().ToArray());
for (int i = 0; i < liquidContractList.dbTickerList.Count; i++)
{
if (!(FlatCurveUnderlyingTable.AsEnumerable().Any(row => liquidContractList.dbTickerList[i] == row.Field <String>("Ticker"))))
{
DataRow UnderlyingRow = FlatCurveUnderlyingTable.NewRow();
UnderlyingRow["Ticker"] = liquidContractList.dbTickerList[i];
ContractUtilities.ContractSpecs Cs = ContractUtilities.ContractMetaInfo.GetContractSpecs(ticker: liquidContractList.dbTickerList[i]);
UnderlyingRow["TickerHead"] = Cs.tickerHead;
UnderlyingRow["TickerClass"] = Cs.tickerClass;
UnderlyingRow["ContINDX"] = Cs.contINDX;
FlatCurveUnderlyingTable.Rows.Add(UnderlyingRow);
}
}
for (int i = 0; i < FlatCurveUnderlyingTable.Rows.Count; i++)
{
DataRow Row = FlatCurveQueryTable.NewRow();
Row["Ticker"] = FlatCurveUnderlyingTable.Rows[i].Field <string>("Ticker");
Row["TickerHead"] = FlatCurveUnderlyingTable.Rows[i].Field <string>("TickerHead");
Row["TickerClass"] = FlatCurveUnderlyingTable.Rows[i].Field <string>("TickerClass");
Row["ContINDX"] = FlatCurveUnderlyingTable.Rows[i].Field <int>("ContINDX");
Row["IsSpreadQ"] = false;
FlatCurveQueryTable.Rows.Add(Row);
}
}
if (NonFlatCurveUnderlyings.Count() > 0)
{
DataTable SortedNonFlatCurveUnderlyings = NonFlatCurveUnderlyings.AsEnumerable()
.OrderBy(r => r.Field <string>("TickerHead"))
.ThenBy(r => r.Field <int>("contINDX"))
.CopyToDataTable();
List <string> TickerHeadList = SortedNonFlatCurveUnderlyings.AsEnumerable().Select(s => s.Field <string>("TickerHead")).Distinct().ToList();
for (int i = 0; i < TickerHeadList.Count(); i++)
{
DataTable TickerHeadPositions = SortedNonFlatCurveUnderlyings.Select("TickerHead='" + TickerHeadList[i] + "'").CopyToDataTable();
for (int j = 0; j < TickerHeadPositions.Rows.Count; j++)
{
DataRow Row = NonFlatCurveQueryTable.NewRow();
Row["Ticker"] = TickerHeadPositions.Rows[j].Field <string>("Ticker");
Row["TickerHead"] = TickerHeadPositions.Rows[j].Field <string>("TickerHead");
Row["TickerClass"] = TickerHeadPositions.Rows[j].Field <string>("TickerClass");
Row["ContINDX"] = TickerHeadPositions.Rows[j].Field <int>("ContINDX");
Row["IsSpreadQ"] = false;
NonFlatCurveQueryTable.Rows.Add(Row);
}
for (int j = 0; j < TickerHeadPositions.Rows.Count - 1; j++)
{
for (int k = j + 1; k < TickerHeadPositions.Rows.Count; k++)
{
DataRow Row2 = NonFlatCurveQueryTable.NewRow();
Row2["Ticker"] = TickerHeadPositions.Rows[j].Field <string>("Ticker") + "-" + TickerHeadPositions.Rows[k].Field <string>("Ticker");
Row2["TickerHead"] = TickerHeadPositions.Rows[j].Field <string>("TickerHead");
Row2["TickerClass"] = TickerHeadPositions.Rows[j].Field <string>("TickerClass");
Row2["ContINDX"] = TickerHeadPositions.Rows[j].Field <int>("ContINDX");
Row2["IsSpreadQ"] = true;
NonFlatCurveQueryTable.Rows.Add(Row2);
}
}
}
}
FlatCurveQueryTable.Merge(NonFlatCurveQueryTable);
return(FlatCurveQueryTable);
}
