量化的不仅是股票、期货、期权、债券等投资交易工具，更是量化自我，量化是人生漫长的修行

量化交易与量化自我

【TWS API 翻译系列】10、IB和TWS API中一些常见的关于订单的算法
作者：yunjinqi   类别：    日期：2022-01-03 22:13:32    阅读：1246 次   消耗积分：0 分    

IB算法

自适应算法

Adaptive Algo将IB的Smartrouting功能与用户定义的优先级设置相结合，以便在执行时进一步的降低成本。使用自适应算法可以比常规的限价单或市价单平均获得更好的执行价格。

参数描述值
适应性优先级"Priority"选择器决定了扫描获得更好的执行价格所需的时间。"Urgent"设置仅进行短暂扫描，而"Patient"扫描工作速度较慢，并且更有可能为您的订单实现更好的整体成交。Urgent>Normal >Patient
baseOrder = OrderSamples.LimitOrder("BUY", 1000, 1)####AvailableAlgoParams.FillAdaptiveParams(baseOrder, "Normal")self.placeOrder(self.nextOrderId(), ContractSamples.USStockAtSmart(), baseOrder)####@staticmethoddef FillAdaptiveParams(baseOrder: Order, priority: str):
    baseOrder.algoStrategy = "Adaptive"
    baseOrder.algoParams = []
    baseOrder.algoParams.append(TagValue("adaptivePriority", priority))

注意："开始时间"和"结束时间"属性中的时区仅在使用格式"hh：mm：ss TMZ"时应用

到达价格

到达价格算法订单类型将尝试在订单过程中实现提交订单时的买入价/卖出价中点。到达价格算法旨在使那些可能会造成很高平均每日交易量（ADV）的订单保持隐藏状态。执行速度由用户分配的风险厌恶级别和用户定义的目标每日平均交易量百分比决定。订单在一天中提交的速度取决于紧急程度：紧急程度越高，执行速度越快，但会使其受到更大的市场影响。通过分配较低的紧迫性可以减轻市场影响，这可能会延长订单的持续时间。用户可以将ADV的最大百分比从1%设置为50%。订单输入屏幕允许用户确定订单的开始和结束时间，而不管订单是否已全部完成。通过选中标记为"允许交易超过结束时间"的框，算法将继续在指定的结束时间之后工作，以完成订单的剩余部分。

参数描述值
最大体积最大ADV百分比0.1 (10%) - 0.5 (50%)
风险规避紧迫性/风险规避Get Done, Aggressive, Neutral, Passive
开始时间算法开始时间hh：mm：ss TMZ 或 YYYYMMDD-hh：mm：ss TMZ
结束时间算法结束时间hh：mm：ss TMZ 或 YYYYMMDD-hh：mm：ss TMZ
allowPastEndTime允许交易超过结束时间1（真）或 0（假）
强制完成尝试在一天结束时完成1（真）或 0（假）
货币价值现金数量
 baseOrder = OrderSamples.LimitOrder("BUY", 1000, 1)
 ###
 AvailableAlgoParams.FillArrivalPriceParams(baseOrder, 0.1, "Aggressive", "09:00:00 CET", "16:00:00 CET", True, True, 100000)self.placeOrder(self.nextOrderId(), ContractSamples.USStockAtSmart(), baseOrder)###@staticmethoddef FillArrivalPriceParams(baseOrder: Order, maxPctVol: float,
                                riskAversion: str, startTime: str, endTime: str,
                                forceCompletion: bool, allowPastTime: bool,
                                monetaryValue: float):
	baseOrder.algoStrategy = "ArrivalPx"
	baseOrder.algoParams = []
	baseOrder.algoParams.append(TagValue("maxPctVol", maxPctVol))
	baseOrder.algoParams.append(TagValue("riskAversion", riskAversion))
	baseOrder.algoParams.append(TagValue("startTime", startTime))
	baseOrder.algoParams.append(TagValue("endTime", endTime))
	baseOrder.algoParams.append(TagValue("forceCompletion",
                                              int(forceCompletion)))
	baseOrder.algoParams.append(TagValue("allowPastEndTime",
                                              int(allowPastTime)))
	baseOrder.algoParams.append(TagValue("monetaryValue", monetaryValue))

收盘价

投资者在收盘竞价中提交市价单或限价盘可能会对收盘价产生不利影响，特别是当买卖订单的交易量相对于平均收盘价成交量较大时。为了帮助投资者在交易时段结束时执行，我们开发了收盘价算法策略。此算法分解大订单量并确定订单输入的时间，以便连续执行以最大程度地减少滑点。执行的开始和速度由用户决定，用户分配市场风险水平并指定交易量的目标百分比，而算法则考虑股票的以前的波动性。

参数描述值
最大体积最大ADV百分比0.1 (10%) - 0.5 (50%)
风险规避紧迫性/风险规避Get Done, Aggressive, Neutral, Passive
开始时间算法开始时间hh：mm：ss TMZ 或 YYYYMMDD-hh：mm：ss TMZ
强制完成尝试在一天结束时完成1（真）或 0（假）
货币价值现金数量
baseOrder = OrderSamples.LimitOrder("BUY", 1000, 1)
###
AvailableAlgoParams.FillClosePriceParams(baseOrder, 0.4, "Neutral", "20180926-06:06:49", True, 100000)
self.placeOrder(self.nextOrderId(), ContractSamples.USStockAtSmart(), baseOrder)
###
@staticmethod
def FillClosePriceParams(baseOrder: Order, maxPctVol: float, riskAversion: str,
                              startTime: str, forceCompletion: bool,
                              monetaryValue: float):
	baseOrder.algoStrategy = "ClosePx"
	baseOrder.algoParams = []
	baseOrder.algoParams.append(TagValue("maxPctVol", maxPctVol))
	baseOrder.algoParams.append(TagValue("riskAversion", riskAversion))
	baseOrder.algoParams.append(TagValue("startTime", startTime))
	baseOrder.algoParams.append(TagValue("forceCompletion", int(forceCompletion)))
	baseOrder.algoParams.append(TagValue("monetaryValue", monetaryValue))

中间价算法

中间价订单旨在分割买入价和卖出价之间的差额，并在NBBO的当前中点或更好处成交。设置可选的价格上限以定义您愿意接受的最高价格（对于买入订单）或最低价格（对于卖出订单）。需要 TWS 975+。仅限Smart-routing到美国股票市场。

  • 产品： 美国股票市场

  • 交易所：仅限Smart-routing

order = Order()order.action = action
order.orderType = "MIDPRICE"order.totalQuantity = quantity
order.lmtPrice = priceCap # optionalself.placeOrder(self.nextOrderId(), ContractSamples.USStockAtSmart(), OrderSamples.Midprice("BUY", 1, 150))

暗冰

Dark Ice订单类型开发了Iceberg或Reserve等订单所采用的隐私概念，使用专有算法进一步隐藏订单向市场显示的交易量。客户可以确定订单保持有效的时间范围，并可以选择在规定的结束时间未完成的情况下允许交易超过结束时间。为了在发生大订单时最大限度地减少市场影响，用户可以指定与实际订单大小不同的显示大小。此外，Dark Ice算法根据价格有利变动的概率随机化显示大小+/- 50%。此外，使用计算的概率，算法决定是将订单置于限价还是比买入订单的当前报价低一个价格变动，以及比卖出订单的当前出价高一个价格变动。

参数描述值
显示大小要显示的订单大小
开始时间算法开始时间hh：mm：ss TMZ 或 YYYYMMDD-hh：mm：ss TMZ
结束时间算法结束时间hh：mm：ss TMZ 或 YYYYMMDD-hh：mm：ss TMZ
allowPastEndTime允许交易超过结束时间1（真）或 0（假）
货币价值现金数量
baseOrder = OrderSamples.LimitOrder("BUY", 1000, 1)
 ###
 AvailableAlgoParams.FillDarkIceParams(baseOrder, 10, "09:00:00 CET", "16:00:00 CET", True, 100000)self.placeOrder(self.nextOrderId(), ContractSamples.USStockAtSmart(), baseOrder)###@staticmethoddef FillDarkIceParams(baseOrder: Order, displaySize: int, startTime: str,
                           endTime: str, allowPastEndTime: bool,
                           monetaryValue: float):
    baseOrder.algoStrategy = "DarkIce"
    baseOrder.algoParams = []
    baseOrder.algoParams.append(TagValue("displaySize", displaySize))
    baseOrder.algoParams.append(TagValue("startTime", startTime))
    baseOrder.algoParams.append(TagValue("endTime", endTime))
    baseOrder.algoParams.append(TagValue("allowPastEndTime",
                                              int(allowPastEndTime)))
    baseOrder.algoParams.append(TagValue("monetaryValue", monetaryValue))

累积/分配

累积/分配算法可以帮助您在不被市场注意到的情况下取得大批量订单的最佳价格，并且可以设置为高频交易。通过将您的订单分割成较小的随机大小的订单增量，这些订单增量在用户定义的时间段内以随机的时间间隔释放，算法允许交易大量的股票和其他品种，而不会在市场上被检测到。算法允许限价单、市价单和相对订单类型。请务必记住，API A/D 算法不会具有可在 TWS 中创建的 A/D 算法的所有可用参数。注意：新字段 activeTimeStart 和 activeTimeEnd 在 TWS 971+ 中使用。以前使用过 startTime 和 endTime。

参数描述值
组件大小增量数量不能超过初始大小
时间介于顺序之间每个订单之间的时间间隔（以秒为单位）
随机时间20随机化时间段 +/- 20%1（真）或 0（假）
随机化大小55按 +/- 55% 随机化大小1（真）或 0（假）
放弃与清算相关的数字
追赶及时赶上1（真）或 0（假）
等待为填充等待当前订单完成，然后再提交下一个订单1（真）或 0（假）
activeTimeStart算法开始时间YYYYMMDD-hh:mm:ss TMZ
活动时间结束算法结束时间YYYYMMDD-hh:mm:ss TMZ

and endTime were used previously.

参数描述值
componentSize增量数量不能超过初始大小
timeBetweenOrders每个订单之间的时间间隔（以秒为单位）
randomizeTime20随机化时间段 +/- 20%1 (true) or 0 (false)
randomizeSize55按 +/- 55% 随机化大小1 (true) or 0 (false)
giveUp与清算相关的数字
catchUp及时赶上1 (true) or 0 (false)
waitForFill等待当前订单完成，然后再提交下一个订单1 (true) or 0 (false)
activeTimeStart算法开始时间YYYYMMDD-hh:mm:ss TMZ
activeTimeEnd算法结束时间YYYYMMDD-hh:mm:ss TMZ
baseOrder = OrderSamples.LimitOrder("BUY", 1000, 1)

###

# The Time Zone in "startTime" and "endTime" attributes is ignored and always defaulted to GMT
AvailableAlgoParams.FillAccumulateDistributeParams(baseOrder, 10, 60, True, True, 1, True, True, "20161010-12:00:00 GMT", "20161010-16:00:00 GMT")
self.placeOrder(self.nextOrderId(), ContractSamples.USStockAtSmart(), baseOrder)

###
@staticmethod
def FillAccumulateDistributeParams(baseOrder: Order, componentSize: int,									                                    timeBetweenOrders: int, randomizeTime20: bool, randomizeSize55: bool,                                        giveUp: int, catchUp: bool, waitForFill: bool, startTime: str,                                              endTime: str):
	baseOrder.algoStrategy = "AD"
	baseOrder.algoParams = []
	baseOrder.algoParams.append(TagValue("componentSize", componentSize))
	baseOrder.algoParams.append(TagValue("timeBetweenOrders", timeBetweenOrders))
	baseOrder.algoParams.append(TagValue("randomizeTime20",
                                              int(randomizeTime20)))
	baseOrder.algoParams.append(TagValue("randomizeSize55",
                                              int(randomizeSize55)))
	baseOrder.algoParams.append(TagValue("giveUp", giveUp))
	baseOrder.algoParams.append(TagValue("catchUp", int(catchUp)))
	baseOrder.algoParams.append(TagValue("waitForFill", int(waitForFill)))
	baseOrder.algoParams.append(TagValue("activeTimeStart", startTime))
	baseOrder.algoParams.append(TagValue("activeTimeEnd", endTime))

交易量百分比

