GKD-C STD-Filtered, Kaiser Window FIR Digital Filter [Loxx]

Giga Kaleidoscope GKD-C STD-Filtered, Kaiser Window FIR Digital Filter is a Confirmation module included in Loxx's "Giga Kaleidoscope Modularized Trading System".

█ GKD-C STD-Filtered, Kaiser Window FIR Digital Filter

What is a Kaiser Window FIR Digital Filter?
A Kaiser Window is a type of window function used in digital signal processing to design Finite Impulse Response (FIR) filters. FIR filters are digital filters that have a finite duration impulse response.

The Kaiser Window is a window function that is used to shape the impulse response of an FIR filter. The window function is applied to the coefficients of the ideal low-pass filter, which results in a truncated and windowed version of the ideal filter.

The Kaiser Window is designed using the Kaiser-Bessel window method, which is a technique for designing FIR filters with a specified stopband attenuation and transition width. The method uses the Kaiser Window to control the magnitude of the filter coefficients in the transition band and stopband.

The Kaiser Window is characterized by a parameter called the "beta" parameter, which controls the trade-off between the transition width and the stopband attenuation of the filter. The larger the beta value, the narrower the transition width and the higher the stopband attenuation.

Kaiser Window FIR filters have a number of advantages, including good stopband attenuation, narrow transition width, and the ability to control the ripple in the passband. However, they also have some disadvantages, including a high computational complexity and a non-linear phase response.

What is the STD-Filtered, Kaiser Window FIR Digital Filter?
This indicator is an implementation of a Kaiser window finite impulse response (FIR) digital filter. The Kaiser window is a widely used window function for designing FIR filters due to its ability to control the trade-off between the main lobe width and sidelobe levels. The design process begins with the calculation of the zero-order modified Bessel function of the first kind using an iterative method. This function plays a crucial role in the calculation of the Kaiser window coefficients.

The filter characteristics, such as passband, stopband, passband ripple, and stopband attenuation, are user-defined inputs. Based on these inputs, and filtering order function estimates the filter length, alpha value (a parameter governing the shape of the Kaiser window), and adjusted passband and stopband values. The filter length is adjusted to be an odd integer to maintain filter symmetry, which is essential for linear phase response.

Subsequently, a normalization function calculates the filter coefficients and the Kaiser window coefficients. The Kaiser window coefficients are obtained by applying the zero-order modified Bessel function to the window samples. The filter coefficients are derived by multiplying the sinc function with the Kaiser window coefficients, and then normalized to preserve the filter's gain in the passband.

The filter response function computes the output of the FIR filter by convolving the input signal with the filter coefficients. Optionally, the output signal can be passed through a standard deviation filter, as determined by the user-selected filter options.

The Kaiser window FIR digital filter presented in this study is suitable for various applications, including noise reduction, signal smoothing, and extraction of relevant information from complex data sets. The implementation allows users to adapt the filter performance according to their specific requirements by adjusting the passband ripple, stopband attenuation, passband bars, and stopband bars, which determine the filter's frequency response and transition band characteristics.

The filter design process relies on the Kaiser window's flexibility, as it can be shaped according to the alpha parameter calculated in the filterOrder() function. This parameter controls the trade-off between the filter's main lobe width and sidelobe levels. A larger alpha value results in higher sidelobe suppression at the cost of a wider main lobe, whereas a smaller alpha value leads to a narrower main lobe but less sidelobe suppression. This trade-off allows users to fine-tune the filter's performance for specific applications.

In addition to the filter's frequency domain characteristics, the implementation ensures a linear phase response by maintaining filter symmetry. Linear phase filters are crucial for applications where the preservation of the signal's phase information is essential, such as audio processing and communication systems.

The optional standard deviation filter serves as a supplementary tool for enhancing the output signal. By applying this filter, users can further suppress unwanted high-frequency components and improve the overall signal quality. This feature is particularly useful in applications where the noise characteristics are unknown or vary over time.

In summary, the Kaiser window FIR digital filter offers a highly customizable and efficient solution for signal processing tasks. The combination of user-defined filter characteristics, a flexible Kaiser window function, linear phase response, and optional standard deviation filtering makes this implementation a powerful and versatile tool for a wide range of applications in various domains, including audio processing, communication systems, and data analysis.

How this is done
Kaiser Window FIR Digital Filter calculations:

/Bessel function, z-order hyperbolic
zorderHyperbolicBessel(float x)=>
    float besselAccuracy = 0.000001
    float bessel = 1.0
    float summ = 0
    float temp = 0
    float k = 2.0
    float factorial = 1.0
    temp := x / 2
    summ := temp * temp
    bessel += summ
    while summ > besselAccuracy 
        factorial := factorial * k
        temp *= x / 2
        summ := temp / factorial
        summ := summ * summ
        bessel += summ
        k += 1.0
    bessel

