Esempio n. 1
0
def TwoAveragesEx(
    average1=None,  # mathutils.ewma(alpha = 0.15),
    average2=None,  # mathutils.ewma(alpha = 0.015),
    threshold=0,
    orderFactory=order.MarketFactory,
    creationIntervalDistr=mathutils.rnd.expovariate(1.0),
    volumeDistr=mathutils.rnd.expovariate(1.0),
):

    if average1 is None:
        average1 = mathutils.ewma(alpha=0.15)
    if average2 is None:
        average2 = mathutils.ewma(alpha=0.015)

    return defs(
        Generic(
            orderFactory=orderFactory,
            volumeFunc=volumeDistr,
            eventGen=scheduler.Timer(creationIntervalDistr),
            sideFunc=SignalSide(
                mathutils.sub(observable.Fold(_.price, average1), observable.Fold(_.price, average2)), threshold
            ),
        ),
        {"price": observable.Price(orderbook.OfTrader())},
    )
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 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 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 MeanReversionEx   (average               = mathutils.ewma(alpha = 0.15),
                       orderFactory          = order.MarketFactory, 
                       volumeDistr           = mathutils.rnd.expovariate(1.), 
                       creationIntervalDistr = mathutils.rnd.expovariate(1.)):

    orderBook = orderbook.OfTrader()
    avg = observable.Fold(observable.Price(orderBook), average)
    
    r = Generic(orderFactory= orderFactory, 
                volumeFunc  = volumeDistr, 
                eventGen    = scheduler.Timer(creationIntervalDistr), 
                sideFunc    = FundamentalValueSide(orderBook, avg))
    
    return r
Esempio n. 6
0
def TrendFollowerEx(average                 = None, #mathutils.ewma(alpha = 0.15), 
                    threshold               = 0., 
                    orderFactory            = order.MarketFactory, 
                    creationIntervalDistr   = mathutils.rnd.expovariate(1.), 
                    volumeDistr             = mathutils.rnd.expovariate(1.)):
    
    if average is None:
        average = mathutils.ewma(alpha = 0.15)
    
    orderBook = orderbook.OfTrader()
    trend = observable.Fold(observable.Price(orderBook), 
                            observable.derivative(average))
    
    r = Generic(orderFactory= orderFactory, 
                volumeFunc  = volumeDistr,
                eventGen    = scheduler.Timer(creationIntervalDistr),
                sideFunc    = SignalSide(trend, threshold))
    
    return r
Esempio n. 7
0
def dEWMA(source, alpha=0.15):
    """ Creates a folder with derivative of exponential weighted moving average as accumulator
    alpha - parameter for ewma
    """
    return Fold(source, derivative(mathutils.ewma(alpha)))
Esempio n. 8
0
def Complete(ctx):
    
    ctx.volumeStep = 100

    c_200 = const(200.)
    
    fv_200_12 = strategy.FundamentalValue(fundamentalValue=c_200, volumeDistr=const(12))

    fv_200 = fv_200_12.With(volumeDistr=const(1.))
     
    def s_fv(fv):
        return strategy.TradeIfProfitable(fv_200.With(fundamentalValue=const(fv)))

    def fv_virtual(fv):
        return ctx.makeTrader_A(s_fv(fv), "v" + str(fv))
        
    
    return [
            ctx.makeTrader_A( 
                      strategy.LiquidityProvider(
                            volumeDistr=const(70.), 
                            orderFactoryT=order.WithExpiryFactory(
                                expirationDistr=const(10))), 
                      "liquidity"), 
            
    
            ctx.makeTrader_A(fv_200_12, "t200"),    
            ctx.makeTrader_A(fv_200, "t200_1"),
            ctx.makeTrader_A(fv_200.With(), "t200_2"),
    
            ctx.makeTrader_A(strategy.FundamentalValue(fundamentalValue=const(150.),
                                                       volumeDistr=const(1.)),
                             "t150"),
            
            ctx.makeTrader_A(strategy.MeanReversion(volumeDistr=const(1.)),
                             "mr_0_15"),
    
            ctx.makeTrader_A(strategy.TwoAverages(average1=mathutils.ewma(0.15),
                                                  average2=mathutils.ewma(0.015),
                                                  volumeDistr=const(1.)),
                             label="avg+"),

            ctx.makeTrader_A(strategy.TwoAverages(average1=mathutils.ewma(0.015),
                                                  average2=mathutils.ewma(0.15),
                                                  volumeDistr=const(1.)),
                             label="avg-"),
    
            ctx.makeTrader_A(strategy.TradeIfProfitable(fv_200),
                             "v_fv200"),
            
            fv_virtual(160.),
            fv_virtual(170.),
            fv_virtual(180.),
            fv_virtual(190.),
    
            ctx.makeTrader_A(strategy.ChooseTheBest([
                                               s_fv(160.),
                                               s_fv(170.),
                                               s_fv(180.),
                                               s_fv(190.), 
                                               ]),
                             "best")
    ]