Posts made by Paul Park

class scale(bt.Indicator):
    lines = ('output',)
    params = (('value', 5),)

    def __init__(self):
        self.h = btind.Highest(self.data, period=252)
        self.l = btind.Lowest(self.data, period=252)
        self.min = .2
        self.max = .8
    def next(self):
        self.lines.output[0] = (((self.max-self.min)* (self.data-self.l))/(self.h-self.l))+ self.min
class gamma1(bt.Indicator):
    lines = ('energy',)

    params = (('value', 5),)
    
    def __init__(self):
        self.o = (self.data.open+self.data.close[-1])/2
        self.h = bt.If(self.data.high  > self.data.close(-1),self.data.high, self.data.close(-1))
        self.l = bt.If(self.data.low  < self.data.close(-1),self.data.low, self.data.close(-1))
        self.c = (self.o+self.h+self.l+self.data.close)/4
        self.m  = bt.If(self.h > self.c(-1), self.h, self.c(-1))
        self.n = bt.If(self.l < self.c(-1), self.l, self.c(-1))
        self.a = self.m - self.n
        self.b = btind.SumN(self.a, period=3)
        self.hl = btind.Highest(self.h, period=3)-btind.Lowest(self.l, period=3)
        
        
    def next(self):
        z = self.b[0]/self.hl[0]
        y = math.log(z,10)
        r = math.log(10, 10)
        g = y/r
        #k = bt.DivByZero(y,r)
        self.lines.energy[0] = g/(math.log(3,10)/ math.log(10,10))
class gamma3(bt.Indicator):
    lines = ('energy',)

    params = (('value', 5),)
    
    def __init__(self):
        self.o = (self.data.open+self.data.close[-1])/2
        self.h = bt.If(self.data.high  > self.data.close(-1),self.data.high, self.data.close(-1))
        self.l = bt.If(self.data.low  < self.data.close(-1),self.data.low, self.data.close(-1))
        self.c = (self.o+self.h+self.l+self.data.close)/4
        self.m  = bt.If(self.data.high > self.data.close(-1), self.data.high, self.data.close(-1))
        self.n = bt.If(self.data.low < self.data.close(-1), self.data.low, self.data.close(-1))
        self.a = self.m - self.n
        self.b = btind.SumN(self.a, period=8)
        self.hl = btind.Highest(self.data.high, period=8)-btind.Lowest(self.data.low, period=8)
        
        
    def next(self):
        z = self.b[0]/self.hl[0]
        y = math.log(z,10)
        r = math.log(8, 10)
        #k = bt.DivByZero(y,r)
        self.lines.energy[0] = y/r
class CLaguerreRSI(bt.Indicator):
    alias = ('CLRSI',)
    lines = ('lrsi',)
    params = (('e', 0.5),)

    plotinfo = dict(
        plotymargin=0.15,
        plotyticks=[0.0, 0.2, 0.5, 0.8, 1.0]
    )
    def __init__(self):
        self.addminperiod(6)
        self.l0 = [0, 0]
        self.l1 = [0, 0]
        self.l2 = [0, 0]
        self.l3 = [0, 0]
        self.gamma2 = gamma1(self.data)
        self.gamma = scale(self.gamma2.energy(0))
        self.practicegamma = gamma3(self.data)
        self.o = (self.data.open+self.data.close[-1])/2
        self.h = bt.If(self.data.high  > self.data.close(-1),self.data.high, self.data.close(-1))
        self.l = bt.If(self.data.low  < self.data.close(-1),self.data.low, self.data.close(-1))
        self.c = (self.o+self.h+self.l+self.data.close)/4
        super(CLaguerreRSI, self).__init__()

    def next(self):
        self.l0.insert(0, ((1 - self.gamma.output[0]) * self.c +
                           self.gamma.output[0] * self.l0[0]))
        self.l1.insert(0, (-self.gamma.output[0] * self.l0[0] + self.l0[1] +
                           self.gamma.output[0] * self.l1[0]))
        self.l2.insert(0, (-self.gamma.output[0] * self.l1[0] + self.l1[1] +
                           self.gamma.output[0] * self.l2[0]))
        self.l3.insert(0, (-self.gamma.output[0] * self.l2[0] + self.l2[1] +
                           self.gamma.output[0] * self.l3[0]))
        del self.l0[2:]
        del self.l1[2:]
        del self.l2[2:]
        del self.l3[2:]
        cd = 0
        cu = 0
        if self.l0[0] >= self.l1[0]:
            cu = self.l0[0] - self.l1[0]
        else:
            cd = self.l1[0] - self.l0[0]

        if self.l1[0] >= self.l2[0]:
            cu = cu + self.l1[0] - self.l2[0]
        else:
            cd = cd + self.l2[0] - self.l1[0]

        if self.l2[0] >= self.l3[0]:
            cu = cu + self.l2[0] - self.l3[0]
        else:
            cd = cd + self.l3[0] - self.l2[0]
        
        aRSI = 0
        if cu+cd != 0 and (cu / (cu + cd)) > .9:
            aRSI = 1
        else:
            aRSI = cu / (cu + cd)
            
        #aRSI = cu / (cu + cd)
        #print(cu / (cu + cd))
        self.lines.lrsi[0] = aRSI