//Filter length estimations
filterOrder(float PassBandRipple, float StopBandAttenuation, float PassBandBars, float StopBandBars)=>
    float sbripple = 0
    float pbripple = 0
    float ripple = 0
    float attenuation = 0
    float bandwidth = 0
    float d = 0
    float n = 0
    float x = 0
    float alpha = 0
    
    float FilterLength = 0.
    PassBand = 1 / PassBandBars
    StopBand = 1 / StopBandBars
    bandwidth := PassBand + StopBand
    if bandwidth >= 0.5
        PassBand := 0.5 * PassBand / bandwidth
        StopBand := 0.5 * StopBand / bandwidth
    
    sbripple := math.pow(10.0, (-0.05 * StopBandAttenuation))
    pbripple := math.pow(10.0, (0.05 * PassBandRipple)) - 1.0
    ripple := math.min(sbripple, pbripple) 
    attenuation := -20 * math.log(ripple) / math.log(10) 
    if math.round(attenuation, 5) <= 21.0
        alpha := 0.0
        d := 0.9222
    
    if math.round(attenuation, 5) > 50.0
        alpha := 0.1102 * (attenuation - 8.7)
        d := (attenuation - 7.95) / 14.36
    
    if math.round(attenuation, 5) > 21.0 and math.round(attenuation, 5) <= 50
        alpha := (0.5842 * math.pow((attenuation - 21.0), 0.4)) + (0.07886 * (attenuation - 21.0))
        d := (attenuation - 7.95) / 14.36
    
    n := (d / StopBand) + 1.0
    x := math.round(n)
    if x % 2 < 1
        FilterLength := x
    else 
        FilterLength := x - 1
        
    [int(FilterLength), alpha, PassBand, StopBand]

Normalization(float PassBandRipple, float StopBandAttenuation, float PassBandBars, float StopBandBars)=>
    float filter = 0
    float Ioalfa = 0
    float temp = 0
    float norm = 0

    [FilterLength, alpha, PassBand, StopBand] = filterOrder(PassBandRipple, StopBandAttenuation, PassBandBars, StopBandBars)
    int M = int(FilterLength / 2)
    float[] filterCoeff = array.new<float>(FilterLength + 1, 0)
    float[] kaiserWindow = array.new<float>(M + 1, 0)
    
    //Window function 
    norm := M
    Ioalfa := zorderHyperbolicBessel(alpha)
    for i = 1 to M 
        temp := i / norm
        array.set(kaiserWindow, i, zorderHyperbolicBessel(alpha * math.sqrt(1 - (temp * temp))) / Ioalfa)

    //filter coefficients
    array.set(filterCoeff, 0, 2.0 * (PassBand + (0.5 * StopBand)))
    norm := array.get(filterCoeff, 0)
    temp := math.pi * array.get(filterCoeff, 0)
    for i = 1 to M 
        array.set(filterCoeff, i, math.sin(i * temp) * array.get(kaiserWindow, i) / (i * math.pi))
        norm := norm + (2 * array.get(filterCoeff, i)) 

    //casual conversion and normalization
    float[] NormCoef = array.new<float>(FilterLength + 1, 0)
    for i = M + 1 to FilterLength 
        array.set(filterCoeff, i, array.get(filterCoeff, i - M))
    for i = 0 to M - 1 
        array.set(filterCoeff, i, array.get(filterCoeff, FilterLength - i))
    array.set(filterCoeff, M, 2.0 * (PassBand + (0.5 * StopBand)))
    for i = 0 to FilterLength 
        array.set(NormCoef, i, array.get(filterCoeff, i) / norm)
    [NormCoef, FilterLength]

filterResponse(float src, float[] NormCoef, int per)=>
    float valueBuf = 0
    float temp = 0
    float temp1 = 0
    float Response = 0.0
    int i = 0
    int filterlength = 0
    while filterlength <= per
        valueBuf := nz(src[filterlength])
        Response := Response + valueBuf * array.get(NormCoef, filterlength)
        filterlength += 1
    Response

Here's a detailed explanation of the functions involed in the code posted above:

1. zorderHyperbolicBessel(float x): This function calculates the zero-order modified Bessel function of the first kind (I0) for a given input x. The Bessel function is used in the calculation of the Kaiser window coefficients.
-besselAccuracy: The desired accuracy for the Bessel function calculation (0.000001).
-bessel: The initial value of the Bessel function (1.0).
-summ: The sum of terms in the series representation of the Bessel function.
-temp: A temporary variable to store intermediate values.
-k: The index for the series representation of the Bessel function.
-factorial: The factorial of k, used to calculate the denominator of the series terms.

The function iteratively calculates the terms in the series representation of the Bessel function until the sum of the squared terms is less than the desired accuracy. The final value of the Bessel function is returned.

