Code: Select all

input int          inpPeriod1   = 8;                                    // First wpr average smoothing period
input bool         UseRegMa1    = true;                                 // Use First regularized ma 
input double       inpLambda1   = 5;                                    // First Lambda (if using regularized ma's)
enum  enRmaTypes
      {
            ma_rema,                                                    // Regularized exponential moving average 
            ma_rrma,                                                    // Regularized relative maving average
            ma_remaf                                                    // Regularized fast exponential moving average 
      };
input enRmaTypes   inpReMaType1 = ma_rema;                              // First Regularized Ma type
enum  enMaTypes
      {
            ma_adxvma,                                                  // Adxvma
            ma_ahr,                                                     // Ahrens moving average
            ma_alma,                                                    // Arnaud Legoux Moving Average - ALMA
            ma_alxma,                                                   // Alexander moving average - ALXMA
            ma_dema,                                                    // Double exponential moving average - DEMA
            ma_dfema,                                                   // Double fast exponential moving average - DFEMA
            ma_dsema,                                                   // Double smoothed exponential moving average - DSEMA
            ma_dsema2,                                                  // Double smoothed EMA (variation)
            ma_dsemaf,                                                  // Double smoothed fast exponential moving average - DSFEMA
            ma_dswema,                                                  // Double smoothed Wilders exponential moving average - DSWEMA
            ma_dscma,                                                   // Deviation scaled MA - DSCMA
            ma_dwma,                                                    // Double weighted MA - DWMA
            ma_dpwma,                                                   // Double parabolic weighted ma - DPWMA
            ma_edic,                                                    // Ehlers distance coefficient filter - EDIC
            ma_emas,                                                    // Ema derivative - EMAD
            ma_ema,                                                     // Exponential moving average - EMA
            ma_epma,                                                    // End point moving average - EPMA
            ma_emaf,                                                    // Fast exponential moving average - FEMA
            ma_eotf,                                                    // Ehlers Optimal tracking filter
            ma_frama,                                                   // Fractal adaptive moving average - FRAMA
            ma_gchan,                                                   // G Channel average - GCHAN
            ma_hull,                                                    // Hull moving average - HMA
            ma_hulle,                                                   // Hull moving average EMA based - HMAe
            ma_hullf,                                                   // Hull moving average Fast EMA based - HMAf
            //ma_hullr,                                                   // Hull moving average RMA based - HMAr
            ma_hulls,                                                   // Hull moving average Slow ma based - HMAs
            ma_ie2,                                                     // IE/2
            ma_ilinr,                                                   // Integral of linear regression slope
            ma_itl,                                                     // Instantaneous trendline
            ma_jur,                                                     // Jurik smoothing
            ma_lagg,                                                    // Laguerre filter
            ma_leade,                                                   // Leader exponential moving average;
            ma_leadf,                                                   // Leader fast exponential moving average
            ma_leadr,                                                   // Leader relative moving average
            ma_linr,                                                    // Linear regression value - LSMA
            ma_slwma,                                                   // Smoothed linear weighted moving average - SLWMA
            ma_lwma,                                                    // Linear weighted moving average - LWMA
            ma_mcg,                                                     // McGinley Dynamic
            ma_mcg2,                                                    // McGinley Dynamic 2
            ma_mcma,                                                    // McNicholl ema
            ma_nlma,                                                    // Non lag moving average
            ma_nma,                                                     // Natural moving average - NMA
            ma_pdfma,                                                   // Probability density funcion ma (pdfma)
            ma_pema,                                                    // Progressive exponential moving average 
            ma_pfma,                                                    // Progressive fast exponential moving average 
            ma_prma,                                                    // Progressive relative maving average 
            ma_pwma,                                                    // Parabolic weighted moving average - PWMA
            ma_qrma,                                                    // Quadratic regression average
            ma_qwma,                                                    // Quadratic weighted average
            ma_rlma,                                                    // Relative moving average - RLMA
            ma_rma,                                                     // Rolling moving average - RMA
            ma_rmta,                                                    // Recursive moving trendline - RMTA
            ma_rwavg,                                                   // Range weighted average - RWAVG
            ma_rwema,                                                   // Range weighted EMA - RWEMA
            ma_rwemads,                                                 // Range weighted EMA double smooth - RWDSEMA
            ma_rwrma,                                                   // Range weighted RMA - RWRMA
            ma_rwrmads,                                                 // Range weighted RMA double smooth - RWDSRMA
            ma_sma,                                                     // Simple moving average - SMA
            ma_sid,                                                     // Simple decycler - SDEC
            ma_sine,                                                    // Sine weighted moving average
            ma_smma,                                                    // Smoothed moving average - SMMA
            ma_smoo,                                                    // Smoother
            ma_smoo2,                                                   // Smoother JMA like
            ma_ssm,                                                     // Super smoother
            ma_b3p,                                                     // Three pole Ehlers Butterworth
            ma_s3p,                                                     // Three pole Ehlers smoother
            ma_mt3r,                                                    // Fulks/Matulich T3 r adaptive - MT3R;
            ma_tt3r,                                                    // Tillson T3 R adaptive
            ma_tma,                                                     // Triangular moving average - TMA
            ma_tema,                                                    // Triple exponential moving average - TEMA
            ma_trma,                                                    // Triple relative moving average - TRMA
            ma_tsema2,                                                  // Triple smoothed EMA (variation)
            ma_twema,                                                   // Triple wilders exponential moving average - TWEMA
            ma_b2p,                                                     // Two pole Ehlers Butterworth
            ma_s2p,                                                     // Two pole Ehlers smoother
            ma_vidya,                                                   // Vidya
            ma_vema,                                                    // Volume weighted ema
            ma_vfma,                                                    // Volume weighted fast ema
            ma_vrma,                                                    // Volume weighted relative moving average
            ma_vwma,                                                    // Volume weighted moving average - VWMA
            ma_zldema,                                                  // Zero lag dema
            ma_zlhulle,                                                 // Zero lag Hull ema based - ZLHMAe
            ma_zlhullf,                                                 // Zero lag Hull fast ema - ZLHMAf
            ma_zlhulls,                                                 // Zero lag Hull slow ma - ZLHMAs
            ma_zlma,                                                    // Zero lag moving average
            ma_zltema                                                   // Zero lag tema
      };  