I made the original Mobius Laguerre RSI however I wanted to test a version with an adaptive FE. However, when I change the gamma from self.practicegamma.energy[0] to self.gamma.output[0] the self.l0, self.l1 etc lists began to return nan values. I can't figure out why. The only thing I changed from the my working laguerre RSI is the type of gamma values for l0, l2. Both self.practicegamma.energy[0] and self.gamma.output[0] return the proper values so I know that is not the issue. Therefore the issue must be when I insert values into self.l0, self.l1 etc. However, the error only occurs when I change self.practicegamma.energy[0] to self.gamma.output[0]. Majorly confused here.

Any help is appreciated.

@ab_trader Ok so everything is working now. So the reason for the errors was that in the init for my strategy I initialized the self.gamma variable with gamma1(self.data).dummyline. That was my mistake I should have deleted that .dummyline.

I think I go confused for a bit and accidentally put that there in the init of my strategy. I also used self.line.dummyline[0] in the next() of my strat. which should be used in my indicator class not strat class.

Bunch of dumb mistakes I made. HUGE thanks to @ab_trader and @run-out for helping me out, and clarifying many aspects of BT for me.

@ab_trader Thanks for the tip! So why does the strategy throw the error "lists object has no attribute dummyline" when I call self.gamma.lines.dummyline[0] in the next() portion of the strategy? I defined dummyline it in my indicator and specifically initialized it in my strategy's init.

@ab_trader Ahhh. Strange, past custom indicators I made did not have issues with self.lines.dummyline[0] not having the brackets, so I assumed that the self.lines.dummyline was an exception.

@run-out I originally tried this but got a, linebuffer has no attribute dummyline, in the next() function. Shouldn't setting self.gamma to dummyline in the init be enough to call it later on without dummyline[0]

@ab_trader I originally tried with normal division, y/r, but when I try to set self.lines equal to it then I get a float object is not callable error.

@run-out I removed [0] because I get a non subscriptable error.

So I made a custom indicator which is the Chop Index/Fractal energy indicator however it only returns nan.

class gamma1(bt.Indicator):
    lines = ('dummyline',)

    params = (('value', 5),)

    def __init__(self):

        self.m  = bt.If(self.data.high > self.data.close(-1), self.data.high, self.data.close(-1))
        self.n = bt.If(self.data.low < self.data.close(-1), self.data.low, self.data.close(-1))
        self.a = self.m - self.n
        self.b = btind.SumN(self.a, period=8)
        self.hl = btind.Highest(self.data.high, period=8)-btind.Lowest(self.data.low, period=8)
        
        
    def next(self):
        z = self.b[0]/self.hl[0]
        y = math.log(z,10)
        r = math.log(8, 10)
        print(y)
        print(r)
        k = bt.DivByZero(y,r)
        self.lines.dummyline = k
class SMAStrategy(bt.Strategy):
    params = (
        ('period', 10), ('period2', 10),
    )
    def __init__(self):
  
        self.gamma = gamma1(self.data)
    
    def next(self): 
        print(self.gamma.lines.dummyline[0])

When I divide y and r by hand there is no issue. Therefore the issue must be with bt.divbyzero. I can't figure out why it return nan. Can anyone provide some guidance?

Much appreciated.

@run-out Thanks for all your help its working now. I just need to figure out why gamma1() only outputs nan.

I appreciate all your help @run-out

@run-out Found a solution to the problem. Instead of y/r i used bt.DivByZero(y,r)

However, when I try printing the values of gamma1() in my strategy to check the values I get this weird printout.

<__main__.gamma1 object at 0x0D274E68>