2. filterOrder(PassBandRipple, StopBandAttenuation, PassBandBars, StopBandBars): This function estimates the filter length, alpha value, passband, and stopband for the Kaiser window-based FIR filter based on the given filter characteristics.
-PassBandRipple: The maximum allowed passband ripple in decibels.
-StopBandAttenuation: The minimum required stopband attenuation in decibels.
-PassBandBars: The number of bars in the passband.
-StopBandBars: The number of bars in the stopband.

The function first calculates the normalized passband and stopband frequencies. If their sum is greater than or equal to 0.5, they are scaled down to ensure the bandwidth is less than the Nyquist frequency.

-sbripple: The stopband ripple, calculated as 10^(-0.05 * StopBandAttenuation).
-pbripple: The passband ripple, calculated as 10^(0.05 * PassBandRipple) - 1.
-ripple: The minimum of the passband and stopband ripple values.
-attenuation: The attenuation in decibels, calculated as -20 * log10(ripple).

The alpha value and the variable d are determined based on the attenuation value:

-If attenuation <= 21 dB, alpha = 0 and d = 0.9222.
-If attenuation > 50 dB, alpha = 0.1102 * (attenuation - 8.7) and d = (attenuation - 7.95) / 14.36.
-If 21 dB < attenuation <= 50 dB, alpha = (0.5842 * (attenuation - 21)^0.4) + (0.07886 * (attenuation - 21)) and d = (attenuation - 7.95) / 14.36.
Finally, the filter length n is calculated as (d / StopBand) + 1. If n is odd, the filter length is set to n; otherwise, it is set to n - 1. The function returns an array containing the filter length, alpha value, passband, and stopband.

The functions Normalization() and filterResponse() play critical roles in the implementation of the Kaiser window FIR digital filter. They focus on calculating normalized filter coefficients and applying the filter to an input signal, respectively.

Normalization() function:
1. The function accepts four input parameters: PassBandRipple, StopBandAttenuation, PassBandBars, and StopBandBars. These parameters define the filter's desired performance characteristics.
2. It then calls the filterOrder() function to obtain the filter length, alpha parameter, passband, and stopband.
3. Next, the function calculates the Kaiser window coefficients using the obtained alpha parameter and the zero-order hyperbolic Bessel function. This is done by iterating from 1 to M (half of the filter length) and calculating the window coefficients using the formula:
zorderHyperbolicBessel(alpha * math.sqrt(1 - (temp * temp))) / Ioalfa
4. The filter coefficients are computed by multiplying the Kaiser window coefficients with the sinc function values. The filter coefficients are then stored in an array called filterCoeff.
5. The function performs causal conversion and normalization of the filter coefficients. The coefficients are normalized by dividing each element by the norm value calculated earlier.
6. Finally, the function returns the normalized filter coefficients NormCoef and the filter length FilterLength.

filterResponse() function:
1. This function is responsible for applying the calculated filter to the input signal src. It accepts three input parameters: the source signal src, the normalized filter coefficients NormCoef, and the period per over which the filter should be applied.
2. It initializes variables valueBuf, Response, and filterlength to store intermediate values and the final filtered signal output.
3. The function then iterates over the input signal for a given period. For each sample in the period, the function multiplies the input signal's value by the corresponding filter coefficient and accumulates the result in the Response variable.
4. Once the iteration is complete, the function returns the filtered signal output Response.

To wrap up, the zorderHyperbolicBessel() function calculates the zero-order modified Bessel function of the first kind, which is used in the Kaiser window calculation. The filterOrder() function estimates the filter length, alpha value, passband, and stopband for the Kaiser window-based FIR filter based on the given filter characteristics. These functions are part of the implementation of a Kaiser window FIR digital filter. The Kaiser window is a type of window function used to design finite impulse response (FIR) filters. The filter length, alpha value, passband, and stopband determined by the filterOrder() function are utilized in the subsequent steps of the filter design process.

Following the filterOrder() function, the Normalization() function calculates the filter coefficients and the Kaiser window coefficients. These coefficients are used in the filterResponse() function to compute the output of the FIR filter.

In the main body of the code, user-defined input values for PassBandBars, StopBandBars, StopBandAttenuation, and PassBandRipple are taken. These inputs are used to estimate the filter order, passband, and stopband using the filterOrder() function. Then, the Kaiser window coefficients and filter coefficients are computed using the Normalization() function.

Finally, the output of the FIR filter is computed using the filterResponse() function, which calculates the filtered response based on the input signal and the filter coefficients. The output signal is then passed through a standard deviation filter (stdFilter()) if the user has selected the "Both" or "Kaiser Window FIR Digital Filter" filter options, and the final output signal is stored in the out variable.

