/// <summary> /// /// </summary> /// <param name="pInstrument"></param> /// <param name="pDirection"></param> /// <param name="pOffset"></param> /// <param name="pPrice"></param> /// <param name="pVolume"></param> /// <param name="pHedge"></param> /// <returns>正确返回0</returns> public int ReqOrderInsert(string pInstrument, DirectionType pDirection, OffsetType pOffset, double pPrice, int pVolume, HedgeType pHedge = HedgeType.Speculation, OrderType pType = OrderType.Limit) { return _proxy.ReqOrderInsert(pInstrument, pDirection, pOffset, pPrice, pVolume, pHedge, pType); }
private void CTPOnRspQryInvestorPosition(ref CThostFtdcInvestorPositionField pInvestorPosition, ref CThostFtdcRspInfoField pRspInfo, int nRequestID, bool bIsLast) { if (!string.IsNullOrEmpty(pInvestorPosition.InstrumentID)) { var f = pInvestorPosition; _listPosi.Add(f); } if (bIsLast) { foreach (var g in _listPosi.GroupBy(p => p.InstrumentID + "_" + p.PosiDirection)) { var id = g.First(); //整理持仓数据 HedgeType hedge = HedgeType.Speculation; switch (id.HedgeFlag) { case TThostFtdcHedgeFlagType.THOST_FTDC_HF_Speculation: hedge = HedgeType.Speculation; break; case TThostFtdcHedgeFlagType.THOST_FTDC_HF_Arbitrage: hedge = HedgeType.Arbitrage; break; case TThostFtdcHedgeFlagType.THOST_FTDC_HF_Hedge: hedge = HedgeType.Hedge; break; } DirectionType dire = DirectionType.Buy; if (g.First().PosiDirection == TThostFtdcPosiDirectionType.THOST_FTDC_PD_Short) { dire = DirectionType.Sell; } var key = id.InstrumentID + "_" + dire; var pf = DicPositionField.GetOrAdd(key, new PositionField { InstrumentID = id.InstrumentID, Direction = dire, Hedge = hedge, }); //if (pInvestorPosition.PositionDate == TThostFtdcPositionDateType.THOST_FTDC_PSD_Today) //{ // pf.TdPosition = pInvestorPosition.Position; // pf.TdCost = pf.TdPosition == 0 ? 0 : (pInvestorPosition.PositionCost /*pInvestorPosition.TodayPosition * pf.TdPosition*/); //} //if (pInvestorPosition.PositionDate == TThostFtdcPositionDateType.THOST_FTDC_PSD_History) //{ // pf.YdPosition = pInvestorPosition.Position; // pf.YdCost = pInvestorPosition.PreSettlementPrice * pf.YdPosition * DicInstrumentField[pf.InstrumentID].VolumeMultiple; // //pf.YdCost = pInvestorPosition.PositionCost / pInvestorPosition.YdPosition * pf.YdPosition; //} pf.Position = g.Sum(n => n.Position); // pf.TdPosition + pf.YdPosition; pf.TdPosition = g.Sum(n => n.TodayPosition); pf.YdPosition = pf.Position - pf.TdPosition; // g.Sum(n => n.YdPosition); pf.Price = pf.Position <= 0 ? 0 : (g.Sum(n => n.PositionCost) / DicInstrumentField[pf.InstrumentID].VolumeMultiple / pf.Position); pf.CloseProfit = g.Sum(n => n.CloseProfit); pf.PositionProfit = g.Sum(n => n.PositionProfit); pf.Commission = g.Sum(n => n.Commission); pf.Margin = g.Sum(n => n.UseMargin); } TradingAccount.CloseProfit = _listPosi.Sum(n => n.CloseProfit); TradingAccount.PositionProfit = _listPosi.Sum(n => n.PositionProfit); TradingAccount.Commission = _listPosi.Sum(n => n.Commission); TradingAccount.Fund = TradingAccount.PreBalance + TradingAccount.CloseProfit + TradingAccount.PositionProfit - TradingAccount.Commission; TradingAccount.FrozenCash = _listPosi.Sum(n => n.FrozenCash); //由查帐户资金函数处理,原因:保证金有单边收的情况无法用持仓统计 //TradingAccount.CurrMargin = _listPosi.Sum(n => n.UseMargin); //TradingAccount.Available = TradingAccount.Fund - TradingAccount.CurrMargin - TradingAccount.FrozenCash; //TradingAccount.Risk = TradingAccount.CurrMargin / TradingAccount.Fund; _listPosi.Clear(); //清除,以便得到结果是重新添加 } }
public override int ReqOrderInsert(string pInstrument, DirectionType pDirection, OffsetType pOffset, double pPrice, int pVolume, int pCustom, OrderType pType = OrderType.Limit, HedgeType pHedge = HedgeType.Speculation) { //限价 var OrderPriceType = TThostFtdcOrderPriceTypeType.THOST_FTDC_OPT_LimitPrice; var TimeCondition = TThostFtdcTimeConditionType.THOST_FTDC_TC_GFD; var VolumeCondition = TThostFtdcVolumeConditionType.THOST_FTDC_VC_AV; if (pType == OrderType.Market) //市价 { OrderPriceType = TThostFtdcOrderPriceTypeType.THOST_FTDC_OPT_AnyPrice; TimeCondition = TThostFtdcTimeConditionType.THOST_FTDC_TC_IOC; //max = instField.MaxMarketOrderVolume; pPrice = 0; } else if (pType == OrderType.FAK) //FAK { OrderPriceType = TThostFtdcOrderPriceTypeType.THOST_FTDC_OPT_LimitPrice; TimeCondition = TThostFtdcTimeConditionType.THOST_FTDC_TC_IOC; } else if (pType == OrderType.FOK) //FOK { OrderPriceType = TThostFtdcOrderPriceTypeType.THOST_FTDC_OPT_LimitPrice; TimeCondition = TThostFtdcTimeConditionType.THOST_FTDC_TC_IOC; VolumeCondition = TThostFtdcVolumeConditionType.THOST_FTDC_VC_CV; //全部数量 } return((int)_t.ReqOrderInsert(_broker, _investor, InstrumentID: pInstrument, OrderRef: string.Format("{0:000000}{1:000000}", _ref++, pCustom % 1000000), CombHedgeFlag: new string((char)(pHedge == HedgeType.Speculation ? TThostFtdcHedgeFlagType.THOST_FTDC_HF_Speculation : pHedge == HedgeType.Arbitrage ? TThostFtdcHedgeFlagType.THOST_FTDC_HF_Arbitrage : TThostFtdcHedgeFlagType.THOST_FTDC_HF_Hedge), 1), CombOffsetFlag: new String((char)(pOffset == OffsetType.Open ? TThostFtdcOffsetFlagType.THOST_FTDC_OF_Open : pOffset == OffsetType.Close ? TThostFtdcOffsetFlagType.THOST_FTDC_OF_Close : TThostFtdcOffsetFlagType.THOST_FTDC_OF_CloseToday), 1), Direction: pDirection == DirectionType.Buy ? TThostFtdcDirectionType.THOST_FTDC_D_Buy : TThostFtdcDirectionType.THOST_FTDC_D_Sell, VolumeTotalOriginal: pVolume, ForceCloseReason: TThostFtdcForceCloseReasonType.THOST_FTDC_FCC_NotForceClose, ContingentCondition: TThostFtdcContingentConditionType.THOST_FTDC_CC_Immediately, VolumeCondition: VolumeCondition, LimitPrice: pPrice, IsSwapOrder: 0, MinVolume: 1, UserForceClose: 0, TimeCondition: TimeCondition, OrderPriceType: OrderPriceType)); }
internal FuzzyCondition(FuzzyVariable var, FuzzyTerm term, bool not, HedgeType hedge) : base(var, term, not) { _hedge = hedge; }
static private List <IExpression> ExtractSingleCondidtions(List <IExpression> conditionExpression, List <FuzzyVariable> input, Dictionary <string, Lexem> lexems) { List <IExpression> copyExpressions = conditionExpression.GetRange(0, conditionExpression.Count); List <IExpression> expressions = new List <IExpression>(); while (copyExpressions.Count > 0) { if (copyExpressions[0] is VarLexem <FuzzyVariable> ) { // // Разбор переменной // VarLexem <FuzzyVariable> varLexem = (VarLexem <FuzzyVariable>)copyExpressions[0]; if (copyExpressions.Count < 3) { throw new Exception(string.Format("Состояние начинается с '{0}' не корректно.", varLexem.Text)); } if (varLexem.Input == false) { throw new Exception("Переменная в состоянии должна быть входной переменной."); } // // Разбор "is" лексемы // Lexem exprIs = (Lexem)copyExpressions[1]; if (exprIs != lexems["is"]) { throw new Exception(string.Format("'is' ключевое слово должно идти после {0} идентификатора.", varLexem.Text)); } // // Разбор 'not' лексемы (если существует) // int cur = 2; bool not = false; if (copyExpressions[cur] == lexems["not"]) { not = true; cur++; if (copyExpressions.Count <= cur) { throw new Exception("Ошибка около 'not' в состоянии части правила."); } } //"slightly" - немного //"somewhat" - в некотором роде //"very" - очень //"extremely" - чрезвычайно // // Разбор hedge модификатора (если существует) // HedgeType hedge = HedgeType.None; if (copyExpressions[cur] == lexems["slightly"]) { hedge = HedgeType.Slightly; } else if (copyExpressions[cur] == lexems["somewhat"]) { hedge = HedgeType.Somewhat; } else if (copyExpressions[cur] == lexems["very"]) { hedge = HedgeType.Very; } else if (copyExpressions[cur] == lexems["extremely"]) { hedge = HedgeType.Extremely; } if (hedge != HedgeType.None) { cur++; if (copyExpressions.Count <= cur) { throw new Exception(string.Format("Ошибка около '{0}' в состоянии части правила.", hedge.ToString().ToLower())); } } // // Разбор терма // Lexem exprTerm = (Lexem)copyExpressions[cur]; if (!(exprTerm is IAltLexem)) { throw new Exception(string.Format("Неверный идентификатор '{0}' в стостоянии части правила.", exprTerm.Text)); } IAltLexem altLexem = (IAltLexem)exprTerm; TermLexem <FuzzyTerm> termLexem = null; do { if (!(altLexem is TermLexem <FuzzyTerm>)) { continue; } termLexem = (TermLexem <FuzzyTerm>)altLexem; if (!varLexem.Var.Values.Contains(termLexem.Term)) { termLexem = null; continue; } }while ((altLexem = altLexem.Alternative) != null && termLexem == null); if (termLexem == null) { throw new Exception(string.Format("Неверный идентификатор '{0}' в стостоянии части правила.", exprTerm.Text)); } // // Добавление нового выражения состояния // FuzzyCondition condition = new FuzzyCondition(varLexem.Var, termLexem.Term, not, hedge); expressions.Add(new ConditionExpression(copyExpressions.GetRange(0, cur + 1), condition)); copyExpressions.RemoveRange(0, cur + 1); } else { IExpression expr = copyExpressions[0]; if (expr == lexems["and"] || expr == lexems["or"] || expr == lexems["("] || expr == lexems[")"]) { expressions.Add(expr); copyExpressions.RemoveAt(0); } else { Lexem unknownLexem = (Lexem)expr; throw new Exception(string.Format("Лексема '{0}' найдена в ошибочном месте в состоянии части правила.", unknownLexem.Text)); } } } return(expressions); }
public int ReqOrderInsert(string pInstrument, DirectionType pDirection, OffsetType pOffset, double pPrice, int pVolume, OrderType pType = OrderType.Limit, int pCustom = 0, HedgeType pHedge = HedgeType.Speculation) { InstrumentField dif; ExchangeStatusType es; //小节收盘:等待重新开盘 if (DicInstrumentField.TryGetValue(pInstrument, out dif)) { if (_initFlow) { pPrice += _floConfig.FirstAddTicks * (pDirection == DirectionType.Buy ? 1 : -1) * dif.PriceTick; } //限定在涨跌板范围内 MarketData f; if (_q == null) { ShowInfo("行情接口异常"); return(-1); } if (!_q.DicTick.TryGetValue(pInstrument, out f)) { _q.ReqSubscribeMarketData(pInstrument); Thread.Sleep(200); } if (!_q.DicTick.TryGetValue(pInstrument, out f)) { ShowInfo($"合约{pInstrument}无行情"); return(-1); } pPrice = Math.Max(f.LowerLimitPrice, Math.Min(f.UpperLimitPrice, pPrice)); //下单前修正价格为最小变动的倍数 pPrice = (int)(pPrice / dif.PriceTick) * dif.PriceTick; if (DicExcStatus.TryGetValue(dif.ProductID, out es) || DicExcStatus.TryGetValue(dif.InstrumentID, out es) || DicExcStatus.TryGetValue(dif.ExchangeID.ToString(), out es)) { if (es == ExchangeStatusType.NoTrading) //小节收盘中:待处理 { ShowInfo($"小节收盘,待重新开盘后再发委托:{pInstrument},{pDirection},{ pOffset},{ pPrice},{ pVolume},{pCustom}"); _listWaitTrading.Add(new object[] { pInstrument, pDirection, pOffset, pPrice, pVolume, pType, pCustom, pHedge }); return(0); } } } return(base.ReqOrderInsert(pInstrument, pDirection, pOffset, pPrice, pVolume, pCustom, pType, pHedge)); }
/// <summary> /// Create a single condition /// </summary> /// <param name="var">A linguistic variable to which the condition is related</param> /// <param name="term">A term in expression 'var is term'</param> /// <param name="not">Does condition contain 'not'</param> /// <param name="hedge">Hedge modifier</param> /// <returns>Generated condition</returns> public FuzzyCondition CreateCondition(FuzzyVariable var, FuzzyTerm term, bool not, HedgeType hedge) { return(new FuzzyCondition(var, term, not, hedge)); }
/// <summary> /// /// </summary> /// <param name="pInstrument"></param> /// <param name="pDirection"></param> /// <param name="pOffset"></param> /// <param name="pPrice"></param> /// <param name="pVolume"></param> /// <param name="pHedge"></param> /// <returns>正确返回0</returns> public int ReqOrderInsert(string pInstrument, DirectionType pDirection, OffsetType pOffset, double pPrice, int pVolume, HedgeType pHedge = HedgeType.Speculation, OrderType pType = OrderType.Limit, string pCustom = "HFapi") { return(_proxy.ReqOrderInsert(pInstrument, pDirection, pOffset, pPrice, pVolume, pHedge, pType, pCustom)); }
/// <summary> /// 委托 /// </summary> /// <param name="pInstrument">合约</param> /// <param name="pDirection">买卖</param> /// <param name="pOffset">开平</param> /// <param name="pPrice">价格</param> /// <param name="pVolume">数量</param> /// <param name="pType">委托类型</param> /// <param name="pCustom">自定义字段(6位数字)</param> /// <param name="pHedge">投保</param> /// <returns></returns> public abstract int ReqOrderInsert(string pInstrument, DirectionType pDirection, OffsetType pOffset, double pPrice, int pVolume, int pCustom, OrderType pType = OrderType.Limit, HedgeType pHedge = HedgeType.Speculation);
private static decimal GetCurrentLevel(ForwardContract contract, HedgeType hedgeType) { return(contract == null ? 0M : hedgeType == HedgeType.Investment ? -contract.Cover : contract.Cover); }
/// <summary> /// /// </summary> /// <param name="pInstrument"></param> /// <param name="pDirection"></param> /// <param name="pOffset"></param> /// <param name="pPrice">价格</param> /// <param name="pVolume"></param> /// <param name="pHedge"></param> /// <param name="pType">报单类型</param> /// <returns></returns> public int ReqOrderInsert(string pInstrument, DirectionType pDirection, OffsetType pOffset, double pPrice, int pVolume, HedgeType pHedge, OrderType pType, string pCustom) { return(((DefReqOrderInsert)Invoke(this._handle, "ReqOrderInsert", typeof(DefReqOrderInsert)))(pInstrument, pDirection, pOffset, pPrice, pVolume, pHedge, pType, pCustom)); }
static private List <IExpression> ExtractSingleCondidtions(List <IExpression> conditionExpression, List <FuzzyVariable> input, Dictionary <string, Lexem> lexems) { List <IExpression> copyExpressions = conditionExpression.GetRange(0, conditionExpression.Count); List <IExpression> expressions = new List <IExpression>(); while (copyExpressions.Count > 0) { if (copyExpressions[0] is VarLexem <FuzzyVariable> ) { // // Parse variable // VarLexem <FuzzyVariable> varLexem = (VarLexem <FuzzyVariable>)copyExpressions[0]; if (copyExpressions.Count < 3) { throw new Exception(string.Format("Condition strated with '{0}' is incorrect.", varLexem.Text)); } if (varLexem.Input == false) { throw new Exception("The variable in condition part must be an input variable."); } // // Parse 'is' lexem // Lexem exprIs = (Lexem)copyExpressions[1]; if (exprIs != lexems["is"]) { throw new Exception(string.Format("'is' keyword must go after {0} identifier.", varLexem.Text)); } // // Parse 'not' lexem (if exists) // int cur = 2; bool not = false; if (copyExpressions[cur] == lexems["not"]) { not = true; cur++; if (copyExpressions.Count <= cur) { throw new Exception("Error at 'not' in condition part of the rule."); } } //"slightly" //"somewhat" //"very" //"extremely" // // Parse hedge modifier (if exists) // HedgeType hedge = HedgeType.None; if (copyExpressions[cur] == lexems["slightly"]) { hedge = HedgeType.Slightly; } else if (copyExpressions[cur] == lexems["somewhat"]) { hedge = HedgeType.Somewhat; } else if (copyExpressions[cur] == lexems["very"]) { hedge = HedgeType.Very; } else if (copyExpressions[cur] == lexems["extremely"]) { hedge = HedgeType.Extremely; } if (hedge != HedgeType.None) { cur++; if (copyExpressions.Count <= cur) { throw new Exception(string.Format("Error at '{0}' in condition part of the rule.", hedge.ToString().ToLower())); } } // // Parse term // Lexem exprTerm = (Lexem)copyExpressions[cur]; if (!(exprTerm is IAltLexem)) { throw new Exception(string.Format("Wrong identifier '{0}' in conditional part of the rule.", exprTerm.Text)); } IAltLexem altLexem = (IAltLexem)exprTerm; TermLexem <FuzzyTerm> termLexem = null; do { if (!(altLexem is TermLexem <FuzzyTerm>)) { continue; } termLexem = (TermLexem <FuzzyTerm>)altLexem; if (!varLexem.Var.Values.Contains(termLexem.Term)) { termLexem = null; continue; } }while ((altLexem = altLexem.Alternative) != null && termLexem == null); if (termLexem == null) { throw new Exception(string.Format("Wrong identifier '{0}' in conditional part of the rule.", exprTerm.Text)); } // // Add new condition expression // FuzzyCondition condition = new FuzzyCondition(varLexem.Var, termLexem.Term, not, hedge); expressions.Add(new ConditionExpression(copyExpressions.GetRange(0, cur + 1), condition)); copyExpressions.RemoveRange(0, cur + 1); } else { IExpression expr = copyExpressions[0]; if (expr == lexems["and"] || expr == lexems["or"] || expr == lexems["("] || expr == lexems[")"]) { expressions.Add(expr); copyExpressions.RemoveAt(0); } else { Lexem unknownLexem = (Lexem)expr; throw new Exception(string.Format("Lexem '{0}' found at the wrong place in condition part of the rule.", unknownLexem.Text)); } } } return(expressions); }
/// <summary> /// /// </summary> /// <param name="pInstrument"></param> /// <param name="pDirection"></param> /// <param name="pOffset"></param> /// <param name="pPrice">价格</param> /// <param name="pVolume"></param> /// <param name="pHedge"></param> /// <param name="pType">报单类型</param> /// <returns></returns> public int ReqOrderInsert(string pInstrument, DirectionType pDirection, OffsetType pOffset, double pPrice, int pVolume, HedgeType pHedge, OrderType pType, string pCustom) { return ((DefReqOrderInsert)Invoke(this._handle, "ReqOrderInsert", typeof(DefReqOrderInsert)))(pInstrument, pDirection, pOffset, pPrice, pVolume, pHedge, pType, pCustom); }
public WallPiece createHedge(int i, int j, HedgeType hedge) { switch(hedge) { case HedgeType.horizontal : {return new WallPiece(i, j, hedgeTexture, Color.Brown, this); } case HedgeType.vertical: { return new WallPiece(i, j, hedgeVertTexture, Color.Brown, this); } case HedgeType.corner_topleft: { return new WallPiece(i, j, hedgeCornerTexturetl, Color.Brown, this); } case HedgeType.corner_topright: { return new WallPiece(i, j, hedgeCornerTexturetr, Color.Brown, this); } case HedgeType.corner_bottomleft: { return new WallPiece(i, j, hedgeCornerTexturebl, Color.Brown, this); } case HedgeType.corner_bottomright: { return new WallPiece(i, j, hedgeCornerTexturebr, Color.Brown, this); } case HedgeType.crisscross: { return new WallPiece(i, j, hedgeCrossTexture, Color.Brown, this); } default: return null; } }