Haven't seen this anywhere else in this community hope you could help.

      self.gamma = gamma1(self.data)
    
    def next(self): 
        print(self.gamma)
   

@run-out Yup here it is.

    y = math.log(z[0])                                                                                                  TypeError: 'float' object is not subscriptable  

@run-out In the next() I have tried using brackets for current bar however for variable y and z I get a float object is not subscriptable error.

@run-out Thank You! So I fixed the original error.

Code:

class gamma1(bt.Indicator):
    lines = ('dummyline',)

    params = (('value', 5),)

    def __init__(self):
        self.m  = bt.If(self.data.high > self.data.close[-1], self.data.high, self.data.close[-1])
        self.n = bt.If(self.data.low < self.data.close[-1], self.data.low, self.data.close[-1])
        self.a = self.m - self.n
        self.b = btind.SumN(self.a, period=8)
        self.hl = btind.Highest(self.data.high, period=8)-btind.Lowest(self.data.low, period=8)
        
        
    def next(self):
        z = self.b/self.hl
        y = math.log(z)
        r = math.log(8)
        self.lines.dummyline = y/r

However the last line, self.lines/dummylin = y/r, gets an error of float object is not callable. After some googling most issues seem to be from misuse of parenthesis however I do not see that in my code. Any guidance is much appreciated.

@run-out Thanks! I made the changes you recommended however now I get a math domain error.

So I am trying to code the Mobius laguerre RSI which has an adaptive gamma, based off of Fractal energy/Chop index values. This is different from BT's build in Laguerre RSI which has a constant value for gamma. However, my math.log is throwing a:

"Must be a real number,not LinesOperation" error on
self.y = math.log(self.z)
Do I need to convert it to a int? Any help is greatly appreciated.

Code:

from __future__ import (absolute_import, division, print_function,
                        unicode_literals)
import argparse
import backtrader as bt
import backtrader.feeds as btfeeds
import backtrader.indicators as btind
from datetime import datetime
from pprint import pprint
import pandas as pd
import math
from numpy import arange
from backtrader.indicators import StdDev
from backtrader.indicators import EMA
pd.set_option('display.max_rows', 500)
class gamma1(bt.Indicator):
    lines = ('dummyline',)

    params = (('value', 5),)

    def __init__(self):
        self.m  = bt.If(self.data.high > self.data.close[1], self.data.high, self.data.close[-1])
        self.n = bt.If(self.data.low < self.data.close[1], self.data.low, self.data.close[-1])
        self.a = self.m - self.n
        self.b = btind.SumN(self.a, period=8)
        self.hl = btind.Highest(self.data.high, period=8)-btind.Lowest(self.data.low, period=8)
        self.z = self.b/self.hl
        self.y = math.log(self.z)
        r = math.log(8)
        
        self.lines.dummyline = self.y/r
class CLaguerreRSI(bt.Indicator):
    alias = ('CLRSI',)
    lines = ('lrsi',)
    params = (('e', 0.5),)

    plotinfo = dict(
        plotymargin=0.15,
        plotyticks=[0.0, 0.2, 0.5, 0.8, 1.0]
    )

    def __init__(self):
        self.addminperiod(6)
        self.l0 = [0, 0]
        self.l1 = [0, 0]
        self.l2 = [0, 0]
        self.l3 = [0, 0]
        self.gamma = gamma1(self.data)
        self.o = (self.data.open+self.data.close[-1])/2
        self.h = bt.If(self.data.high  > self.data.close(-1),self.data.high, self.data.close(-1))
        self.l = bt.If(self.data.low  < self.data.close(-1),self.data.low, self.data.close(-1))
        self.c = (self.o+self.h+self.l+self.data.close)/4
        super(CLaguerreRSI, self).__init__()

    def next(self):
        self.l0.insert(0, ((1 - self.gamma) * self.c +
                           self.gamma * self.l0[0]))
        self.l1.insert(0, (-self.gamma * self.l0[0] + self.l0[1] +
                           self.gamma * self.l1[0]))
        self.l2.insert(0, (-self.gamma * self.l1[0] + self.l1[1] +
                           self.gamma * self.l2[0]))
        self.l3.insert(0, (-self.gamma * self.l2[0] + self.l2[1] +
                           self.gamma * self.l3[0]))
        del self.l0[2:]
        del self.l1[2:]
        del self.l2[2:]
        del self.l3[2:]

        cu = bt.If(self.l0[0] >= self.l1[0], self.l0[0] - self.l1[0], 0)
        cd = bt.If(self.l0[0] < self.l1[0], self.l1[0] - self.l0[0], 0)

        cu = bt.If(self.l1[0] >= self.l2[0], cu + self.l1[0] - self.l2[0], 0)
        cd = bt.If(self.l1[0] < self.l2[0], cd + self.l2[0] - self.l1[0] , 0)
       
        cu = bt.If(self.l2[0] >= self.l3[0], cu + self.l2[0] - self.l3[0], 0)
        cd = bt.If(self.l2[0] < self.l3[0], cd + self.l3[0] - self.l2[0] , 0)
        self.lines.lrsi = cu / (cu + cd)
