def Canceller(ctx): ctx.volumeStep = 15 return [ ctx.makeTrader_A(strategy.LiquidityProviderSide(side = Side.Sell), "LiquidityProvider-"), ctx.makeTrader_A(strategy.LiquidityProviderEx( orderFactory=order.WithExpiryFactory( expirationDistr=mathutils.constant(1))), "LiquidityProviderEx-"), ctx.makeTrader_A(strategy.LiquidityProviderSide(side = Side.Buy), "LiquidityProviderBuy"), ctx.makeTrader_A( strategy.Array([ strategy.LiquidityProviderSide(side = Side.Sell), strategy.Canceller() ]), label = "LiquidityProviderWithCanceller"), ctx.makeTrader_A( strategy.LiquidityProviderSide( side = Side.Sell, orderFactoryT=order.WithExpiryFactory( expirationDistr=mathutils.constant(10))), "LiquidityProviderWithExpiry"), ctx.makeTrader_A( strategy.FundamentalValue( fundamentalValue = mathutils.constant(1000)), "fv_1000") ]
def TradeIfProfitable(ctx): ctx.volumeStep = 30 alpha_slow = 0.015 alpha_fast = 0.15 slow = lambda: mathutils.ewma(alpha = alpha_slow) fast = lambda: mathutils.ewma(alpha = alpha_fast) linear_signal = signal.RandomWalk(initialValue=200, deltaDistr=const(-1), label="200-t") demo = ctx.addGraph('demo') myVolume = lambda: [(observable.VolumeTraded(), demo)] myAverage = lambda alpha: [(observable.avg(observable.Price(orderbook.OfTrader()), alpha), demo)] avg_plus = strategy.TwoAverages(average1 = slow(), average2 = fast(), creationIntervalDistr = mathutils.constant(1.), volumeDistr = mathutils.constant(1.)) avg_minus = strategy.TwoAverages(average1 = fast(), average2 = slow(), creationIntervalDistr = mathutils.constant(1.), volumeDistr = mathutils.constant(1.)) avg_plus_opt = strategy.TradeIfProfitable(avg_plus) avg_minus_opt = strategy.TradeIfProfitable(avg_minus) return [ ctx.makeTrader_A(strategy.LiquidityProvider(volumeDistr=const(45)), "liquidity"), ctx.makeTrader_A(strategy.Signal(linear_signal, volumeDistr=const(20)), "signal", [(linear_signal, ctx.amount_graph)]), ctx.makeTrader_A(avg_plus, 'avg+', myAverage(alpha_slow) + myAverage(alpha_fast) + myVolume()), ctx.makeTrader_A(avg_minus, 'avg-', myVolume()), ctx.makeTrader_A(avg_plus_opt, 'avg+ opt', myVolume()), ctx.makeTrader_A(avg_minus_opt, 'avg- opt', myVolume()), ]
def FundamentalValue(ctx): ctx.volumeStep = 30 fv = 200 demo = ctx.addGraph('demo') myVolume = lambda: [(observable.VolumeTraded(), demo)] myPrice = lambda: [(observable.Price(orderbook.OfTrader()), demo)] return [ ctx.makeTrader_A( strategy.LiquidityProvider( volumeDistr=mathutils.constant(6), orderFactoryT=order.WithExpiryFactory( expirationDistr=mathutils.constant(10))), "liquidity"), ctx.makeTrader_A( strategy.FundamentalValue( fundamentalValue = mathutils.constant(fv), creationIntervalDistr = mathutils.constant(1.), volumeDistr = mathutils.constant(1)), "fv_200", myVolume() + myPrice() + Constant(fv, demo)), ctx.makeTrader_A( strategy.FundamentalValueEx( fundamentalValue = mathutils.constant(fv), creationIntervalDistr = mathutils.constant(1.), volumeDistr = mathutils.constant(1)), "fv_ex_200", myVolume()) ]
def OnEveryDt(interval, source): """ Creates an indicator that is updated regularly interval - constant interval between updates source - function to obtain indicator value """ return IndicatorBase(scheduler.Timer(mathutils.constant(interval)), source, {"smooth": True})
def __init__(self, world, graph_renderer): self.world = world self.book_A = orderbook.Local(tickSize=0.01, label="A") self.book_B = orderbook.Local(tickSize=0.01, label="B") delay = mathutils.constant(1.07) self.link_A = remote.TwoWayLink(remote.Link(delay), remote.Link(delay)) self.link_B = remote.TwoWayLink(remote.Link(delay), remote.Link(delay)) self.remote_A = orderbook.Remote(self.book_A, self.link_A) self.remote_B = orderbook.Remote(self.book_B, self.link_B) self.graph = graph_renderer self.price_graph = self.graph("Price") self.eff_graph = self.graph("efficiency") self.amount_graph = self.graph("amount") self.balance_graph = self.graph('balance') self.graphs = [ self.price_graph, self.eff_graph, self.amount_graph, self.balance_graph ] self.books = { 'Asset A' : self.book_A , 'Asset B' : self.book_B , 'Remote A': self.remote_A, 'Remote B': self.remote_B }
def Dependency(ctx): liqVol = mathutils.product(mathutils.rnd.expovariate(.1), mathutils.constant(2)) ctx.volumeStep = 70 return [ ctx.makeTrader_A( strategy.LiquidityProvider(defaultValue=50., volumeDistr=liqVol), "LiquidityProvider_A"), ctx.makeTrader_B( strategy.LiquidityProvider(defaultValue=150., volumeDistr=liqVol), "LiquidityProvider_B"), ctx.makeTrader_A(strategy.Dependency(ctx.book_B, factor=2), "A dependent on B"), ctx.makeTrader_B(strategy.Dependency(ctx.book_A, factor=.5), "B dependent on A"), ctx.makeTrader_A(strategy.DependencyEx(ctx.book_B, factor=2), "A dependent on B ex"), ctx.makeTrader_B(strategy.DependencyEx(ctx.book_A, factor=.5), "B dependent on A ex") ]
def SafeSidePrice(orderBook, side, defaultValue): return defs( NotNoneFloat( side_price(_.orderBook, side), NotNoneFloat( last_side_price(_.orderBook, side), mathutils.constant(defaultValue))), { 'orderBook': orderBook })
def Noise(ctx): ctx.volumeStep = 10 return [ ctx.makeTrader_A(strategy.LiquidityProvider( volumeDistr=mathutils.constant(2), orderFactoryT=order.WithExpiryFactory( expirationDistr=mathutils.constant(10))), "liquidity"), ctx.makeTrader_A(strategy.Noise(), "noise"), ctx.makeTrader_A(strategy.Noise( orderFactory = order.AlwaysBestFactory()), "noise_best"), ctx.makeTrader_A(strategy.NoiseEx(), "noise_ex") ]
def MeanReversion(ctx): ctx.volumeStep = 40 alpha = 0.015 V = 1 linear_signal = signal.RandomWalk(initialValue=200, deltaDistr=const(-1), label="200-t") demo = ctx.addGraph('demo') myVolume = lambda: [(observable.VolumeTraded(), demo)] myAverage = lambda: [(observable.avg(observable.Price(orderbook.OfTrader()), alpha), demo)] myPrice = lambda: [(observable.Price(orderbook.OfTrader()), demo)] return [ ctx.makeTrader_A( strategy.LiquidityProvider( volumeDistr=const(V*20), orderFactoryT=order.WithExpiryFactory( expirationDistr=const(10))), label="liquidity"), ctx.makeTrader_A(strategy.Signal(linear_signal, volumeDistr = const(V*3)), "signal", [(linear_signal, ctx.amount_graph)]), ctx.makeTrader_A(strategy.MeanReversion( average=mathutils.ewma(alpha), creationIntervalDistr = mathutils.constant(1.), volumeDistr = const(V)), "meanreversion", myVolume() + myAverage() + myPrice()), ctx.makeTrader_A(strategy.MeanReversionEx( average=mathutils.ewma(alpha), creationIntervalDistr = mathutils.constant(1.), volumeDistr = const(V)), "meanreversion_ex", myVolume()) ]
def TrendFollower(ctx): V = 1 alpha = 0.015 ctx.volumeStep = 30 linear_signal = signal.RandomWalk(initialValue=200, deltaDistr=const(-1), label="200-t") demo = ctx.addGraph('demo') myVolume = lambda: [(observable.VolumeTraded(), demo)] myAverage = lambda alpha: [(observable.avg(observable.Price(orderbook.OfTrader()), alpha), demo)] return [ ctx.makeTrader_A(strategy.LiquidityProvider( volumeDistr=const(V*8), orderFactoryT=order.WithExpiryFactory( expirationDistr=const(100))), label="liquidity"), ctx.makeTrader_A(strategy.Signal(linear_signal, volumeDistr = const(V*2)), "signal", [ (linear_signal, ctx.amount_graph) ]), ctx.makeTrader_A(strategy.TrendFollower( creationIntervalDistr = mathutils.constant(1.), average=mathutils.ewma(alpha), volumeDistr = const(V)), "trendfollower", myVolume() + myAverage(alpha)), ctx.makeTrader_A(strategy.TrendFollowerEx( creationIntervalDistr = mathutils.constant(1.), average=mathutils.ewma(alpha), volumeDistr = const(V)), "trendfollower_ex", myVolume()) ]
def FundamentalValueEx(fundamentalValue = mathutils.constant(100.), orderFactory = order.MarketFactory, volumeDistr = mathutils.rnd.expovariate(1.), creationIntervalDistr = mathutils.rnd.expovariate(1.)): orderBook = orderbook.OfTrader() r = Generic(orderFactory= orderFactory, volumeFunc = volumeDistr, eventGen = scheduler.Timer(creationIntervalDistr), sideFunc = FundamentalValueSide(orderBook, fundamentalValue)) return r
def RSI(ctx): const = mathutils.constant linear_signal = signal.RandomWalk(initialValue=20, deltaDistr=const(-.1), label="20-0.1t") one = mathutils.constant(1) rsi = observable.OnEveryDt(one.value, observable.Fold( observable.Price( orderbook.OfTrader()), mathutils.rsi())) threshold = 30 demo = ctx.addGraph('demo') myVolume = lambda: [(observable.VolumeTraded(), demo)] myRsi = lambda: [(rsi, demo)] alpha = 1./14 myRsiBis = lambda: [(observable.OnEveryDt(1, observable.RSI(orderbook.OfTrader(), 0, alpha)), demo)] return [ ctx.makeTrader_A(strategy.LiquidityProvider(volumeDistr=const(4)), "liquidity"), ctx.makeTrader_A(strategy.Signal(linear_signal), "signal", [(linear_signal, ctx.amount_graph)]), ctx.makeTrader_A(strategy.RSIbis(alpha = alpha, timeframe = 0, threshold=threshold, volumeDistr=one, creationIntervalDistr=one), "rsi_bis", myVolume() + myRsiBis()), ctx.makeTrader_A(strategy.RSIEx(alpha = alpha, threshold=threshold, volumeDistr=one, creationIntervalDistr=one), "rsi_ex", (myVolume() + myRsi() + Constant(threshold, demo) + Constant(100-threshold, demo))) ]
def SignalSide(source, threshold = 0): return defs(ConditionSide( less_float( _.threshold, _.source), ConstantSide(Side.Buy), ConditionSide( less_float( _.source, mathutils.negate(_.threshold)), ConstantSide(Side.Sell), none_side())), { 'source' : source, 'threshold' : mathutils.constant(threshold) })
def RSIbis (timeframe = 0., threshold = 30, alpha = 1./14, orderFactory = order.MarketFactory, volumeDistr = mathutils.rnd.expovariate(1.), creationIntervalDistr = mathutils.rnd.expovariate(1.)): thisBook = orderbook.OfTrader() return defs(Generic(orderFactory = orderFactory, volumeFunc = volumeDistr, eventGen = scheduler.Timer(creationIntervalDistr), sideFunc = SignalSide(mathutils.sub(mathutils.constant(50), _.rsi), 50-threshold)), { 'rsi' : observable.RSI(thisBook, timeframe, alpha) })
def Arbitrage(ctx): liqVol = mathutils.product(mathutils.rnd.expovariate(.1), mathutils.constant(2)) ctx.volumeStep = 70 return [ ctx.makeTrader_A( strategy.LiquidityProvider(defaultValue=50., volumeDistr=liqVol), "LiquidityProvider_A"), ctx.makeTrader_B( strategy.LiquidityProvider(defaultValue=150., volumeDistr=liqVol), "LiquidityProvider_B"), ctx.makeMultiAssetTrader([ctx.remote_A, ctx.remote_B], strategy.Arbitrage(), "Arbitrager") ]
def DependencyEx (bookToDependOn, factor = mathutils.constant(1.), orderFactory = order.MarketFactory, volumeDistr = mathutils.rnd.expovariate(1.)): orderBook = orderbook.OfTrader() r = defs( Generic(orderFactory= orderFactory, volumeFunc = volumeDistr, eventGen = _.dependee, sideFunc = FundamentalValueSide(orderBook, _.dependee)), { 'dependee' : observable.Price(bookToDependOn) }) r._alias = ["Generic", "Dependency"] return r
def __init__(self): self._chooseTheBest = bind.Method(self, '_chooseTheBest_impl') Strategy.__init__(self) # TODO: eventGen should be a parameter self._eventGen = scheduler.Timer(mathutils.constant(1)) def _createInstance(sp): estimator_strategy = self.estimator(sp) estimator = trader.SingleAsset(orderbook.OfTrader(trader.ParentProxy()),estimator_strategy) efficiency = self.efficiency(estimator) return (sp, estimator, estimator_strategy, efficiency) self._strategies = [_createInstance(sp) for sp in self.strategies] self._chooseTheBest = bind.Method(self, '_chooseTheBest_impl') self._current = None event.subscribe(self._eventGen, self._chooseTheBest, self)
def __init__(self): Strategy.__init__(self) # TODO: eventGen should be a parameter self._eventGen = scheduler.Timer(mathutils.constant(1)) def _createInstance(sp): estimator_strategy = self.estimator(sp) estimator = trader.SingleAsset(orderbook.OfTrader(trader.ParentProxy()), estimator_strategy) efficiency = self.efficiency(estimator) return (sp, estimator, estimator_strategy, efficiency) self._strategies = [_createInstance(sp) for sp in self.strategies] self._choose = bind.Method(self, "_choose_impl") self._strategyWeights = self.weight self._current = None # what is the data source for weight update? event.subscribe(self._eventGen, self._choose, self) # suspend all strategies for (s, _, _, _) in self._strategies: s.suspend(True)
def __init__(self, orderFactory = LimitFactory, priceFunc = mathutils.constant(100)): self.orderFactory = orderFactory self.priceFunc = priceFunc
def __init__(self, latency=mathutils.constant(0.001)): """ Initializes the link with a latency function """ self._scheduler = scheduler.current() self.latency = latency self.reset()
def Constant(c, demo): return [(observable.OnEveryDt(10, mathutils.constant(c)), demo)]
def __init__(self, expirationDistr=mathutils.constant(10), orderFactory = LimitFactory): self.expirationDistr = expirationDistr self.orderFactory = orderFactory
def virtualWithUnitVolume(strategy): """ Creates for a *strategy* a clone with same parameters but sending virtual market orders of unit volume """ return strategy.With(volumeDistr=mathutils.constant(1), orderFactory=order.VirtualMarketFactory)
def PriceAtVolume(interval, orderbook, side, volume): return IndicatorBase(scheduler.Timer(mathutils.constant(interval)), price_at_volume(orderbook, side, volume), {'smooth':True, 'fillBelow' : side == Side.Buy, 'fillAbove' : side == Side.Sell})
def VolumeLevels(interval, orderbook, side, volumeDelta, volumeCount): return IndicatorBase(scheduler.Timer(mathutils.constant(interval)), volume_levels(orderbook, side, volumeDelta, volumeCount), {'smooth':True, 'volumeLevels' : True, 'fillBelow' : side == Side.Buy, 'fillAbove' : side == Side.Sell})