input enMaTypes   matype1             = ma_tsema2;                      // First wpr average smoothing method
input int         per1                = 14;                             // First wpr period
enum enPrices
{
         pr_close,                                                      // Close
         pr_open,                                                       // Open
         pr_high,                                                       // High
         pr_low,                                                        // Low
         pr_median,                                                     // Median
         pr_typical,                                                    // Typical
         pr_weighted,                                                   // Weighted
         pr_average,                                                    // Average (high+low+open+close)/4
         pr_medianb,                                                    // Average median body (open+close)/2
         pr_tbiased,                                                    // Trend biased price
         pr_tbiased2,                                                   // Trend biased (extreme) price
         pr_haclose,                                                    // Heiken ashi close
         pr_haopen,                                                     // Heiken ashi open
         pr_hahigh,                                                     // Heiken ashi high
         pr_halow,                                                      // Heiken ashi low
         pr_hamedian,                                                   // Heiken ashi median
         pr_hatypical,                                                  // Heiken ashi typical
         pr_haweighted,                                                 // Heiken ashi weighted
         pr_haaverage,                                                  // Heiken ashi average
         pr_hamedianb,                                                  // Heiken ashi median body
         pr_hatbiased,                                                  // Heiken ashi trend biased price
         pr_hatbiased2,                                                 // Heiken ashi trend biased (extreme) price
         pr_habclose,                                                   // Heiken ashi (better formula) close
         pr_habopen,                                                    // Heiken ashi (better formula) open
         pr_habhigh,                                                    // Heiken ashi (better formula) high
         pr_hablow,                                                     // Heiken ashi (better formula) low
         pr_habmedian,                                                  // Heiken ashi (better formula) median
         pr_habtypical,                                                 // Heiken ashi (better formula) typical
         pr_habweighted,                                                // Heiken ashi (better formula) weighted
         pr_habaverage,                                                 // Heiken ashi (better formula) average
         pr_habmedianb,                                                 // Heiken ashi (better formula) median body
         pr_habtbiased,                                                 // Heiken ashi (better formula) trend biased price
         pr_habtbiased2                                                 // Heiken ashi (better formula) trend biased (extreme) price
      }; 
input enPrices    inpPrice1           = pr_close;                       // First Wpr Price to use
input int         inpPeriod2          = 8;                              // Second wpr average smoothing period
input bool        UseRegMa2           = true;                           // Use Second regularized ma 
input double      inpLambda2          = 5;                              // Second Lambda (if using regularized ma's)
input enRmaTypes  inpReMaType2        = ma_rema;                        // Second Regularized Ma type
input enMaTypes   matype2             = ma_tsema2;                      // Second wpr average smoothing method
input int         per2                = 96;                             // Second wpr period
input enPrices    inpPrice2           = pr_close;                       // Second Wpr Price to use
input double      inpFilter           = 0;                              // Filter to use (<= 0, no filter)
input int         inpFilPer1          = 0;                              // Filter period (0 to use wpr period 1)
input int         inpFilPer2          = 0;                              // Filter period (0 to use wpr period 2)
enum  enFilWhat
      {
         flt_fwpr,                                                      // FAST wpr
         flt_swpr,                                                      // SLOW wpr 
         flt_all                                                        // BOTH wpr's
      };
input enFilWhat   inpFilOn            = flt_all;                        // Apply filter to: