def MeanReversion(ctx):
ctx.volumeStep = 40
alpha = 0.015
V = 1
linear_signal = math.RandomWalk(initialValue=200,
deltaDistr=constant(-1),
name="200-t")
demo = ctx.addGraph('demo')
myVolume = lambda: [(trader.Position(), demo)]
return [
ctx.makeTrader_A(strategy.LiquidityProvider(
orderFactory=order.side_price.WithExpiry(
constant(10), order.side_price.Limit(volume=constant(V *
20)))),
label="liquidity"),
ctx.makeTrader_A(
strategy.Signal(event.Every(constant(1.)),
order.side.Market(volume=constant(V * 3)),
linear_signal), "signal",
[(linear_signal, ctx.amount_graph)]),
ctx.makeTrader_A(
strategy.MeanReversion(event.Every(constant(1.)),
order.side.Market(volume=constant(V)),
alpha), "meanreversion_ex", myVolume()),
]
def TwoAverages(ctx):
ctx.volumeStep = 30
alpha_slow = 0.015
alpha_fast = 0.15
linear_signal = math.RandomWalk(initialValue=200,
deltaDistr=const(-1),
name="200-t")
demo = ctx.addGraph('demo')
myVolume = lambda: [(trader.Position(), demo)]
return [
ctx.makeTrader_A(
strategy.LiquidityProvider(
event.Every(constant(1.)),
order.side_price.Limit(volume=const(10))), "liquidity"),
ctx.makeTrader_A(
strategy.Signal(event.Every(constant(1.)),
order.side.Market(volume=const(3)), linear_signal),
"signal", [(linear_signal, ctx.amount_graph)]),
ctx.makeTrader_A(
strategy.CrossingAverages(event.Every(constant(1.)),
order.side.Market(volume=const(1.)),
alpha_slow, alpha_fast), 'avg_ex+',
myVolume()),
ctx.makeTrader_A(
strategy.CrossingAverages(event.Every(constant(1.)),
order.side.Market(volume=const(1.)),
alpha_fast, alpha_slow), 'avg_ex-',
myVolume()),
]
def TradeIfProfitable(ctx):
ctx.volumeStep = 30
slow_alpha = 0.015
fast_alpha = 0.15
linear_signal = math.RandomWalk(initialValue=200,
deltaDistr=constant(-1),
name="200-t")
demo = ctx.addGraph('demo')
myVolume = lambda: [(trader.Position(), demo)]
myAverage = lambda alpha: [(orderbook.OfTrader().MidPrice.EW_Avg(alpha).
OnEveryDt(1), demo)]
def cross(alpha1, alpha2):
return strategy.CrossingAverages(
event.Every(constant(1.)), order.side.Market(volume=constant(1.)),
alpha1, alpha2)
avg_plus_virt = strategy.TradeIfProfitable(
cross(slow_alpha, fast_alpha), strategy.account.virtualMarket())
avg_minus_virt = strategy.TradeIfProfitable(
cross(fast_alpha, slow_alpha), strategy.account.virtualMarket())
avg_plus_real = strategy.TradeIfProfitable(cross(slow_alpha, fast_alpha),
strategy.account.real())
avg_minus_real = strategy.TradeIfProfitable(cross(fast_alpha, slow_alpha),
strategy.account.real())
return [
ctx.makeTrader_A(
strategy.LiquidityProvider(orderFactory=order.side_price.Limit(
volume=constant(45))), "liquidity"),
ctx.makeTrader_A(
strategy.Signal(event.Every(constant(1.)),
order.side.Market(volume=constant(20)),
linear_signal), "signal",
[(linear_signal, ctx.amount_graph)]),
ctx.makeTrader_A(
cross(slow_alpha, fast_alpha), 'avg+',
myAverage(slow_alpha) + myAverage(fast_alpha) + myVolume()),
ctx.makeTrader_A(cross(fast_alpha, slow_alpha), 'avg-', myVolume()),
ctx.makeTrader_A(avg_plus_virt, 'avg+ virt', myVolume()),
ctx.makeTrader_A(avg_minus_virt, 'avg- virt', myVolume()),
ctx.makeTrader_A(avg_plus_real, 'avg+ real', myVolume()),
ctx.makeTrader_A(avg_minus_real, 'avg- real', myVolume()),
]
def Signal(ctx):
const = constant
linear_signal = math.RandomWalk(initialValue=20,
deltaDistr=const(-.1),
name="20-0.1t")
return [
ctx.makeTrader_A(
strategy.LiquidityProvider(
event.Every(constant(1.)),
order.side_price.Limit(volume=const(5))), "liquidity"),
ctx.makeTrader_A(
strategy.Signal(event.Every(constant(1.)),
order.side.Market(volume=const(1)), linear_signal),
"signal_ex"),
]
def RSI(ctx):
const = constant
linear_signal = math.RandomWalk(initialValue=20,
deltaDistr=const(-.1),
name="20-0.1t")
one = const(1)
threshold = 30
demo = ctx.addGraph('demo')
myVolume = lambda: [(trader.Position(), demo)]
alpha = 1. / 14
myRsiBis = lambda: [(orderbook.OfTrader().RSI(1, alpha).OnEveryDt(1), demo)
]
return [
ctx.makeTrader_A(
strategy.LiquidityProvider(
event.Every(constant(1.)),
order.side_price.Limit(volume=const(4))), "liquidity"),
ctx.makeTrader_A(
strategy.Signal(event.Every(constant(1.)), order.side.Market(),
linear_signal), "signal",
[(linear_signal, ctx.amount_graph)]),
ctx.makeTrader_A(
strategy.RSI_linear(order.signedVolume.MarketSigned(),
alpha=alpha,
timeframe=1), "rsi_linear", myVolume()),
ctx.makeTrader_A(
strategy.RSIbis(event.Every(constant(1.)),
order.side.Market(one),
alpha=alpha,
timeframe=1,
threshold=threshold), "rsi_bis",
myVolume() + myRsiBis()),
]
def Orders(ctx):
linear_signal = math.RandomWalk(initialValue=20,
deltaDistr=const(-.1),
name="20-0.1t")
midPrice = orderbook.MidPrice(ctx.book_A)
return [
ctx.makeTrader_A(
strategy.LiquidityProvider(
event.Every(const(1.)),
order.side_price.Limit(volume=const(35))), "liquidity"),
ctx.makeTrader_A(
strategy.LiquidityProvider(
event.Every(const(100.)),
order.side_price.StopLoss(
const(0.1), order.side_price.Limit(volume=const(5)))),
"liquidity stoploss"),
ctx.makeTrader_A(
strategy.LiquidityProvider(
event.Every(const(10.)),
order.side_price.Iceberg(
order.side_price.Limit(volume=const(5)), const(1))),
"liquidity iceberg"),
ctx.makeTrader_A(
strategy.LiquidityProvider(
event.Every(const(10.)),
order.side_price.WithExpiry(
const(5), order.side_price.Limit(volume=const(5)))),
"liquidity expiry"),
ctx.makeTrader_A(
strategy.LiquidityProvider(
event.Every(const(10.)),
order.side_price.WithExpiry(
const(5),
order.side_price.Iceberg(
order.side_price.Limit(volume=const(15)), const(1)))),
"liquidity iceberg expiry"),
ctx.makeTrader_A(
strategy.Signal(event.Every(const(1.)),
order.side.Market(volume=const(1)), linear_signal),
"signal market"),
ctx.makeTrader_A(
strategy.Signal(
event.Every(const(1.)),
order.side.FloatingPrice(const(100.),
order.side.price.Limit(const(1))),
linear_signal), "signal floating"),
ctx.makeTrader_A(
strategy.Signal(
event.Every(const(1.)),
order.side.Iceberg(order.side.Limit(const(110), const(3)),
const(1)), linear_signal),
"signal iceberg"),
ctx.makeTrader_A(
strategy.Signal(
event.Every(const(1.)),
order.side.ImmediateOrCancel(
order.side.Limit(const(120), const(1))), linear_signal),
"signal ioc"),
ctx.makeTrader_A(
strategy.Signal(event.Every(const(10.)),
order.side.Peg(order.side.price.Limit(const(1))),
linear_signal), "signal peg"),
ctx.makeTrader_A(
strategy.Signal(
event.Every(const(1.)),
order.side.StopLoss(const(0.1),
order.side.Market(volume=const(1))),
linear_signal), "signal stoploss"),
ctx.makeTrader_A(
strategy.Signal(event.Every(const(10.)),
order.side.Limit(price=midPrice, volume=const(1)),
linear_signal), "signal limit"),
ctx.makeTrader_A(
strategy.Signal(
event.Every(const(10)),
order.side.Limit(price=const(120), volume=const(1)),
Interlacing()), "noise limit"),
ctx.makeTrader_A(
strategy.Signal(
event.Every(const(10)),
order.side.WithExpiry(
const(10),
order.side.Limit(price=const(120), volume=const(1))),
Interlacing()), "noise expiry"),
ctx.makeTrader_A(
strategy.Signal(
event.Every(const(10.)),
order.side.Iceberg(
order.side.Peg(order.side.price.Limit(const(1))),
const(1)), Interlacing()), "iceberg peg"),
ctx.makeTrader_A(
strategy.Signal(
event.Every(const(10.)),
order.side.Peg(
order.side.price.Iceberg(order.side.price.Limit(const(3)),
const(1))), Interlacing()),
"peg iceberg"),
ctx.makeTrader_A(
strategy.Signal(
event.Every(constant(3.)),
order.side.WithExpiry(
constant(3.),
order.side.Peg(
order.side.price.Iceberg(
order.side.price.Limit(const(3)), const(1)))),
Interlacing()), "peg iceberg expiry"),
ctx.makeTrader_A(
strategy.Signal(
event.Every(constant(10.)),
order.side.WithExpiry(
constant(10.),
order.side.Iceberg(
order.side.Peg(order.side.price.Limit(const(1))),
const(1))), Interlacing()), "iceberg peg expiry"),
]