In summary, the code provided is an implementation of a Kaiser window FIR digital filter that processes an input signal based on user-defined filter characteristics (passband, stopband, passband ripple, and stopband attenuation). The zorderHyperbolicBessel() and filterOrder() functions are critical components in the filter design process, calculating the zero-order modified Bessel function and estimating the filter length, alpha value, passband, and stopband, respectively.

█ Giga Kaleidoscope Modularized Trading System

What is Loxx's "Giga Kaleidoscope Modularized Trading System"?
The Giga Kaleidoscope Modularized Trading System is a trading system built on the philosophy of the NNFX (No Nonsense Forex) algorithmic trading.

What is the NNFX algorithmic trading strategy?
The NNFX (No-Nonsense Forex) trading system is a comprehensive approach to Forex trading that is designed to simplify the process and remove the confusion and complexity that often surrounds trading. The system was developed by a Forex trader who goes by the pseudonym "VP" and has gained a significant following in the Forex community.

The NNFX trading system is based on a set of rules and guidelines that help traders make objective and informed decisions. These rules cover all aspects of trading, including market analysis, trade entry, stop loss placement, and trade management.

Here are the main components of the NNFX trading system:

1. Trading Philosophy: The NNFX trading system is based on the idea that successful trading requires a comprehensive understanding of the market, objective analysis, and strict risk management. The system aims to remove subjective elements from trading and focuses on objective rules and guidelines.

2. Technical Analysis: The NNFX trading system relies heavily on technical analysis and uses a range of indicators to identify high-probability trading opportunities. The system uses a combination of trend-following and mean-reverting strategies to identify trades.

3. Market Structure: The NNFX trading system emphasizes the importance of understanding the market structure, including price action, support and resistance levels, and market cycles. The system uses a range of tools to identify the market structure, including trend lines, channels, and moving averages.

4. Trade Entry: The NNFX trading system has strict rules for trade entry. The system uses a combination of technical indicators to identify high-probability trades, and traders must meet specific criteria to enter a trade.

5. Stop Loss Placement: The NNFX trading system places a significant emphasis on risk management and requires traders to place a stop loss order on every trade. The system uses a combination of technical analysis and market structure to determine the appropriate stop loss level.

6. Trade Management: The NNFX trading system has specific rules for managing open trades. The system aims to minimize risk and maximize profit by using a combination of trailing stops, take profit levels, and position sizing.

Overall, the NNFX trading system is designed to be a straightforward and easy-to-follow approach to Forex trading that can be applied by traders of all skill levels.

Core components of an NNFX algorithmic trading strategy
The NNFX algorithm is built on the principles of trend, momentum, and volatility. There are six core components in the NNFX trading algorithm:

1. Volatility - price volatility; e.g., Average True Range, True Range Double, Close-to-Close, etc.
2. Baseline - a moving average to identify price trend
3. Confirmation 1 - a technical indicator used to identify trends
4. Confirmation 2 - a technical indicator used to identify trends
5. Continuation - a technical indicator used to identify trends
6. Volatility/Volume - a technical indicator used to identify volatility/volume breakouts/breakdown
7. Exit - a technical indicator used to determine when a trend is exhausted

What is Volatility in the NNFX trading system?
In the NNFX (No Nonsense Forex) trading system, ATR (Average True Range) is typically used to measure the volatility of an asset. It is used as a part of the system to help determine the appropriate stop loss and take profit levels for a trade. ATR is calculated by taking the average of the true range values over a specified period.

True range is calculated as the maximum of the following values:

-Current high minus the current low
-Absolute value of the current high minus the previous close
-Absolute value of the current low minus the previous close

ATR is a dynamic indicator that changes with changes in volatility. As volatility increases, the value of ATR increases, and as volatility decreases, the value of ATR decreases. By using ATR in NNFX system, traders can adjust their stop loss and take profit levels according to the volatility of the asset being traded. This helps to ensure that the trade is given enough room to move, while also minimizing potential losses.

Other types of volatility include True Range Double (TRD), Close-to-Close, and Garman-Klass

What is a Baseline indicator?
The baseline is essentially a moving average, and is used to determine the overall direction of the market.

The baseline in the NNFX system is used to filter out trades that are not in line with the long-term trend of the market. The baseline is plotted on the chart along with other indicators, such as the Moving Average (MA), the Relative Strength Index (RSI), and the Average True Range (ATR).

Trades are only taken when the price is in the same direction as the baseline. For example, if the baseline is sloping upwards, only long trades are taken, and if the baseline is sloping downwards, only short trades are taken. This approach helps to ensure that trades are in line with the overall trend of the market, and reduces the risk of entering trades that are likely to fail.

By using a baseline in the NNFX system, traders can have a clear reference point for determining the overall trend of the market, and can make more informed trading decisions. The baseline helps to filter out noise and false signals, and ensures that trades are taken in the direction of the long-term trend.