class SMAStrategy(bt.Strategy):
    params = (
        ('period', 10), ('period2', 10),
    )
    def __init__(self):
        self.startcash = self.broker.getvalue()
        self.o = (self.data.open+self.data.close[-1])/2
        self.h = bt.If(self.data.high  > self.data.close(-1),self.data.high, self.data.close(-1))
        self.l = bt.If(self.data.low  < self.data.close(-1),self.data.low, self.data.close(-1))
        self.c = (self.o+self.h+self.l+self.data.close)/4
        self.atr = btind.AverageTrueRange(self.data, period = 14)
        self.filt = btind.LaguerreFilter(self.data.close, gamma = .8)
        self.rsi = btind.LRSI(self.c, gamma = .05)
        self.rsi_exit =  btind.LRSI(self.c, gamma = .5)
        self.BB = btind.BollingerBands(self.data, period = 20, devfactor =2, movav=bt.indicators.MovAv.Exponential)
        self.mLRSI = CLaguerreRSI(self.data)
    
    def next(self): 

        if self.position:
            if (self.mLRSI == 0 or (self.mLRSI < self.mLRSI[-1] and self.mLRSI < .8))  and self.position.size > 0:
                self.close(size=self.position.size)
            if (self.mLRSI ==1 or (self.mLRSI > self.mLRSI[-1] and self.mLRSI > .2))  and self.position.size < 0:
                self.close(size=self.position.size)
        if not self.position:
            if (self.mLRSI == 1 or (self.mLRSI > self.mLRSI[-1] and self.mLRSI > .2)) and self.data.close > self.filt:
                self.buy(size=10)
                #print('{},BUY,{}'.format(self.datetime.datetime(), self.data.close[0]))
                #print(self.datetime.date())
            if (self.mLRSI ==0 or (self.mLRSI < self.mLRSI[-1] and self.mLRSI < .8)) and self.data.close < self.filt:
                self.sell(size=10)
                #print('{},SELL,{}'.format(self.datetime.datetime(), self.data.close[0]))
                #print(self.datetime.date())
        
        
        
def printTradeAnalysis(analyzer):
    '''
    Function to print the Technical Analysis results in a nice format.
    '''
    #Get the results we are interested in
    #total_open = analyzer.total.open
    #total_closed = analyzer.total.closed
    total_won = analyzer.won.total
    total_lost = analyzer.lost.total
    #pnl_net = round(analyzer.pnl.net.total,2)
    '''
    longWinRate = analyzer.long.won/(analyzer.long.won+analyzer.long.lost)
    longLossRate = analyzer.long.lost/(analyzer.long.won+analyzer.long.lost)
    longAvgWin = analyzer.long.pnl.won.average
    longAvgLoss = abs(analyzer.long.pnl.lost.average)
    longExpect = (longAvgWin*longWinRate)-(longAvgLoss*longLossRate)
    longPF = analyzer.long.pnl.won.total/abs(analyzer.long.pnl.lost.total)

    shortWinRate = analyzer.short.won/(analyzer.short.won+analyzer.short.lost)
    shortLossRate = analyzer.short.lost/(analyzer.short.won+analyzer.short.lost)
    shortAvgWin = analyzer.short.pnl.won.average
    shortAvgLoss = abs(analyzer.short.pnl.lost.average)
    shortExpect = (shortAvgWin*shortWinRate)-(shortAvgLoss*shortLossRate)
    shortPF = analyzer.short.pnl.won.total/abs(analyzer.short.pnl.lost.total)
    '''
    winRate = total_won/(total_won+total_lost)
    bearWinRate = total_lost/(total_won+total_lost)
    avgwin = analyzer.won.pnl.average
    avgloss = abs(analyzer.lost.pnl.average)
    totalExpect = (avgwin*winRate)-(avgloss*bearWinRate)
    #totalPF = analyzer.won.pnl.total/abs(analyzer.lost.pnl.total)
    print(winRate)
    print(totalExpect)
    #print(analyzer.SharpeRatio)
    print(analyzer.total.total)
    #return "{:.2%}".format(winRate), round(analyzer.won.pnl.average,2), round(analyzer.lost.pnl.average,2), round(totalExpect,2), round(analyzer.len.average,2), analyzer.streak.won.longest, analyzer.streak.lost.longest
