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 Ladder(ctx):
const = constant
linear_signal = math.RandomWalk(initialValue=10,
deltaDistr=const(-.1),
name="20-0.1t")
return [
ctx.makeTrader_A(
strategy.price.LiquidityProvider().Strategy(
orderFactory=order.side_price.Limit(
volume=const(10.)).sideprice_WithExpiry(const(50.))),
"liquidity"),
ctx.makeTrader_A(
order.side_price.Limit(volume=const(1.))
# .sideprice_Iceberg(lotSize=const(1))
.LadderMM(initialSize=10).LadderBalancer(maximalSize=10).StopLoss(
lossFactor=constant(0.03)).Suspend(CurrentTime() < 30).Suspend(
(300 < CurrentTime()).And(CurrentTime() < 350)),
"ladder mm"),
ctx.makeTrader_A(
strategy.side.Signal(linear_signal).Strategy(
event.Every(constant(1.)), order.side.Market(const(4))),
"signal"),
]
def Arbitrage(ctx):
liqVol = math.random.expovariate(.1) * 2.
ctx.volumeStep = 70
return [
ctx.makeTrader_A(
strategy.LiquidityProvider(
orderFactory=order.side_price.WithExpiry(
constant(50.), order.side_price.Limit(volume=liqVol)),
initialValue=50.), "LiquidityProvider_A"),
ctx.makeTrader_B(
strategy.LiquidityProvider(
orderFactory=order.side_price.WithExpiry(
constant(50.), order.side_price.Limit(volume=liqVol)),
initialValue=150.), "LiquidityProvider_B"),
ctx.makeTrader_C(
strategy.LiquidityProvider(
orderFactory=order.side_price.WithExpiry(
constant(50), order.side_price.Limit(volume=liqVol)),
initialValue=100.), "LiquidityProvider_C"),
ctx.makeMultiAssetTrader([ctx.remote_A, ctx.remote_B, ctx.remote_C],
strategy.Arbitrage(), "Arbitrager")
]
def Dependency(ctx):
liqVol = constant(3)
ctx.volumeStep = 70
return [
ctx.makeTrader_A(
strategy.LiquidityProvider(event.Every(constant(1.)),
order.side_price.Limit(volume = liqVol),
initialValue=50.),
"LiquidityProvider_A"),
ctx.makeTrader_B(
strategy.LiquidityProvider(event.Every(constant(1.)),
order.side_price.Limit(volume = liqVol),
initialValue=150.),
"LiquidityProvider_B"),
ctx.makeTrader_A(
strategy.PairTrading(
event.Every(constant(1.)),
order.side.Market(),
ctx.book_B,
factor=2.),
"A dependent on B ex"),
ctx.makeTrader_B(
strategy.PairTrading(
event.Every(constant(1.)),
order.side.Market(),
ctx.book_A,
factor=.5),
"B dependent on A ex"),
]
def Dependency(ctx):
liqVol = constant(3)
ctx.volumeStep = 70
return [
ctx.makeTrader_A(
strategy.LiquidityProvider(event.Every(constant(1.)),
order.side_price.Limit(volume=liqVol),
initialValue=50.),
"LiquidityProvider_A"),
ctx.makeTrader_B(
strategy.LiquidityProvider(event.Every(constant(1.)),
order.side_price.Limit(volume=liqVol),
initialValue=150.),
"LiquidityProvider_B"),
ctx.makeTrader_A(
strategy.PairTrading(event.Every(constant(1.)),
order.side.Market(),
ctx.book_B,
factor=2.), "A dependent on B ex"),
ctx.makeTrader_B(
strategy.PairTrading(event.Every(constant(1.)),
order.side.Market(),
ctx.book_A,
factor=.5), "B dependent on A ex"),
]
def Arbitrage(ctx):
liqVol = math.random.expovariate(.1) * 2.
ctx.volumeStep = 70
return [
ctx.makeTrader_A(
strategy.LiquidityProvider(
orderFactory = order.side_price.WithExpiry(constant(50.),
order.side_price.Limit(volume=liqVol)),
initialValue= 50.),
"LiquidityProvider_A"),
ctx.makeTrader_B(
strategy.LiquidityProvider(
orderFactory = order.side_price.WithExpiry(constant(50.),
order.side_price.Limit(volume=liqVol)),
initialValue = 150.),
"LiquidityProvider_B"),
ctx.makeTrader_C(
strategy.LiquidityProvider(
orderFactory = order.side_price.WithExpiry(constant(50),
order.side_price.Limit(volume=liqVol)),
initialValue = 100.),
"LiquidityProvider_C"),
ctx.makeMultiAssetTrader([ctx.remote_A, ctx.remote_B, ctx.remote_C],
strategy.Arbitrage(),
"Arbitrager")
]
def TrendFollower(ctx):
V = 1
alpha = 0.015
ctx.volumeStep = 30
linear_signal = math.RandomWalk(initialValue=200,
deltaDistr=const(-1),
name="200-t")
demo = ctx.addGraph('demo')
myVolume = lambda: [(orderbook.OfTrader().MidPrice, demo),
(trader.Position(), demo),
(orderbook.OfTrader().MidPrice.EW().Avg.OnEveryDt(1),
demo)]
return [
ctx.makeTrader_A(strategy.price.LiquidityProvider().Strategy(
orderFactory=order.side_price.Limit(
volume=constant(V * 8)).sideprice_WithExpiry(constant(100))),
label="liquidity"),
ctx.makeTrader_A(
strategy.side.Signal(linear_signal).Strategy(
event.Every(constant(1.)), order.side.Market(const(V * 3))),
"signal", [(linear_signal, ctx.amount_graph)]),
ctx.makeTrader_A(
strategy.side.TrendFollower(alpha).Strategy(
event.Every(constant(1.)), order.side.Market(volume=const(V))),
"trendfollower_ex", myVolume()),
]
def ChooseTheBest(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(alpha).Avg.OnEveryDt(1), demo)]
def cross(alpha1, alpha2):
return strategy.side.CrossingAverages(alpha1, alpha2)\
.Strategy(event.Every(constant(1.)),
order.side.Market(volume = constant(1.)))
def strategies():
return [cross(slow_alpha, fast_alpha), cross(fast_alpha, slow_alpha)]
return [
ctx.makeTrader_A(
strategy.price.LiquidityProvider()
.Strategy(orderFactory = order.side_price.Limit(volume=constant(45))),
"liquidity"),
ctx.makeTrader_A(strategy.side.Signal(linear_signal)
.Strategy(event.Every(constant(1.)),
order.side.Market(volume = constant(20))),
"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(strategy.ChooseTheBest(
strategies(),
strategy.account.virtualMarket()),
'best virt',
myVolume()),
ctx.makeTrader_A(strategy.ChooseTheBest(
strategies(),
strategy.account.real()),
'best real',
myVolume()),
]
def Noise(ctx):
ctx.volumeStep = 10
return [
ctx.makeTrader_A(
strategy.LiquidityProvider(
orderFactory=order.side_price.WithExpiry(
constant(10), order.side_price.Limit(volume=constant(2)))),
"liquidity"),
ctx.makeTrader_A(strategy.Noise(), "noise_ex"),
]
def Noise(ctx):
ctx.volumeStep = 10
return [
ctx.makeTrader_A(
strategy.price.LiquidityProvider()
.Strategy(orderFactory =
order.side_price.Limit(volume=constant(2))
.sideprice_WithExpiry(constant(10))),
"liquidity"),
ctx.makeTrader_A(strategy.side.Noise().Strategy(), "noise_ex"),
]
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.price.LiquidityProvider().Strategy(
event.Every(constant(1.)),
order.side_price.Limit(volume=const(5))), "liquidity"),
ctx.makeTrader_A(
strategy.side.Signal(linear_signal).Strategy(
event.Every(constant(1.)), order.side.Market(const(1))),
"signal"),
]
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 ChooseTheBest(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(alpha).Avg.
OnEveryDt(1), demo)]
def cross(alpha1, alpha2):
return strategy.side.CrossingAverages(alpha1, alpha2)\
.Strategy(event.Every(constant(1.)),
order.side.Market(volume = constant(1.)))
def strategies():
return [cross(slow_alpha, fast_alpha), cross(fast_alpha, slow_alpha)]
return [
ctx.makeTrader_A(
strategy.price.LiquidityProvider().Strategy(
orderFactory=order.side_price.Limit(volume=constant(45))),
"liquidity"),
ctx.makeTrader_A(
strategy.side.Signal(linear_signal).Strategy(
event.Every(constant(1.)),
order.side.Market(volume=constant(20))), "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(
strategy.ChooseTheBest(strategies(),
strategy.account.virtualMarket()),
'best virt', myVolume()),
ctx.makeTrader_A(
strategy.ChooseTheBest(strategies(), strategy.account.real()),
'best real', myVolume()),
]
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() / 3, demo),
(orderbook.OfTrader().MidPrice.EW(alpha).Avg.OnEveryDt(
1), demo),
(orderbook.OfTrader().Asks.BestPrice, demo),
(orderbook.OfTrader().Bids.BestPrice, demo)]
return [
ctx.makeTrader_A(strategy.price.LiquidityProvider(
initialValue=30.).Strategy(orderFactory=order.side_price.Limit(
volume=constant(V * 20)).sideprice_WithExpiry(constant(10))),
label="liquidity"),
ctx.makeTrader_A(
strategy.side.Noise().Strategy(
event.Every(constant(1.)),
order.side.Market(volume=constant(V * 3))), "signal",
[(linear_signal, ctx.amount_graph)]),
ctx.makeTrader_A(
strategy.side.MeanReversion(alpha).Strategy(
event.Every(constant(1.)),
order.side.Market(volume=constant(V))), "meanreversion_ex",
myVolume()),
]
def Dependency(ctx):
V = 1
alpha = 0.015
ctx.volumeStep = 30
const = constant
linear_signal = math.RandomWalk(initialValue=200,
deltaDistr=const(-1),
name="200-t")
demo = ctx.addGraph('demo')
myVolume = lambda: [(orderbook.OfTrader().MidPrice, demo),
(trader.Position(), demo),
(orderbook.OfTrader().MidPrice.EW().Avg.OnEveryDt(1), demo)]
return [
ctx.makeTrader_A(
strategy.price.LiquidityProvider(100.)
.Strategy(orderFactory =
order.side_price.Limit(volume=constant(V*8)).sideprice_WithExpiry(constant(100))),
label="liquidity"),
ctx.makeTrader_B(
strategy.price.LiquidityProvider(200.)
.Strategy(orderFactory =
order.side_price.Limit(volume=constant(V*8)).sideprice_WithExpiry(constant(100))),
label="liquidity B"),
ctx.makeTrader_A(strategy.side.Signal(linear_signal)
.Strategy(event.Every(constant(1.)),
order.side.Market(const(V*3))),
"signal",
[
(linear_signal, ctx.amount_graph),
]),
ctx.makeTrader_B(
strategy.side.PairTrading(
ctx.book_A,
factor=2.
).Strategy(event.Every(constant(1.)),
order.side.Market(const(V*5))),
"B dependent on A ex"),
]
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: [(orderbook.OfTrader().MidPrice, demo),
(trader.Position() / const(10.), demo),
(orderbook.OfTrader().MidPrice.EW(alpha_fast).Avg.OnEveryDt(1), demo),
(orderbook.OfTrader().MidPrice.EW(alpha_slow).Avg.OnEveryDt(1), demo)]
return [
ctx.makeTrader_A(
strategy.price.LiquidityProvider(initialValue=10.)
.Strategy(
event.Every(constant(1.)),
order.side_price.Limit(volume=const(10))),
"liquidity"),
ctx.makeTrader_A(strategy.side.Signal(linear_signal)
.Strategy(event.Every(constant(1.)),
order.side.Market(volume = const(3))),
"signal",
[(linear_signal, ctx.amount_graph)]),
ctx.makeTrader_A(strategy.side.CrossingAverages(alpha_slow,
alpha_fast)
.Strategy(event.Every(constant(1.)),
order.side.Market(volume = const(1.))),
'avg_ex+',
myVolume()),
ctx.makeTrader_A(strategy.side.CrossingAverages(alpha_fast,
alpha_slow)
.Strategy(event.Every(constant(1.)),
order.side.Market(volume = const(1.))),
'avg_ex-',
myVolume()),
]
def Signal(ctx):
const = constant
linear_signal = math.RandomWalk(initialValue=20,
deltaDistr=const(-.1),
name="20-0.1t")
return [
ctx.makeTrader_A(
strategy.price.LiquidityProvider()
.Strategy(event.Every(constant(1.)),
order.side_price.Limit(volume=const(5))),
"liquidity"),
ctx.makeTrader_A(strategy.side.Signal(linear_signal)
.Strategy(event.Every(constant(1.)),
order.side.Market(const(1))),
"signal"),
]
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 TrendFollower(ctx):
V = 1
alpha = 0.015
ctx.volumeStep = 30
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(
orderFactory = order.side_price.WithExpiry(
constant(100),
order.side_price.Limit(volume=constant(V*8)))),
label="liquidity"),
ctx.makeTrader_A(strategy.Signal(event.Every(constant(1.)),
order.side.Market(const(V*2)),
linear_signal),
"signal",
[
(linear_signal, ctx.amount_graph)
]),
ctx.makeTrader_A(strategy.TrendFollower(
event.Every(constant(1.)),
order.side.Market(volume = const(V)),
alpha),
"trendfollower_ex",
myVolume()),
]
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() / 3, demo),
(orderbook.OfTrader().MidPrice.EW(alpha).Avg.OnEveryDt(1), demo),
(orderbook.OfTrader().Asks.BestPrice, demo),
(orderbook.OfTrader().Bids.BestPrice, demo)]
return [
ctx.makeTrader_A(
strategy.price.LiquidityProvider(initialValue=30.)
.Strategy(orderFactory =
order.side_price.Limit(volume=constant(V*20))
.sideprice_WithExpiry(constant(10))),
label="liquidity"),
ctx.makeTrader_A(strategy.side.Noise()
.Strategy(event.Every(constant(1.)),
order.side.Market(volume = constant(V*3))),
"signal",
[(linear_signal, ctx.amount_graph)]),
ctx.makeTrader_A(
strategy.side.MeanReversion(
alpha
).Strategy(
event.Every(constant(1.)),
order.side.Market(volume = constant(V))),
"meanreversion_ex",
myVolume()),
]
def cross(alpha1, alpha2):
return strategy.side.CrossingAverages(alpha1, alpha2)\
.Strategy(event.Every(constant(1.)),
order.side.Market(volume = constant(1.)))
def fv(x):
return strategy.FundamentalValue(
event.Every(constant(1.)),
order.side.Market(volume=constant(1.)),
fundamentalValue=const(x))
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 makeLP(dv):
return (
strategy.price.LiquidityProvider(initialValue= dv)
.Strategy(orderFactory = order.side_price.Limit(volume=liqVol)
.sideprice_WithExpiry(constant(50))))
def cross(alpha1, alpha2):
return strategy.CrossingAverages(
event.Every(constant(1.)), order.side.Market(volume=constant(1.)),
alpha1, alpha2)
def makeLP(dv):
return (strategy.price.LiquidityProvider(initialValue=dv).Strategy(
orderFactory=order.side_price.Limit(
volume=liqVol).sideprice_WithExpiry(constant(50))))
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.price.LiquidityProvider().Strategy(
event.Every(const(1.)),
order.side_price.Limit(volume=const(35))), "liquidity"),
ctx.makeTrader_A(
strategy.price.LiquidityProvider().Strategy(
event.Every(const(100.)),
order.side_price.Limit(volume=const(5)).sideprice_StopLoss(
const(0.1))), "liquidity stoploss"),
ctx.makeTrader_A(
strategy.price.LiquidityProvider().Strategy(
event.Every(const(10.)),
order.side_price.Limit(volume=const(5)).sideprice_Iceberg(
const(1))), "liquidity iceberg"),
ctx.makeTrader_A(
strategy.price.LiquidityProvider().Strategy(
event.Every(const(10.)),
order.side_price.Limit(volume=const(5)).sideprice_WithExpiry(
const(5))), "liquidity expiry"),
ctx.makeTrader_A(
strategy.price.LiquidityProvider().Strategy(
event.Every(const(10.)),
order.side_price.Limit(volume=const(15)).sideprice_Iceberg(
const(1)).sideprice_WithExpiry(const(5))),
"liquidity iceberg expiry"),
ctx.makeTrader_A(
strategy.side.Signal(linear_signal).Strategy(
event.Every(const(1.)), order.side.Market(volume=const(1))),
"signal market"),
ctx.makeTrader_A(
strategy.side.Signal(linear_signal).Strategy(
event.Every(const(1.)),
order.side.price.Limit(const(1)).side_FloatingPrice(
const(100))), "signal floating"),
ctx.makeTrader_A(
strategy.side.Signal(linear_signal).Strategy(
event.Every(const(1.)),
order.side.Limit(const(110), const(3)).side_Iceberg(const(1))),
"signal iceberg"),
ctx.makeTrader_A(
strategy.side.Signal(linear_signal).Strategy(
event.Every(const(1.)),
order.side.Limit(const(120), const(1)).side_ImmediateOrCancel),
"signal ioc"),
ctx.makeTrader_A(
strategy.side.Signal(linear_signal).Strategy(
event.Every(const(10.)),
order.side.price.Limit(const(1)).side_Peg), "signal peg"),
ctx.makeTrader_A(
strategy.side.Signal(linear_signal).Strategy(
event.Every(const(1.)),
order.side.Market(volume=const(1)).side_StopLoss(const(0.1))),
"signal stoploss"),
ctx.makeTrader_A(
strategy.side.Signal(linear_signal).Strategy(
event.Every(const(10.)),
order.side.Limit(price=midPrice, volume=const(1))),
"signal limit"),
ctx.makeTrader_A(
strategy.side.Signal(Interlacing()).Strategy(
event.Every(const(10)),
order.side.Limit(price=const(120), volume=const(1))),
"noise limit"),
ctx.makeTrader_A(
strategy.side.Signal(Interlacing()).Strategy(
event.Every(const(10)),
order.side.Limit(price=const(120),
volume=const(1)).side_WithExpiry(const(10))),
"noise expiry"),
ctx.makeTrader_A(
strategy.side.Signal(Interlacing()).Strategy(
event.Every(const(10.)),
order.side.price.Limit(const(1)).side_Peg.side_Iceberg(
const(1))), "iceberg peg"),
ctx.makeTrader_A(
strategy.side.Signal(Interlacing()).Strategy(
event.Every(const(10.)),
order.side.price.Limit(const(3)).side_price_Iceberg(
const(1)).side_Peg), "peg iceberg"),
ctx.makeTrader_A(
strategy.side.Signal(Interlacing()).Strategy(
event.Every(constant(3.)),
order.side.price.Limit(const(3)).side_price_Iceberg(
const(1)).side_Peg.side_WithExpiry(const(3))),
"peg iceberg expiry"),
ctx.makeTrader_A(
strategy.side.Signal(Interlacing()).Strategy(
event.Every(constant(10.)),
order.side.price.Limit(const(1)).side_Peg.side_Iceberg(
const(1)).side_WithExpiry(const(10.))),
"iceberg peg expiry"),
]
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"),
]
def MultiarmedBandit(ctx):
ctx.volumeStep = 30
demo = ctx.addGraph('demo')
myVolume = lambda: [(trader.Position(), demo)]
def fv(x):
return strategy.FundamentalValue(
event.Every(constant(1.)),
order.side.Market(volume=constant(1.)),
fundamentalValue=const(x))
xs = range(100, 300, 50) + range(160, 190, 10)
def strategies():
return map(fv, xs)
def fv_traders():
return [ctx.makeTrader_A(fv(x), "fv" + str(x), myVolume()) for x in xs]
return [
ctx.makeTrader_A(
strategy.LiquidityProvider(orderFactory=order.side_price.Limit(
volume=constant(45))), "liquidity"),
ctx.makeTrader_A(
strategy.FundamentalValue(event.Every(constant(1.)),
order.side.Market(volume=constant(12.)),
fundamentalValue=const(200)),
'fv 12-200'),
ctx.makeTrader_A(
strategy.MultiArmedBandit(
strategies(), strategy.account.virtualMarket(),
strategy.weight.efficiencyTrend()), 'virt trend', myVolume()),
ctx.makeTrader_A(
strategy.MultiArmedBandit(strategies(), strategy.account.real(),
strategy.weight.efficiencyTrend()),
'real trend', myVolume()),
ctx.makeTrader_A(
strategy.MultiArmedBandit(
strategies(), strategy.account.virtualMarket(),
strategy.weight.efficiency()), 'virt efficiency', myVolume()),
ctx.makeTrader_A(
strategy.MultiArmedBandit(strategies(), strategy.account.real(),
strategy.weight.efficiency()),
'real efficiency', myVolume()),
ctx.makeTrader_A(
strategy.MultiArmedBandit(
strategies(), strategy.account.virtualMarket(),
strategy.weight.score(), strategy.weight.atanPow()),
'virt score', myVolume()),
ctx.makeTrader_A(
strategy.MultiArmedBandit(
strategies(), strategy.account.real(), strategy.weight.score(),
strategy.weight.clamp0()), 'real score', myVolume()),
ctx.makeTrader_A(
strategy.MultiArmedBandit(
strategies(), strategy.account.virtualMarket(),
strategy.weight.efficiencyTrend(), strategy.weight.identityF(),
strategy.weight.chooseTheBest()), 'virt best', myVolume()),
ctx.makeTrader_A(
strategy.MultiArmedBandit(
strategies(), strategy.account.real(), strategy.weight.unit(),
strategy.weight.identityF()), 'uniform', myVolume()),
] + fv_traders()