What is a Confirmation indicator?
Confirmation indicators are technical indicators that are used to confirm the signals generated by primary indicators. Primary indicators are the core indicators used in the NNFX system, such as the Average True Range (ATR), the Moving Average (MA), and the Relative Strength Index (RSI).

The purpose of the confirmation indicators is to reduce false signals and improve the accuracy of the trading system. They are designed to confirm the signals generated by the primary indicators by providing additional information about the strength and direction of the trend.

Some examples of confirmation indicators that may be used in the NNFX system include the Bollinger Bands, the MACD (Moving Average Convergence Divergence), and the MACD Oscillator. These indicators can provide information about the volatility, momentum, and trend strength of the market, and can be used to confirm the signals generated by the primary indicators.

In the NNFX system, confirmation indicators are used in combination with primary indicators and other filters to create a trading system that is robust and reliable. By using multiple indicators to confirm trading signals, the system aims to reduce the risk of false signals and improve the overall profitability of the trades.

What is a Continuation indicator?
In the NNFX (No Nonsense Forex) trading system, a continuation indicator is a technical indicator that is used to confirm a current trend and predict that the trend is likely to continue in the same direction. A continuation indicator is typically used in conjunction with other indicators in the system, such as a baseline indicator, to provide a comprehensive trading strategy.

What is a Volatility/Volume indicator?
Volume indicators, such as the On Balance Volume (OBV), the Chaikin Money Flow (CMF), or the Volume Price Trend (VPT), are used to measure the amount of buying and selling activity in a market. They are based on the trading volume of the market, and can provide information about the strength of the trend. In the NNFX system, volume indicators are used to confirm trading signals generated by the Moving Average and the Relative Strength Index. Volatility indicators include Average Direction Index, Waddah Attar, and Volatility Ratio. In the NNFX trading system, volatility is a proxy for volume and vice versa.

By using volume indicators as confirmation tools, the NNFX trading system aims to reduce the risk of false signals and improve the overall profitability of trades. These indicators can provide additional information about the market that is not captured by the primary indicators, and can help traders to make more informed trading decisions. In addition, volume indicators can be used to identify potential changes in market trends and to confirm the strength of price movements.

What is an Exit indicator?
The exit indicator is used in conjunction with other indicators in the system, such as the Moving Average (MA), the Relative Strength Index (RSI), and the Average True Range (ATR), to provide a comprehensive trading strategy.

The exit indicator in the NNFX system can be any technical indicator that is deemed effective at identifying optimal exit points. Examples of exit indicators that are commonly used include the Parabolic SAR, the Average Directional Index (ADX), and the Chandelier Exit.

The purpose of the exit indicator is to identify when a trend is likely to reverse or when the market conditions have changed, signaling the need to exit a trade. By using an exit indicator, traders can manage their risk and prevent significant losses.

In the NNFX system, the exit indicator is used in conjunction with a stop loss and a take profit order to maximize profits and minimize losses. The stop loss order is used to limit the amount of loss that can be incurred if the trade goes against the trader, while the take profit order is used to lock in profits when the trade is moving in the trader's favor.

Overall, the use of an exit indicator in the NNFX trading system is an important component of a comprehensive trading strategy. It allows traders to manage their risk effectively and improve the profitability of their trades by exiting at the right time.

How does Loxx's GKD (Giga Kaleidoscope Modularized Trading System) implement the NNFX algorithm outlined above?
Loxx's GKD v1.0 system has five types of modules (indicators/strategies). These modules are:

1. GKD-BT - Backtesting module (Volatility, Number 1 in the NNFX algorithm)
2. GKD-B - Baseline module (Baseline and Volatility/Volume, Numbers 1 and 2 in the NNFX algorithm)
3. GKD-C - Confirmation 1/2 and Continuation module (Confirmation 1/2 and Continuation, Numbers 3, 4, and 5 in the NNFX algorithm)
4. GKD-V - Volatility/Volume module (Confirmation 1/2, Number 6 in the NNFX algorithm)
5. GKD-E - Exit module (Exit, Number 7 in the NNFX algorithm)

(additional module types will added in future releases)

Each module interacts with every module by passing data between modules. Data is passed between each module as described below:

GKD-B => GKD-V => GKD-C(1) => GKD-C(2) => GKD-C(Continuation) => GKD-E => GKD-BT

That is, the Baseline indicator passes its data to Volatility/Volume. The Volatility/Volume indicator passes its values to the Confirmation 1 indicator. The Confirmation 1 indicator passes its values to the Confirmation 2 indicator. The Confirmation 2 indicator passes its values to the Continuation indicator. The Continuation indicator passes its values to the Exit indicator, and finally, the Exit indicator passes its values to the Backtest strategy.

