Incorporating existing 'standard' indicators into a custom indicator

Hi Koen,

I've been doing that extensively. Overall, I use two “techniques”:

1- The existing indicators I want to use are simply assigned to one self.some_variable in my custom indicator.

2- I re-implement the existing indicator inside my custom indicator when it makes more sense to blend it in instead of letting it encapsulated. For instance, having multiple encapsulated indicators inside another indicator can multiply the duplication of data. Dumb example: let's day one indie integrates 3 EMAs of different lengths and makes comparisons to produce signals. If you keep those 3 EMAs separate, the shorter one's data is also inside the other two and the middle one's is in the longer one… So then I would choose to keep only the longer length of data once and calculate all 3 EMAs from that data. It's not only a question of data duplication (space) but also a question of time (processing). Oftentimes, I also do “dynamic programming”, which means I calculate some “small results” only once and I re-use those results over and over again when I calculate larger results, instead of always re-calculating smaller results when needing larger ones. 😊 When the algo is about doing that…….. Doing my best to popularize here.

Fred

Sharing this relevant post from Fred. It might be useful as he breaks down, in much detail, how custom indicators work.

@ekz and @fred - appreciate the suggestions. Incorporating both!

is there any template to incorporate a standard indicators into a custom indicators, with the update, warmup period, and plotting include ? For exemple, i'am currently trying to build an ADX based on the average of 7 DX, which is it self based on +DI and -DI computed on 14 period. In other words ADX period = 7 and +DI, -DI period = 14.

A kind of “fast” ADX compare to the 14 period ADX

I upload my code and a special discussion for my case: "

I upload my code and a special discussion for my case: "

After spending many hours working on this problem, I've finally found a solution. The code I'm sharing is the very first template designed to calculate a custom indicator using a pre-existing indicator as a base.

I hope sharing this will save someone else the six full days of hard work and effort I put into solving it myself :))

# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from AlgorithmImports import *
from collections import deque

class CustomIndicatorAlgorithm(QCAlgorithm):
    def Initialize(self):
        self.SetStartDate(2021,1,1)
        self.SetEndDate(2024,5,1)
        self.symbol = self.AddCrypto("BTCUSDT", Resolution.Daily).Symbol

        self.custom = Volatility_ADX('custom', 7, 14)


# To register a custom indicator for automatic update, its output need to be a single value.
# Here the single value is the fast adx minus the slow adx.


        self.RegisterIndicator(self.symbol, self.custom )

        self.SetWarmUp(50)

        self.PlotIndicator('ADX: Fast - Slow', self.custom)


    #def OnData(self, slice: Slice) -> None:

       # if self.IsWarmingUp:
           # return

        # For manual update (remove the RegisterIndicator method)
        #if slice.Bars.ContainsKey(self.symbol):
            #bar = slice.Bars[self.symbol]
            #self.custom.Update(bar)
        
        # Manually update the custom indicator
        #self.custom.Update(data["SPY"].Bars)
       
       

        # The current value of self.sma is represented by self.sma.Current.Value
        #self.Plot("Slow ADX", "fast", self.custom.SlowValue)
        #self.Plot("Fast ADX", "fast", self.custom.FastValue)


class Volatility_ADX(PythonIndicator):
    def __init__(self, name, fast_period, slow_period):
        super().__init__()
        self.Name = name
      
        self.Value = 0
        self.fastqueue = deque(maxlen=fast_period)
        self.slowqueue = deque(maxlen=slow_period)

        self.adx = AverageDirectionalIndex(14)

    # Update method is mandatory
    def Update(self, input):

        self.adx.Update(input)

        if self.adx.IsReady:
            DX = (100 * abs((self.adx.PositiveDirectionalIndex.Current.Value) - (self.adx.NegativeDirectionalIndex.Current.Value))) / ((self.adx.PositiveDirectionalIndex.Current.Value) + (self.adx.NegativeDirectionalIndex.Current.Value))

            self.fastqueue.appendleft(DX)
            self.slowqueue.appendleft(DX)
        
        slowcount = len(self.slowqueue)
        fastcount = len(self.fastqueue)

        if slowcount == self.slowqueue.maxlen:
            SlowValue = np.sum(self.slowqueue) / slowcount
            FastValue = np.sum(self.fastqueue) / fastcount
            
            #The single value the indicator return: the difference between the fast and slow 						    
            self.Value = FastValue - SlowValue