交易量百分比算法可以限制订单对总体平均每日交易量的贡献，以尽量减少影响。客户可以设置 1-50% 之间的值，以控制他们在规定的开始时间和结束时间之间的成交量。当天的订单数量和交易量分布是使用您输入的目标交易量百分比以及根据TWS市场数据计算的持续更新的交易量预测来确定的。此外，可以设置算法以避免吸收流动性，这可能有助于避免流动性接受者费用，并可能导致流动性增加回扣。通过选中"尝试永不采取流动性"框，如果可能的话，不鼓励算法买入价卖出（hitting the bid）或卖出价买入（lifting the offer）。但是，这也可能导致与基准的更大偏差，并导致部分成交，因为随着价格的上涨/下跌，发布的出价/报价可能并不总是会成交。IB将尽最大努力在选中此框时不采取流动性，但是，有时无法避免。

ParameterDescriptionValues
pctVol目标百分比0.1 (10%) - 0.5 (50%)
startTime算法开始时间hh:mm:ss TMZ or YYYYMMDD-hh:mm:ss TMZ
endTime算法结束时间hh:mm:ss TMZ or YYYYMMDD-hh:mm:ss TMZ
noTakeLiq试图永不吸收流动性1 (true) or 0 (false)
monetaryValue现金数量
baseOrder = OrderSamples.LimitOrder("BUY", 1000, 1)
 ###
 AvailableAlgoParams.FillPctVolParams(baseOrder, 0.5, "12:00:00 EST", "14:00:00 EST", True, 100000)self.placeOrder(self.nextOrderId(), ContractSamples.USStockAtSmart(), baseOrder)###@staticmethoddef FillPctVolParams(baseOrder: Order, pctVol: float, startTime: str,
					endTime: str, noTakeLiq: bool,
                    monetaryValue: float):
    baseOrder.algoStrategy = "PctVol"
    baseOrder.algoParams = []
    baseOrder.algoParams.append(TagValue("pctVol", pctVol))
    baseOrder.algoParams.append(TagValue("startTime", startTime))
    baseOrder.algoParams.append(TagValue("endTime", endTime))
    baseOrder.algoParams.append(TagValue("noTakeLiq", int(noTakeLiq)))
    baseOrder.algoParams.append(TagValue("monetaryValue", monetaryValue))

TWAP

TWAP算法旨在实现从您提交订单到完成订单时计算的时间加权平均价格。如果在规定的完成时间结束时未完成的订单，如果选中了"允许交易超过结束时间"框，则将继续填充。用户可以将订单设置为仅在满足指定条件时进行交易。这些用户定义的输入包括当订单可销售时，当中点与所需价格匹配时，当同一方（买入或卖出）匹配以使订单可销售时，或当最后一个交易价格使订单可销售时。对于TWAP算法，平均价格计算是从订单进入时间到市场收盘时间计算的，并且仅在满足标准时才尝试执行。订单可能无法在其规定的期限内完成，因此不能保证订单。TWAP适用于所有美国股票。

ParameterDescriptionValues
strategyType交易策略Marketable, Matching, Midpoint, Matching Same Side, Matching Last
startTime算法开始时间hh:mm:ss TMZ or YYYYMMDD-hh:mm:ss TMZ
endTime算法结束时间hh:mm:ss TMZ or YYYYMMDD-hh:mm:ss TMZ
allowPastEndTime当时间结束是否允许交易1 (true) or 0 (false)
monetaryValue现金量
baseOrder = OrderSamples.LimitOrder("BUY", 1000, 1)### AvailableAlgoParams.FillTwapParams(baseOrder, "Marketable", "09:00:00 CET", "16:00:00 CET", True, 100000)self.placeOrder(self.nextOrderId(), ContractSamples.USStockAtSmart(), baseOrder)###@staticmethoddef FillTwapParams(baseOrder: Order, strategyType: str, startTime: str,
               endTime: str, allowPastEndTime: bool,
               monetaryValue: float):
	baseOrder.algoStrategy = "Twap"
	baseOrder.algoParams = []
	baseOrder.algoParams.append(TagValue("strategyType", strategyType))
	baseOrder.algoParams.append(TagValue("startTime", startTime))
	baseOrder.algoParams.append(TagValue("endTime", endTime))
	baseOrder.algoParams.append(TagValue("allowPastEndTime",                                                                                   int(allowPastEndTime)))
    baseOrder.algoParams.append(TagValue("monetaryValue", monetaryValue))

价格变异量策略的百分比