This chaining of indicators requires that each module conform to Loxx's GKD protocol, therefore allowing for the testing of every possible combination of technical indicators that make up the six components of the NNFX algorithm.

What does the application of the GKD trading system look like?
Example trading system:

• Backtest: Strategy with 1-3 take profits, trailing stop loss, multiple types of PnL volatility, and 2 backtesting styles
  
• Baseline: Hull Moving Average
  
• Volatility/Volume: Hurst Exponent
  
• Confirmation 1: STD-Filtered, Kaiser Window FIR Digital Filter as shown on the chart above
  
• Confirmation 2: Williams Percent Range
  
• Continuation: Fisher Transform
  
• Exit: Rex Oscillator
  

Each GKD indicator is denoted with a module identifier of either: GKD-BT, GKD-B, GKD-C, GKD-V, or GKD-E. This allows traders to understand to which module each indicator belongs and where each indicator fits into the GKD protocol chain.

Giga Kaleidoscope Modularized Trading System Signals (based on the NNFX algorithm)
Standard Entry
1. GKD-C Confirmation 1 Signal
2. GKD-B Baseline agrees
3. Price is within a range of 0.2x Volatility and 1.0x Volatility of the Goldie Locks Mean
4. GKD-C Confirmation 2 agrees
5. GKD-V Volatility/Volume agrees

Baseline Entry
1. GKD-B Baseline signal
2. GKD-C Confirmation 1 agrees
3. Price is within a range of 0.2x Volatility and 1.0x Volatility of the Goldie Locks Mean
4. GKD-C Confirmation 2 agrees
5. GKD-V Volatility/Volume agrees
6. GKD-C Confirmation 1 signal was less than 7 candles prior

Volatility/Volume Entry
1. GKD-V Volatility/Volume signal
2. GKD-C Confirmation 1 agrees
3. Price is within a range of 0.2x Volatility and 1.0x Volatility of the Goldie Locks Mean
4. GKD-C Confirmation 2 agrees
5. GKD-B Baseline agrees
6. GKD-C Confirmation 1 signal was less than 7 candles prior

Continuation Entry
1. Standard Entry, Baseline Entry, or Pullback; entry triggered previously
2. GKD-B Baseline hasn't crossed since entry signal trigger
3. GKD-C Confirmation Continuation Indicator signals
4. GKD-C Confirmation 1 agrees
5. GKD-B Baseline agrees
6. GKD-C Confirmation 2 agrees

1-Candle Rule Standard Entry
1. GKD-C Confirmation 1 signal
2. GKD-B Baseline agrees
3. Price is within a range of 0.2x Volatility and 1.0x Volatility of the Goldie Locks Mean
Next Candle:
1. Price retraced (Long: close < close or Short: close > close)
2. GKD-B Baseline agrees
3. GKD-C Confirmation 1 agrees
4. GKD-C Confirmation 2 agrees
5. GKD-V Volatility/Volume agrees

1-Candle Rule Baseline Entry
1. GKD-B Baseline signal
2. GKD-C Confirmation 1 agrees
3. Price is within a range of 0.2x Volatility and 1.0x Volatility of the Goldie Locks Mean
4. GKD-C Confirmation 1 signal was less than 7 candles prior
Next Candle:
1. Price retraced (Long: close < close or Short: close > close)
2. GKD-B Baseline agrees
3. GKD-C Confirmation 1 agrees
4. GKD-C Confirmation 2 agrees
5. GKD-V Volatility/Volume Agrees

1-Candle Rule Volatility/Volume Entry
1. GKD-V Volatility/Volume signal
2. GKD-C Confirmation 1 agrees
3. Price is within a range of 0.2x Volatility and 1.0x Volatility of the Goldie Locks Mean
4. GKD-C Confirmation 1 signal was less than 7 candles prior
Next Candle:
1. Price retraced (Long: close < close or Short: close > close)
2. GKD-B Volatility/Volume agrees
3. GKD-C Confirmation 1 agrees
4. GKD-C Confirmation 2 agrees
5. GKD-B Baseline agrees

PullBack Entry
1. GKD-B Baseline signal
2. GKD-C Confirmation 1 agrees
3. Price is beyond 1.0x Volatility of Baseline
Next Candle:
1. Price is within a range of 0.2x Volatility and 1.0x Volatility of the Goldie Locks Mean
2. GKD-C Confirmation 1 agrees
3. GKD-C Confirmation 2 agrees
4. GKD-V Volatility/Volume Agrees

]█ Setting up the GKD
The GKD system involves chaining indicators together. These are the steps to set this up.

Use a GKD-C indicator alone on a chart
1. Inside the GKD-C indicator, change the "Confirmation Type" setting to "Solo Confirmation Simple"