def runstrat():  
    # Create a cerebro entity
    #for grp in groups:
    startcash = 10000
    #cerebro = bt.Cerebro(stdstats=False)

    # Add a strategy

    # Load the Data
    cerebro = bt.Cerebro(stdstats=False)
    #cerebro.optstrategy(SMAStrategy)
    cerebro.addstrategy(SMAStrategy,)

    #cerebro.addanalyzer(bt.analyzers.TradeAnalyzer, _name="ta")

    data = bt.feeds.YahooFinanceData(
    dataname='BA',
    fromdate = datetime(2000,1,1),
    todate = datetime(2020,8,17),
    timeframe = bt.TimeFrame.Days,
    buffered= True
    )
    cerebro.adddata(data)  # First add the original data - smaller timeframe
    #cerebro.strat(SMAStrategy )
    #cerebro.broker.setcash(startcash)

    # Run over everything
    cerebro.addanalyzer(bt.analyzers.TradeAnalyzer, _name="ta")
    cerebro.addanalyzer(bt.analyzers.SharpeRatio, _name='mysharpe')
    #cerebro.addanalyzer(bt.analyzers.SQN, _name="sqn")
    strategies = cerebro.run()
    firstStrat = strategies[0]
    portvalue = cerebro.broker.getvalue()
    pnl = portvalue - startcash
    printTradeAnalysis(firstStrat.analyzers.ta.get_analysis())
 

if __name__ == '__main__':
    runstrat()

@rpriyadarshi said in Custom Indicator RVI; float division by zero:

Wherever you see this error, you can add Python exception handler. For example, in my case, I modified the code as follows in file */backtrader/linebuffer.py. Look for the def as shown below:

def _once_op(self, start, end):
    ...
    for i in range(start, end):
        dst[i] = op(srca[i], srcb[i])

Replace it as follows:

def _once_op(self, start, end):
    ...
    for i in range(start, end):
        try:
            dst[i] = op(srca[i], srcb[i])
        except ZeroDevisionError:
            dst[i] = float(f'nan')

You may replace all such occurrences if you get this error.

Thank You very much. Try/Catch completely slipped my mind.

@barton05 said in Custom Indicator RVI; float division by zero:

Referencing RSI in backtrader and simplfied the design a bit, see if it helps

import backtrader as bt

class RVI(bt.Indicator):
    lines = ('rvi','upDaySTD','downDaySTD')
    params = (('period', 14),
    ('movav', bt.ind.MovAv.Smoothed),
    ('upperband', 70.0),
    ('lowerband', 30.0),
    ('safehigh', 100.0),
    ('safelow', 50.0),
    )

    plotinfo = dict(subplot=True)
    plotlines = dict(
        upDaySTD=dict(_plotskip=True),
        downDaySTD=dict(_plotskip=True),
    )

    def _plotinit(self):
        self.plotinfo.plotyhlines = [self.p.upperband, self.p.lowerband]

    def __init__(self):
        super(RVI, self).__init__()
        self.lines.upDaySTD=bt.If(self.data-self.data(-1)<0,bt.ind.StdDev(self.data, period=self.p.period),0)
        self.lines.downDaySTD=bt.If(self.data-self.data(-1)>0,bt.ind.StdDev(self.data, period=self.p.period),0)
        maup = self.p.movav(self.lines.upDaySTD, period=self.p.period)
        madown = self.p.movav(self.lines.downDaySTD, period=self.p.period)
        highrs = self._rscalc(self.p.safehigh)
        lowrs = self._rscalc(self.p.safelow)
        rv = bt.ind.DivZeroByZero(maup, madown, highrs, lowrs)
        self.l.rvi = 100.0 - 100.0 / (1.0 + rv)

    def _rscalc(self, rsi):
        try:
            rs = (-100.0 / (rsi - 100.0)) - 1.0
        except ZeroDivisionError:
            return float('inf')
        return rs