交易量策略的价格变体百分比- 此算法允许您以用户定义的速率参与交易量，该速率随时间而变化，具体取决于证券的市场价格。此算法允许您在价格较低时更积极地买入，并在价格上涨时更加被动，而卖出订单则恰恰相反。订单处于活动状态期间的订单数量和交易量分布是使用您输入的交易量的目标百分比以及根据TWS市场数据计算的持续更新的交易量预测来确定的。

ParameterDescriptionValues
pctVol目标百分比0.1 (10%) - 0.5 (50%)
deltaPctVol目标百分比变化率0.1 (10%) - 0.5 (50%)
minPctVol4Px最小目标百分比0.1 (10%) - 0.5 (50%)
maxPctVol4Px最大目标百分比0.1 (10%) - 0.5 (50%)
startTime算法开始时间hh:mm:ss TMZ or YYYYMMDD-hh:mm:ss TMZ
endTime算法结束时间hh:mm:ss TMZ or YYYYMMDD-hh:mm:ss TMZ
noTakeLiq试图永不吸收流动性1 (true) or 0 (false)
monetaryValue现金数量
baseOrder = OrderSamples.LimitOrder("BUY", 1000, 1)###AvailableAlgoParams.FillPriceVariantPctVolParams(baseOrder, 0.1, 0.05, 0.01, 0.2, "12:00:00 EST", "14:00:00 EST", True, 100000)self.placeOrder(self.nextOrderId(), ContractSamples.USStockAtSmart(), baseOrder)###@staticmethoddef FillPriceVariantPctVolParams(baseOrder: Order, pctVol: float,
                           deltaPctVol: float, minPctVol4Px: float,
                           maxPctVol4Px: float, startTime: str,
                           endTime: str, noTakeLiq: bool,
                           monetaryValue: float):
	baseOrder.algoStrategy = "PctVolPx"
	baseOrder.algoParams = []
	baseOrder.algoParams.append(TagValue("pctVol", pctVol))
	baseOrder.algoParams.append(TagValue("deltaPctVol", deltaPctVol))
	baseOrder.algoParams.append(TagValue("minPctVol4Px", minPctVol4Px))
	baseOrder.algoParams.append(TagValue("maxPctVol4Px", maxPctVol4Px))
	baseOrder.algoParams.append(TagValue("startTime", startTime))
	baseOrder.algoParams.append(TagValue("endTime", endTime))
	baseOrder.algoParams.append(TagValue("noTakeLiq", int(noTakeLiq)))
	baseOrder.algoParams.append(TagValue("monetaryValue", monetaryValue))

Size Variant Percentage of Volume Strategy

Size Variant Percentage of Volume Strategy - 此算法允许您以用户定义的速率参与交易量，该速率随时间而变化，具体取决于订单的剩余大小。定义开始时间（初始参与率）和结束时间（终端参与率）的目标百分比率，算法根据剩余订单大小计算两者之间一段时间内的参与率。这允许订单最初更具侵略性，而在最后阶段不那么激进，反之亦然。

ParameterDescriptionValues
startPctVol初始目标百分比0.1 (10%) - 0.5 (50%)
endPctVol终端目标百分比0.1 (10%) - 0.5 (50%)
startTime算法开始时间hh:mm:ss TMZ or YYYYMMDD-hh:mm:ss TMZ
endTime算法结束时间hh:mm:ss TMZ or YYYYMMDD-hh:mm:ss TMZ
noTakeLiq试图永不吸收流动性1 (true) or 0 (false)
monetaryValue试图永不吸收流动性
baseOrder = OrderSamples.LimitOrder("BUY", 1000, 1)###AvailableAlgoParams.FillSizeVariantPctVolParams(baseOrder, 0.2, 0.4, "12:00:00 EST", "14:00:00 EST", True, 100000)self.placeOrder(self.nextOrderId(), ContractSamples.USStockAtSmart(), baseOrder)###@staticmethoddef FillSizeVariantPctVolParams(baseOrder: Order, startPctVol: float,
                                endPctVol: float, startTime: str,
                                endTime: str, noTakeLiq: bool,
                                monetaryValue: float):
	baseOrder.algoStrategy = "PctVolSz"
	baseOrder.algoParams = []
	baseOrder.algoParams.append(TagValue("startPctVol", startPctVol))
	baseOrder.algoParams.append(TagValue("endPctVol", endPctVol))
	baseOrder.algoParams.append(TagValue("startTime", startTime))
	baseOrder.algoParams.append(TagValue("endTime", endTime))
	baseOrder.algoParams.append(TagValue("noTakeLiq", int(noTakeLiq)))
	baseOrder.algoParams.append(TagValue("monetaryValue", monetaryValue))