Use a GKD-V indicator alone on a chart
**nothing, it's already useable on the chart without any settings changes

Use a GKD-B indicator alone on a chart
**nothing, it's already useable on the chart without any settings changes

Baseline (Baseline, Backtest)
1. Import the GKD-B Baseline into the GKD-BT Backtest: "Input into Volatility/Volume or Backtest (Baseline testing)"
2. Inside the GKD-BT Backtest, change the setting "Backtest Special" to "Baseline"

Volatility/Volume (Volatility/Volume, Backtest)
1. Inside the GKD-V indicator, change the "Testing Type" setting to "Solo"
2. Inside the GKD-V indicator, change the "Signal Type" setting to "Crossing" (neither traditional nor both can be backtested)
3. Import the GKD-V indicator into the GKD-BT Backtest: "Input into C1 or Backtest"
4. Inside the GKD-BT Backtest, change the setting "Backtest Special" to "Volatility/Volume"
5. Inside the GKD-BT Backtest, a) change the setting "Backtest Type" to "Trading" if using a directional GKD-V indicator; or, b) change the setting "Backtest Type" to "Full" if using a directional or non-directional GKD-V indicator (non-directional GKD-V can only test Longs and Shorts separately)
6. If "Backtest Type" is set to "Full": Inside the GKD-BT Backtest, change the setting "Backtest Side" to "Long" or "Short
7. If "Backtest Type" is set to "Full": To allow the system to open multiple orders at one time so you test all Longs or Shorts, open the GKD-BT Backtest, click the tab "Properties" and then insert a value of something like 10 orders into the "Pyramiding" settings. This will allow 10 orders to be opened at one time which should be enough to catch all possible Longs or Shorts.

Solo Confirmation Simple (Confirmation, Backtest)
1. Inside the GKD-C indicator, change the "Confirmation Type" setting to "Solo Confirmation Simple"
1. Import the GKD-C indicator into the GKD-BT Backtest: "Input into Backtest"
2. Inside the GKD-BT Backtest, change the setting "Backtest Special" to "Solo Confirmation Simple"

Solo Confirmation Complex without Exits (Baseline, Volatility/Volume, Confirmation, Backtest)
1. Inside the GKD-V indicator, change the "Testing Type" setting to "Chained"
2. Import the GKD-B Baseline into the GKD-V indicator: "Input into Volatility/Volume or Backtest (Baseline testing)"
3. Inside the GKD-C indicator, change the "Confirmation Type" setting to "Solo Confirmation Complex"
4. Import the GKD-V indicator into the GKD-C indicator: "Input into C1 or Backtest"
5. Inside the GKD-BT Backtest, change the setting "Backtest Special" to "GKD Full wo/ Exits"
6. Import the GKD-C into the GKD-BT Backtest: "Input into Exit or Backtest"

Solo Confirmation Complex with Exits (Baseline, Volatility/Volume, Confirmation, Exit, Backtest)
1. Inside the GKD-V indicator, change the "Testing Type" setting to "Chained"
2. Import the GKD-B Baseline into the GKD-V indicator: "Input into Volatility/Volume or Backtest (Baseline testing)"
3. Inside the GKD-C indicator, change the "Confirmation Type" setting to "Solo Confirmation Complex"
4. Import the GKD-V indicator into the GKD-C indicator: "Input into C1 or Backtest"
5. Import the GKD-C indicator into the GKD-E indicator: "Input into Exit"
6. Inside the GKD-BT Backtest, change the setting "Backtest Special" to "GKD Full w/ Exits"
7. Import the GKD-E into the GKD-BT Backtest: "Input into Backtest"

Full GKD without Exits (Baseline, Volatility/Volume, Confirmation 1, Confirmation 2, Continuation, Backtest)
1. Inside the GKD-V indicator, change the "Testing Type" setting to "Chained"
2. Import the GKD-B Baseline into the GKD-V indicator: "Input into Volatility/Volume or Backtest (Baseline testing)"
3. Inside the GKD-C 1 indicator, change the "Confirmation Type" setting to "Confirmation 1"
4. Import the GKD-V indicator into the GKD-C 1 indicator: "Input into C1 or Backtest"
5. Inside the GKD-C 2 indicator, change the "Confirmation Type" setting to "Confirmation 2"
6. Import the GKD-C 1 indicator into the GKD-C 2 indicator: "Input into C2"
7. Inside the GKD-C Continuation indicator, change the "Confirmation Type" setting to "Continuation"
8. Inside the GKD-BT Backtest, change the setting "Backtest Special" to "GKD Full wo/ Exits"
9. Import the GKD-E into the GKD-BT Backtest: "Input into Exit or Backtest"