Oh wow the one you made is much cleaner and better than the one I made. Thanks for the help!

Thank you, thats exactly what I needed. Didn't realize backtrader had this function.

So I am trying to build the relative volatility index indicator in backtrader. However, I get an error:

dst[i] = op(srca[i], srcb[i])                                                                                       ZeroDivisionError: float division by zero   

I understand that there are multiple points in my indicator logic where a division by zero could occur, such as rviHi declaration. However, I can't seem to find a way to fix this. Can anyone with knowledge of the relative volatility index check if my math/formula is right? Or is this a logic/programming error I committed?

Code:

from __future__ import (absolute_import, division, print_function,
                        unicode_literals)
import backtrader as bt
from datetime import datetime
from backtrader.indicators import EMA
from backtrader.indicators import StdDev
import backtrader.indicators as btind

class RVI(bt.Indicator):
    lines = ('dummyline',)

    params = (('value', 5),)

    def __init__(self):
        stDevHi = StdDev(self.data.high, period=10)
        stDevLo = StdDev(self.data.low, period=10)
        avgStDevHiUp = bt.If(self.data.high  > self.data.high(-1),EMA(stDevHi, period = 14), 0)

        avgStDevHiDown= bt.If(self.data.high  < self.data.high(-1),EMA(stDevHi, period = 14), 0)


        avgStDevLoUp = bt.If(self.data.low  > self.data.low(-1),EMA(stDevLo, period = 14), 0)

 
        avgStDevLoDown = bt.If(self.data.low  < self.data.low(-1),EMA(stDevLo, period = 14), 0)


        rviHi = bt.If((avgStDevHiDown + avgStDevHiUp) == 0, 50, (100* avgStDevHiUp) / (avgStDevHiUp + avgStDevHiDown))


        rviLo = bt.If((avgStDevLoUp + avgStDevLoDown) == 0,50, (100* avgStDevLoUp) / (avgStDevLoUp + avgStDevLoDown))


        self.lines.dummyline = (rviHi + rviLo) / 2
class firstStrategy(bt.Strategy):

    def __init__(self):
        self.rsi_small = RVI(self.data)
        self.sma = btind.EMA(self.data, period = 20)

    def next(self):
        if not self.position:
            if (self.sma < self.data.close and self.rsi_small > self.rsi_small[-1]):
                self.buy(size=10)
                #print('{},BUY,{}'.format(self.datetime.datetime(), self.data.close[0]))
                #print(self.datetime.date())
            if (self.sma > self.data.close and self.rsi_small < self.rsi_small[-1]):
                self.sell(size=10)
                #print('{},SELL,{}'.format(self.datetime.datetime(), self.data.close[0]))
                #print(self.datetime.date())
        else:
            if self.rsi_small < self.rsi_small[-1] and self.data.close < self.sma and self.position.size > 0:
                self.close(size=10)
            if self.rsi_small > self.rsi_small[-1] and self.data.close > self.sma and self.position.size < 0:
                self.close(size=10)


#Variable for our starting cash
startcash = 10000

#Create an instance of cerebro
cerebro = bt.Cerebro()

#Add our strategy
cerebro.addstrategy(firstStrategy)

#Get Apple data from Yahoo Finance.
#data = bt.feeds.Quandl(
#    dataname='AAPL',
#    fromdate = datetime(2016,1,1),
#    todate = datetime(2017,1,1),
#    buffered= True
#    )
data = bt.feeds.YahooFinanceData(
    dataname='AAPL',
    fromdate = datetime(2000,1,1),
    todate = datetime(2020,1,1),
    timeframe = bt.TimeFrame.Days,
    buffered= True
    )
#Add the data to Cerebro
cerebro.adddata(data)



# Set our desired cash start
cerebro.broker.setcash(startcash)

# Run over everything
cerebro.run()

#Get final portfolio Value
portvalue = cerebro.broker.getvalue()
pnl = portvalue - startcash

#Print out the final result
print('Final Portfolio Value: ${}'.format(portvalue))
print('P/L: ${}'.format(pnl))

#Finally plot the end results
cerebro.plot(style='candlestick')

Thanks for any help

@ab_trader said in Basic MultiTimeframe order:

@Paul-Park said in Basic MultiTimeframe order:

So nextstart() ensures that the higher time frame completes the bar before letting the program continue?

nextstart() has no relation to time frames.

Ahh I see where my confusion was now. Thank you very much.