Time Variant Percentage of Volume Strategy

Time Variant Percentage of Volume Strategy - 此算法允许您以用户定义的速率参与交易量，该速率随时间而变化。定义开始时间和结束时间的目标百分比率，算法将计算两者之间随时间变化的参与率。这允许订单最初更具侵略性，而在最后阶段不那么激进，反之亦然。

ParameterDescriptionValues
startPctVol初始目标百分比0.1 (10%) - 0.5 (50%)
endPctVol终端目标百分比0.1 (10%) - 0.5 (50%)
startTime算法开始时间hh:mm:ss TMZ or YYYYMMDD-hh:mm:ss TMZ
endTime算法结束时间hh:mm:ss TMZ or YYYYMMDD-hh:mm:ss TMZ
noTakeLiq试图永不吸收流动性1 (true) or 0 (false)
monetaryValue试图永不吸收流动性
baseOrder = OrderSamples.LimitOrder("BUY", 1000, 1)### AvailableAlgoParams.FillTimeVariantPctVolParams(baseOrder, 0.2, 0.4, "12:00:00 EST", "14:00:00 EST", True, 100000)self.placeOrder(self.nextOrderId(), ContractSamples.USStockAtSmart(), baseOrder)### @staticmethoddef FillTimeVariantPctVolParams(baseOrder: Order, startPctVol: float,
                           endPctVol: float, startTime: str,
                           endTime: str, noTakeLiq: bool,
                           monetaryValue: float):
	baseOrder.algoStrategy = "PctVolSz"
	baseOrder.algoParams = []
	baseOrder.algoParams.append(TagValue("startPctVol", startPctVol))
	baseOrder.algoParams.append(TagValue("endPctVol", endPctVol))
	baseOrder.algoParams.append(TagValue("startTime", startTime))
	baseOrder.algoParams.append(TagValue("endTime", endTime))
	baseOrder.algoParams.append(TagValue("noTakeLiq", int(noTakeLiq)))
	baseOrder.algoParams.append(TagValue("monetaryValue", monetaryValue))

VWAP

IB的 VWAP 算法旨在实现从您提交订单到收盘时计算的成交量加权平均价格（VWAP）.

VWAP算法是保证的VWAP（不再受支持）的低成本替代方案，使用户能够尝试在交易超过结束时间的同时，永远不要采取流动性。由于订单可能不会在买入价或卖出价上成交，因此此算法需要权衡。如果用户试图避免流动性收取费用和/或最大化流动性增加回扣，并且可能通过要求保持出价或要价而错过基准，则订单可能无法完全成交。用户可以确定其订单将包含的每日平均交易量的最大百分比（高达50%）。系统将从输入订单到交易结束的时间生成VWAP，并且订单可以限制在预定的时间段内进行交易。如果在规定期限结束时未填写，用户可以请求订单继续超过其规定的结束时间。VWAP算法适用于所有美国股票。

ParameterDescriptionValues
maxPctVol平均每日交易量的最大百分比0.1 (10%) - 0.5 (50%)
startTime算法开始时间hh:mm:ss TMZ or YYYYMMDD-hh:mm:ss TMZ
endTime算法结束时间hh:mm:ss TMZ or YYYYMMDD-hh:mm:ss TMZ
allowPastEndTime允许交易超过结束时间1 (true) or 0 (false)
noTakeLiq试图永不吸收流动性1 (true) or 0 (false)
speedUp补偿由于存在限制价格而导致的填充率降低1 (true) or 0 (false)
monetaryValue现金数量
baseOrder = OrderSamples.LimitOrder("BUY", 1000, 1)###AvailableAlgoParams.FillVwapParams(baseOrder, 0.2, "09:00:00 CET", "16:00:00 CET", True, True, 100000)self.placeOrder(self.nextOrderId(), ContractSamples.USStockAtSmart(), baseOrder)###@staticmethoddef FillVwapParams(baseOrder: Order, maxPctVol: float, startTime: str,
                        endTime: str, allowPastEndTime: bool, noTakeLiq: bool,
                        monetaryValue: float):
	baseOrder.algoStrategy = "Vwap"
	baseOrder.algoParams = []
	baseOrder.algoParams.append(TagValue("maxPctVol", maxPctVol))
	baseOrder.algoParams.append(TagValue("startTime", startTime))
	baseOrder.algoParams.append(TagValue("endTime", endTime))
	baseOrder.algoParams.append(TagValue("allowPastEndTime",
                                       int(allowPastEndTime)))
	baseOrder.algoParams.append(TagValue("noTakeLiq", int(noTakeLiq)))
	baseOrder.algoParams.append(TagValue("monetaryValue", monetaryValue))