Full GKD with Exits (Baseline, Volatility/Volume, Confirmation 1, Confirmation 2, Continuation, Exit, Backtest)
1. Inside the GKD-V indicator, change the "Testing Type" setting to "Chained"
2. Import the GKD-B Baseline into the GKD-V indicator: "Input into Volatility/Volume or Backtest (Baseline testing)"
3. Inside the GKD-C 1 indicator, change the "Confirmation Type" setting to "Confirmation 1"
4. Import the GKD-V indicator into the GKD-C 1 indicator: "Input into C1 or Backtest"
5. Inside the GKD-C 2 indicator, change the "Confirmation Type" setting to "Confirmation 2"
6. Import the GKD-C 1 indicator into the GKD-C 2 indicator: "Input into C2"
7. Inside the GKD-C Continuation indicator, change the "Confirmation Type" setting to "Continuation"
8. Import the GKD-C Continuation indicator into the GKD-E indicator: "Input into Exit"
9. Inside the GKD-BT Backtest, change the setting "Backtest Special" to "GKD Full w/ Exits"
10. Import the GKD-E into the GKD-BT Backtest: "Input into Backtest"

Baseline + Volatility/Volume (Baseline, Volatility/Volume, Backtest)
1. Inside the GKD-V indicator, change the "Testing Type" setting to "Baseline + Volatility/Volume"
2. Inside the GKD-V indicator, make sure the "Signal Type" setting is set to "Traditional"
3. Import the GKD-B Baseline into the GKD-V indicator: "Input into Volatility/Volume or Backtest (Baseline testing)"
4. Inside the GKD-BT Backtest, change the setting "Backtest Special" to "Baseline + Volatility/Volume"
5. Import the GKD-V into the GKD-BT Backtest: "Input into C1 or Backtest"
6. Inside the GKD-BT Backtest, change the setting "Backtest Type" to "Full". For this backtest, you must test Longs and Shorts separately
7. To allow the system to open multiple orders at one time so you can test all Longs or Shorts, open the GKD-BT Backtest, click the tab "Properties" and then insert a value of something like 10 orders into the "Pyramiding" settings. This will allow 10 orders to be opened at one time which should be enough to catch all possible Longs or Shorts.

Requirements
Inputs
Confirmation 1: GKD-V Volatility / Volume indicator
Confirmation 2: GKD-C Confirmation indicator
Continuation: GKD-C Confirmation indicator
Solo Confirmation Simple: GKD-B Baseline
Solo Confirmation Complex: GKD-V Volatility / Volume indicator
Solo Confirmation Super Complex: GKD-V Volatility / Volume indicator
Stacked 1: None
Stacked 2+: GKD-C, GKD-V, or GKD-B Stacked 1

Outputs
Confirmation 1: GKD-C Confirmation 2 indicator
Confirmation 2: GKD-C Continuation indicator
Continuation: GKD-E Exit indicator
Solo Confirmation Simple: GKD-BT Backtest
Solo Confirmation Complex: GKD-BT Backtest or GKD-E Exit indicator
Solo Confirmation Super Complex: GKD-C Continuation indicator
Stacked 1: GKD-C, GKD-V, or GKD-B Stacked 2+
Stacked 2+: GKD-C, GKD-V, or GKD-B Stacked 2+ or GKD-BT Backtest

Additional features will be added in future releases.

Phát hành các Ghi chú:

Updated inputs labels

Phát hành các Ghi chú:

Updated for new GKD backtests.

Phát hành các Ghi chú:

Additions and Subtractions:

-All signal logic has been transferred to the new GKD-BT Backtests. You can access these backtests using the links provided below:

GKD-BT Giga Confirmation Stack Backtest:

GKD-BT Giga Stacks Backtest:

GKD-BT Full Giga Kaleidoscope Backtest:

GKD-BT Solo Confirmation Super Complex Backtest:

GKD-BT Solo Confirmation Complex Backtest:

GKD-BT Solo Confirmation Simple Backtest:

-Removed all Confirmation Type options except for "Confirmation" and "Continuation." The "Continuation" type is only used in GKD-BT Solo Confirmation Super Complex Backtest and GKD-BT Full Giga Kaleidoscope Backtest when selecting a Confirmation indicator.

-Added new signal plots based on the selected Confirmation Type. For the "Confirmation" type, only initial Longs and Shorts will be displayed on the indicator. For the "Continuation" type, both initial and continuation signals will be displayed. In both cases, if multiple signal types are present (e.g., middle cross, signal cross), these signals can be controlled using the "Signal Type" option.

-Implemented code optimizations to enhance the rendering speed of signals.

-Streamlined the export process by generating only a single value for export to other indicators or backtests. This exported value is named "Input into NEW GKD-BT Backtest."

Phát hành các Ghi chú:

Updated for multi-ticker GKD.

Phát hành các Ghi chú:

Updated for GKD optimizer.