Balance Impact Risk

The Balance Impact Risk 平衡交易期权的市场影响与订单时间范围内价格变化的风险。此策略考虑用户分配的风险厌恶级别，以定义执行速度，以及用户定义的目标交易量百分比。

ParameterDescriptionValues
maxPctVol平均每日交易量的最大百分比0.1 (10%) - 0.5 (50%)
riskAversion紧迫性/风险规避Get Done, Aggressive, Neutral, Passive
forceCompletion尝试在一天结束时完成1 (true) or 0 (false)
baseOrder = OrderSamples.LimitOrder("BUY", 1000, 1)### AvailableAlgoParams.FillBalanceImpactRiskParams(baseOrder, 0.1, "Aggressive", True)self.placeOrder(self.nextOrderId(), ContractSamples.USOptionContract(), baseOrder)###@staticmethoddef FillBalanceImpactRiskParams(baseOrder: Order, maxPctVol: float,
                           riskAversion: str, forceCompletion: bool):
	baseOrder.algoStrategy = "BalanceImpactRisk"
	baseOrder.algoParams = []
	baseOrder.algoParams.append(TagValue("maxPctVol", maxPctVol))
	baseOrder.algoParams.append(TagValue("riskAversion", riskAversion))
	baseOrder.algoParams.append(TagValue("forceCompletion",
                                        int(forceCompletion)))

Minimise Impact

Minimise Impact 算法 通过随时间分割订单来最小化市场影响，从而在不超过给定的最大百分比值的情况下达到市场平均值。

ParameterDescriptionValues
maxPctVol平均每日交易量的最大百分比0.1 (10%) - 0.5 (50%)
baseOrder = OrderSamples.LimitOrder("BUY", 1000, 1)###AvailableAlgoParams.FillMinImpactParams(baseOrder, 0.3)self.placeOrder(self.nextOrderId(), ContractSamples.USOptionContract(), baseOrder)###@staticmethoddef FillMinImpactParams(baseOrder: Order, maxPctVol: float):
	baseOrder.algoStrategy = "MinImpact"
	baseOrder.algoParams = []
	baseOrder.algoParams.append(TagValue("maxPctVol", maxPctVol))

TWS API相关的教程

【TWS API使用教程1】—如何在自己创建的client和TWS之间创建一个连接，并请求当前的时间
【TWS API使用教程2】—如何使用 TWS API在ubuntu和windows上分别设置contract、获取contract详细信息、设置order、下单、获取持仓信息、获取账户信息
【TWS API使用教程3】—如何使用TWS API从盈透证券中设置contract及获取contract的信息？
【TWS API使用教程4】—如何使用TWS API在盈透证券中设置order？
【TWS API使用教程5】—如何使用TWS API在盈透证券中下单(place order)、获取订单信息、获取持仓、获取账户汇总信息?
【TWS API使用教程6】—如何使用TWS API在盈透证券中获取数据?
【TWS API 使用教程7】如何使用TWS API 从盈透证券中筛选满足一定条件的contract？
【TWS API 使用教程8】一个基于TWS API的简单的程序化策略


版权所有，转载本站文章请注明出处：云子量化， http://www.woniunote.com/article/76
上一篇：【TWS API 翻译系列】9、IB和TWS API中的一些高级order
下一篇：【TWS API 翻译系列】11、TWS和IB中的streaming市场数据
人生时间

天 : 20295

小时 : 473553

分钟 : 28413197

秒 : 1704791820

最新文章
最多阅读

版权所有 © 云金杞

京 ICP 备 2021040304号

京公网安备 11010702002337 号

友情链接

CSDN博客    个人知乎   

联系博主

北京★孵化园   微信：tianjixuetu